@systemdox/mcp-server 0.1.49 → 0.1.51

package/dist/server.js

@@ -0,0 +1,3582 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/get-guardrails.ts
+import { z } from "zod";
+
+// src/lib/language.ts
+var EXTENSION_MAP = {
+  ".py": { language: "python", categories: ["api", "backend", "data-access"] },
+  ".ts": { language: "typescript", categories: ["frontend", "api"] },
+  ".tsx": { language: "typescript", categories: ["frontend"] },
+  ".js": { language: "javascript", categories: ["frontend"] },
+  ".jsx": { language: "javascript", categories: ["frontend"] },
+  ".yaml": {
+    language: "cloudformation",
+    categories: ["infrastructure", "architecture"]
+  },
+  ".yml": {
+    language: "cloudformation",
+    categories: ["infrastructure", "architecture"]
+  },
+  ".json": { language: "json", categories: ["configuration"] },
+  ".css": { language: "css", categories: ["frontend"] },
+  ".html": { language: "html", categories: ["frontend"] },
+  ".sql": { language: "sql", categories: ["data-access"] },
+  ".sh": { language: "shell", categories: ["infrastructure"] },
+  ".bash": { language: "shell", categories: ["infrastructure"] },
+  ".tf": { language: "terraform", categories: ["infrastructure"] },
+  ".md": { language: "markdown", categories: ["documentation"] }
+};
+var PATH_CATEGORY_RULES = [
+  { pattern: /backend\/functions\//, categories: ["api", "backend"] },
+  { pattern: /backend\/layers\//, categories: ["backend"] },
+  { pattern: /backend\//, categories: ["backend"] },
+  { pattern: /apps\/app\//, categories: ["frontend"] },
+  { pattern: /apps\/website\//, categories: ["frontend"] },
+  { pattern: /apps\/portal\//, categories: ["frontend"] },
+  { pattern: /packages\/ui\//, categories: ["frontend"] },
+  { pattern: /infra\//, categories: ["infrastructure"] },
+  { pattern: /\.github\//, categories: ["infrastructure"] },
+  { pattern: /tests?\//, categories: ["testing"] },
+  { pattern: /spec/, categories: ["testing"] },
+  { pattern: /docs\/adr/, categories: ["architecture"] },
+  { pattern: /template\.yaml$/, categories: ["infrastructure", "architecture"] }
+];
+function detectLanguage(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return EXTENSION_MAP[ext];
+}
+function detectCategories(filePaths) {
+  const categories = /* @__PURE__ */ new Set();
+  for (const filePath of filePaths) {
+    const langInfo = detectLanguage(filePath);
+    if (langInfo) {
+      for (const cat of langInfo.categories) {
+        categories.add(cat);
+      }
+    }
+    for (const rule of PATH_CATEGORY_RULES) {
+      if (rule.pattern.test(filePath)) {
+        for (const cat of rule.categories) {
+          categories.add(cat);
+        }
+      }
+    }
+  }
+  return Array.from(categories);
+}
+function detectLanguages(filePaths) {
+  const languages = /* @__PURE__ */ new Set();
+  for (const filePath of filePaths) {
+    const info = detectLanguage(filePath);
+    if (info) languages.add(info.language);
+  }
+  return Array.from(languages);
+}
+
+// src/lib/deprecation.ts
+var LEGACY_TOOL_REMOVAL_EARLIEST = "2027-01-31";
+function legacyToolDescription(canonical, description) {
+  return `DEPRECATED \u2014 use \`${canonical}\` instead. This name still works and will not be removed before ${LEGACY_TOOL_REMOVAL_EARLIEST}. ${description}`;
+}
+
+// src/lib/config-links.ts
+async function workspaceBase(apiClient) {
+  try {
+    const access = await apiClient.get(
+      "/v1/docs/portal-access"
+    );
+    const slug = (access.host ?? "").split(".")[0];
+    return slug ? `https://${slug}.systemdox.com` : null;
+  } catch {
+    return null;
+  }
+}
+function configLink(path, base) {
+  return base ? `${base}${path}` : `${path} in your SystemDox workspace`;
+}
+
+// src/tools/get-guardrails.ts
+var DESCRIPTION = "Retrieve SystemDox checks (banned patterns, required patterns, coding rules). Filter by language, category, or file path to get only relevant checks.";
+var inputSchema = () => ({
+  language: z.string().optional().describe(
+    "Filter by programming language (python, typescript, javascript, cloudformation)"
+  ),
+  category: z.string().optional().describe(
+    "Filter by category (imports, auth, error-handling, architecture, testing, security, conventions, data-access)"
+  ),
+  file_path: z.string().optional().describe(
+    "File path being edited \u2014 language is auto-detected from the extension"
+  )
+});
+function registerGetGuardrails(server, apiClient) {
+  const handler = async ({
+    language,
+    category,
+    file_path
+  }) => {
+    const guardrails = await apiClient.get("/v1/guardrails");
+    let filtered = guardrails;
+    const lang = language ?? (file_path ? detectLanguage(file_path)?.language : void 0);
+    if (lang) {
+      filtered = filtered.filter(
+        (g) => g.description.toLowerCase().includes(lang.toLowerCase()) || g.category.toLowerCase().includes(lang.toLowerCase()) || g.title.toLowerCase().includes(lang.toLowerCase())
+      );
+    }
+    if (category) {
+      filtered = filtered.filter(
+        (g) => g.category.toLowerCase() === category.toLowerCase()
+      );
+    }
+    if (filtered.length === 0) {
+      const text4 = guardrails.length === 0 ? `No checks found. Add checks at ${configLink("/docs/guardrails", await workspaceBase(apiClient))}` : `No checks found${lang ? ` for language "${lang}"` : ""}${category ? ` in category "${category}"` : ""}.`;
+      return {
+        content: [{ type: "text", text: text4 }]
+      };
+    }
+    const text3 = filtered.map(
+      (g) => `## ${g.title} [${g.severity}]
+
+${g.description}
+
+` + (g.pattern ? `**Bad pattern:**
+\`\`\`
+${g.pattern}
+\`\`\`
+
+` : "") + (g.fix ? `**Correct pattern:**
+\`\`\`
+${g.fix}
+\`\`\`
+
+` : "") + (g.fitnessTest ? `**Detection:** \`${g.fitnessTest}\`
+` : "")
+    ).join("\n---\n\n");
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Found ${filtered.length} check(s):
+
+${text3}`
+        }
+      ]
+    };
+  };
+  server.registerTool(
+    "get_checks",
+    {
+      title: "Get Checks",
+      description: DESCRIPTION,
+      inputSchema: inputSchema()
+    },
+    handler
+  );
+  server.registerTool(
+    "get_guardrails",
+    {
+      title: "Get Checks (legacy name)",
+      description: legacyToolDescription("get_checks", DESCRIPTION),
+      inputSchema: inputSchema()
+    },
+    handler
+  );
+}
+
+// src/tools/get-specs.ts
+import { z as z2 } from "zod";
+function registerGetSpecs(server, apiClient) {
+  server.registerTool(
+    "get_specs",
+    {
+      title: "Get Specs",
+      description: "Retrieve SystemDox specifications (proposal, requirements with RFC 2119 keywords, Given/When/Then scenarios). Get a specific spec by ID, filter by status, or search by keyword.",
+      inputSchema: {
+        draft_id: z2.string().optional().describe("Specific spec ID to retrieve with full content"),
+        status: z2.enum(["draft", "ready", "archived"]).optional().describe("Filter by status"),
+        search: z2.string().optional().describe("Keyword search across spec names")
+      }
+    },
+    async ({ draft_id, status, search }) => {
+      if (draft_id) {
+        const spec = await apiClient.get(
+          `/v1/specs/${draft_id}`
+        );
+        const sections = [`# ${spec.name}
+
+**Status:** ${spec.status}`];
+        if (spec.proposalContent) {
+          sections.push(`## Proposal
+
+${spec.proposalContent}`);
+        }
+        if (spec.requirements.length > 0) {
+          const reqs = spec.requirements.map((r) => `### ${r.name}
+
+${r.content}`).join("\n\n");
+          sections.push(`## Requirements
+
+${reqs}`);
+        }
+        if (spec.taskContent) {
+          sections.push(`## Tasks
+
+${spec.taskContent}`);
+        }
+        return {
+          content: [{ type: "text", text: sections.join("\n\n") }]
+        };
+      }
+      const specs = await apiClient.get("/v1/specs");
+      let filtered = specs;
+      if (status) {
+        filtered = filtered.filter((s) => s.status === status);
+      }
+      if (search) {
+        const term = search.toLowerCase();
+        filtered = filtered.filter(
+          (s) => s.name.toLowerCase().includes(term)
+        );
+      }
+      if (filtered.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No specs found${status ? ` with status "${status}"` : ""}${search ? ` matching "${search}"` : ""}.`
+            }
+          ]
+        };
+      }
+      const text3 = filtered.map(
+        (s) => `- **${s.name}** (${s.draftId}) \u2014 ${s.status}, ${s.requirementCount} requirements` + (s.repoFullName ? `, repo: ${s.repoFullName}` : "")
+      ).join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Found ${filtered.length} spec(s):
+
+${text3}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/get-docs.ts
+import { z as z3 } from "zod";
+function matchGlob(path, pattern) {
+  const regex = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regex}$`).test(path);
+}
+function registerGetDocs(server, apiClient) {
+  server.registerTool(
+    "get_docs",
+    {
+      title: "Get Docs",
+      description: "Retrieve synced documentation from connected GitHub repositories. Filter by repo, file path pattern, or keyword search. Pass doc_id with section (a heading anchor) or chunk_id to retrieve just that section instead of the whole document.",
+      inputSchema: {
+        repo: z3.string().optional().describe("Filter by repo (owner/repo format)"),
+        path: z3.string().optional().describe("File path glob pattern (e.g., docs/adr/*.md)"),
+        search: z3.string().optional().describe("Keyword search across document content"),
+        doc_id: z3.string().optional().describe(
+          "Specific document ID to retrieve full content"
+        ),
+        section: z3.string().optional().describe(
+          "Heading anchor (e.g. 'rollback-strategy') \u2014 with doc_id, returns just that section"
+        ),
+        chunk_id: z3.string().optional().describe(
+          "Section chunk id ('{path_hash}#{anchor}') from get_context \u2014 with doc_id, returns just that section"
+        )
+      }
+    },
+    async ({ repo, path, search, doc_id, section, chunk_id }) => {
+      if (doc_id) {
+        const anchor = section ?? (chunk_id ? chunk_id.split("#").pop() : void 0);
+        const doc = await apiClient.get(
+          `/v1/docs/${encodeURIComponent(doc_id)}/content`,
+          anchor ? { section: anchor } : void 0
+        );
+        if (doc.error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error retrieving document: ${doc.error}`
+              }
+            ],
+            isError: true
+          };
+        }
+        let text4 = doc.content;
+        if (anchor && doc.section_resolved === false) {
+          text4 = `_Section "${anchor}" not found \u2014 returning the full document._
+
+` + text4;
+        } else if (anchor && doc.heading) {
+          text4 = `## ${doc.heading}
+
+${doc.content}`;
+        }
+        return {
+          content: [{ type: "text", text: text4 }]
+        };
+      }
+      const params = {};
+      if (repo) params.repo = repo;
+      if (search) params.q = search;
+      const response = await apiClient.get(
+        "/v1/docs",
+        params
+      );
+      let items = response.items;
+      if (path) {
+        items = items.filter((item) => matchGlob(item.path, path));
+      }
+      if (items.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No documents found${repo ? ` in ${repo}` : ""}${path ? ` matching "${path}"` : ""}${search ? ` for "${search}"` : ""}.`
+            }
+          ]
+        };
+      }
+      const text3 = items.map((d) => {
+        const sections = (d.outline ?? []).slice(0, 8);
+        const sectionHint = sections.length > 0 ? `
+  sections: ${sections.map((s) => s.anchor).join(", ")}` : "";
+        return `- **${d.title}** \u2014 \`${d.repo_full_name}/${d.path}\` (${d.doc_type}, ${d.size} bytes, synced ${d.synced_at})
+  doc_id: \`${d.id}\`` + (d.snippet ? `
+  > ${d.snippet}` : "") + sectionHint;
+      }).join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Found ${items.length} document(s) (${response.total} total):
+
+${text3}
+
+Use doc_id for full content, or doc_id + section to fetch one section.`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/get-tech-stack.ts
+function registerGetTechStack(server, apiClient) {
+  server.registerTool(
+    "get_tech_stack",
+    {
+      title: "Get Tech Stack",
+      description: "Retrieve the configured technology stack (languages, frameworks, databases, infrastructure) with versions and notes."
+    },
+    async () => {
+      const stack = await apiClient.get(
+        "/v1/ai/settings/stack"
+      );
+      if (stack.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No tech stack entries configured. Add your stack at ${configLink("/docs/tech-stack", await workspaceBase(apiClient))}`
+            }
+          ]
+        };
+      }
+      const grouped = /* @__PURE__ */ new Map();
+      for (const entry of stack) {
+        const list = grouped.get(entry.category) ?? [];
+        list.push(entry);
+        grouped.set(entry.category, list);
+      }
+      const sections = Array.from(grouped.entries()).map(([category, entries2]) => {
+        const items = entries2.map(
+          (e) => `- ${e.name}${e.version ? ` v${e.version}` : ""}${e.notes ? ` \u2014 ${e.notes}` : ""}`
+        ).join("\n");
+        return `### ${category}
+${items}`;
+      }).join("\n\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Tech stack (${stack.length} entries):
+
+${sections}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/get-planning-context.ts
+import { z as z4 } from "zod";
+function registerGetPlanningContext(server, apiClient) {
+  server.registerTool(
+    "get_planning_context",
+    {
+      title: "Get Planning Context",
+      description: "Retrieve org-wide planning context: connected repos with summaries, cross-repo dependencies, ADRs, and active specs. Optionally focus on a target repo.",
+      inputSchema: {
+        target_repo: z4.string().optional().describe(
+          "Focus on a specific repo (owner/repo format) to get its CLAUDE.md and relevant context"
+        )
+      }
+    },
+    async ({ target_repo }) => {
+      const params = {};
+      if (target_repo) params.targetRepo = target_repo;
+      const ctx = await apiClient.get(
+        "/v1/org/planning-context",
+        params
+      );
+      const sections = [];
+      if (ctx.repoSummaries.length > 0) {
+        const repos = ctx.repoSummaries.map(
+          (r) => `#### ${r.repo}
+${r.purpose}
+
+${r.summary}` + (r.conventions.length > 0 ? `
+
+**Conventions:**
+${r.conventions.map((c) => `- ${c}`).join("\n")}` : "")
+        ).join("\n\n");
+        sections.push(`## Repositories (${ctx.repoSummaries.length})
+
+${repos}`);
+      }
+      if (ctx.dependencies.length > 0) {
+        const deps = ctx.dependencies.map((d) => `- ${d.from} \u2192 ${d.to}${d.provenance === "inferred" ? " (inferred)" : ""}`).join("\n");
+        sections.push(`## Cross-Repo Dependencies
+
+${deps}`);
+      }
+      if (ctx.adrs.length > 0) {
+        const adrs = ctx.adrs.map((a) => `- ${a.title}${a.repo ? ` (${a.repo})` : ""}`).join("\n");
+        sections.push(`## Architecture Decision Records (${ctx.adrs.length})
+
+${adrs}`);
+      }
+      if (ctx.specs.length > 0) {
+        const specs = ctx.specs.map((s) => `- ${s.name} [${s.status}]`).join("\n");
+        sections.push(`## Specs (${ctx.specs.length})
+
+${specs}`);
+      }
+      if (sections.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No planning context available. Connect repositories at ${configLink("/settings/github", await workspaceBase(apiClient))}`
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: sections.join("\n\n")
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/get-plan-board.ts
+import { z as z5 } from "zod";
+var API_ITEM_PAGE = 100;
+var DEFAULT_LIMIT = 50;
+var BUCKET_LABELS = {
+  inProgress: "In Progress",
+  todo: "Todo",
+  done: "Done"
+};
+var BUCKET_ORDER = ["inProgress", "todo", "done"];
+var STATUS_ARG_TO_BUCKET = {
+  todo: "todo",
+  in_progress: "inProgress",
+  done: "done"
+};
+function bucketOf(item) {
+  const status = (item.fields?.Status ?? "").trim().toLowerCase();
+  if (status) {
+    if (status.includes("done") || status.includes("ship") || status.includes("complete")) {
+      return "done";
+    }
+    if (status.includes("progress") || status.includes("doing") || status.includes("review")) {
+      return "inProgress";
+    }
+    return "todo";
+  }
+  return item.state === "CLOSED" ? "done" : "todo";
+}
+function formatBoards(boards) {
+  const lines = boards.map((b) => {
+    const c = b.statusCounts ?? { todo: 0, inProgress: 0, done: 0 };
+    return `- **${b.title}** \u2014 board #${b.number} \xB7 ${b.itemCount} item(s) (todo ${c.todo} \xB7 in progress ${c.inProgress} \xB7 done ${c.done})` + (b.description ? `
+  ${b.description}` : "") + `
+  ${b.url}`;
+  });
+  return lines.join("\n");
+}
+function formatItem(item) {
+  const meta = [];
+  if (item.labels.length > 0) meta.push(`labels: ${item.labels.join(", ")}`);
+  if (item.assignees.length > 0)
+    meta.push(`assignees: ${item.assignees.join(", ")}`);
+  const epic = item.fields?.Epic;
+  if (epic) meta.push(`epic: ${epic}`);
+  return `- #${item.number} ${item.title}${item.repo ? ` \u2014 ${item.repo}` : ""}` + (meta.length > 0 ? `
+  ${meta.join(" \xB7 ")}` : "") + (item.url ? `
+  ${item.url}` : "");
+}
+function registerGetPlanBoard(server, apiClient) {
+  server.registerTool(
+    "get_plan_board",
+    {
+      title: "Get Plan Board",
+      description: "Read the GitHub Projects boards connected to this workspace. With no arguments, lists the open boards with their item counts by status. With project_number, lists that board's issues grouped by status (In Progress / Todo / Done), each with issue number, title, repo, labels, assignees and URL \u2014 so you can see what is planned or in flight and pick up the right issue. Read-only: this tool cannot create, move, or close board items.",
+      inputSchema: {
+        project_number: z5.number().int().positive().optional().describe(
+          "Board number (the N in github.com/orgs/{org}/projects/N). Omit to list the open boards."
+        ),
+        status: z5.enum(["todo", "in_progress", "done"]).optional().describe(
+          "With project_number, return only the items in this status group"
+        ),
+        limit: z5.number().int().positive().max(200).optional().describe(
+          `Max items to list (default ${DEFAULT_LIMIT}). Group headings always show the true totals.`
+        )
+      }
+    },
+    async ({ project_number, status, limit }) => {
+      if (project_number === void 0) {
+        const boards = await apiClient.get(
+          "/v1/planning/projects"
+        );
+        if (boards.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No project boards found. Connect a GitHub organisation and create a board at ${configLink("/plan", await workspaceBase(apiClient))}`
+              }
+            ]
+          };
+        }
+        const open = boards.filter((b) => !b.closed);
+        if (open.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No open project boards (${boards.length} closed). Reopen one, or create a board at ${configLink("/plan", await workspaceBase(apiClient))}`
+              }
+            ]
+          };
+        }
+        const closedNote = boards.length > open.length ? `
+
+_${boards.length - open.length} closed board(s) not listed._` : "";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${open.length} open project board(s):
+
+${formatBoards(open)}` + closedNote + `
+
+Call get_plan_board with project_number to list a board's issues.`
+            }
+          ]
+        };
+      }
+      const response = await apiClient.get(
+        `/v1/planning/projects/${project_number}/items`
+      );
+      const allItems = response.items ?? [];
+      const boardName = response.projectTitle ? `**${response.projectTitle}** \u2014 board #${project_number}` : `Board #${project_number}`;
+      if (allItems.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${boardName} has no issues, or it is not visible to this workspace's GitHub connection. Check the board at ${configLink("/plan", await workspaceBase(apiClient))}`
+            }
+          ]
+        };
+      }
+      const grouped = {
+        inProgress: [],
+        todo: [],
+        done: []
+      };
+      for (const item of allItems) grouped[bucketOf(item)].push(item);
+      const wanted = status ? [STATUS_ARG_TO_BUCKET[status]] : BUCKET_ORDER;
+      const shown = wanted.reduce((n, b) => n + grouped[b].length, 0);
+      if (shown === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${boardName}: no items with status "${status}" (of ${allItems.length} item(s) on the board).`
+            }
+          ]
+        };
+      }
+      const cap = limit ?? DEFAULT_LIMIT;
+      let budget = cap;
+      const sections = [];
+      let rendered = 0;
+      for (const b of wanted) {
+        const items = grouped[b];
+        if (items.length === 0) continue;
+        const slice = items.slice(0, Math.max(budget, 0));
+        budget -= slice.length;
+        rendered += slice.length;
+        const omitted = items.length - slice.length;
+        sections.push(
+          `### ${BUCKET_LABELS[b]} (${items.length})
+` + (slice.length > 0 ? slice.map(formatItem).join("\n") : "_(not listed \u2014 item limit reached)_") + (omitted > 0 && slice.length > 0 ? `
+_\u2026${omitted} more not listed._` : "")
+        );
+      }
+      const notes = [];
+      if (rendered < shown) {
+        notes.push(
+          `_Listing ${rendered} of ${shown} matching item(s) \u2014 raise limit (max 200) or filter by status to see the rest._`
+        );
+      }
+      if (allItems.length >= API_ITEM_PAGE) {
+        notes.push(
+          `_The API reads the board's first ${API_ITEM_PAGE} items; a larger board may have more._`
+        );
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${boardName} \u2014 ${allItems.length} item(s)
+
+` + sections.join("\n\n") + (notes.length > 0 ? `
+
+${notes.join("\n")}` : "")
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/get-change.ts
+import { z as z6 } from "zod";
+var GITHUB_NAME = "[A-Za-z0-9][A-Za-z0-9._-]{0,99}";
+var REPO_RE = new RegExp(`^${GITHUB_NAME}/${GITHUB_NAME}$`);
+var SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var SLUG_MAX = 64;
+var PARTS = ["decision", "contract", "behaviour", "plan", "release"];
+var BRIEF = ["decision", "contract", "behaviour", "plan"];
+var PAST_REVIEW = /* @__PURE__ */ new Set(["passed", "being built", "done"]);
+function briefVerdict(states) {
+  const waiting = BRIEF.filter(
+    (part) => !(part === "decision" && states.decision === null) && !PAST_REVIEW.has(String(states[part]))
+  ).map((part) => `${part} is ${states[part] ?? "unknown"}`);
+  return waiting.length === 0 ? "The brief is passed" : `The brief is not passed: ${waiting.join(", ")}`;
+}
+function prLink(pr) {
+  return `[${pr.repo}#${pr.number}](${pr.url}) ${pr.state}`;
+}
+function fileSource(file) {
+  if (file.pullRequest) return prLink(file.pullRequest);
+  return file.direct ? "committed directly" : "\u2014";
+}
+function partPullRequests(change, part) {
+  const files = part === "contract" ? change.contract.files : part === "behaviour" ? change.behaviour.files : part === "plan" ? [change.plan.file] : [];
+  const prs = part === "decision" ? [change.decision?.pullRequest ?? null] : part === "release" ? change.release.prs : files.map((file) => file?.pullRequest ?? null);
+  const unique = /* @__PURE__ */ new Map();
+  for (const pr of prs) {
+    if (pr && !unique.has(`${pr.repo}#${pr.number}`)) unique.set(`${pr.repo}#${pr.number}`, pr);
+  }
+  return [...unique.values()].sort((a, b) => Number(b.state === "open") - Number(a.state === "open"));
+}
+function countsLine(counts) {
+  const tags = ["proposed", "built", "defect", "unbuilt", "open", "untagged"].filter((tag) => counts[tag] > 0).map((tag) => `${counts[tag]} ${tag}`);
+  return `${counts.total} scenario(s)` + (tags.length > 0 ? `: ${tags.join(", ")}` : "");
+}
+function partsTable(change) {
+  const rows = PARTS.filter((part) => !(part === "decision" && change.states.decision === null)).map((part) => {
+    const prs = partPullRequests(change, part);
+    return `| ${part} | ${change.states[part]} | ${prs.length > 0 ? prs.map(prLink).join(", ") : "\u2014"} |`;
+  });
+  return ["| Part | State | Pull request |", "|---|---|---|", ...rows].join("\n");
+}
+function decisionSection(change) {
+  const decision = change.decision;
+  if (decision === null) return "## Decision\n\nNone: the proposal names no ADR (a small change).";
+  const status = decision.status || "no record in a connected repository";
+  return `## Decision
+
+${decision.adr} \xB7 ${status}${decision.title ? ` \u2014 ${decision.title}` : ""}`;
+}
+function contractSection(change) {
+  const files = change.contract.files;
+  return "## Contract\n\n" + (files.length > 0 ? files.map((file) => `- ${file.path} \u2014 ${fileSource(file)}`).join("\n") : "No contract file yet (openapi.yaml, asyncapi.yaml or contract.md).");
+}
+function behaviourSection(change) {
+  const { files, counts } = change.behaviour;
+  if (files.length === 0) {
+    return `## Behaviour
+
+No feature file names this change. A feature file joins it when its path or its first ten lines name \`${change.slug}\`${change.decision ? ` or ${change.decision.adr}` : ""}.`;
+  }
+  const blocks = files.map(
+    (file) => [
+      `### ${file.path}`,
+      "",
+      [file.title, file.runner ? `runner ${file.runner}` : "", fileSource(file), countsLine(file.counts)].filter(Boolean).join(" \xB7 "),
+      "",
+      ...file.scenarios.map((s) => `- ${s.id || "(no id)"} \xB7 ${s.state || "untagged"} \xB7 ${s.title}`)
+    ].join("\n")
+  );
+  return ["## Behaviour", countsLine(counts), ...blocks].join("\n\n");
+}
+function planSection(change) {
+  const { file, draftId, board } = change.plan;
+  const boardLine = board ? `[#${board.number} ${board.title}](${board.url}) \u2014 todo ${board.items.todo} \xB7 in progress ${board.items.inProgress} \xB7 done ${board.items.done}` + (board.items.truncated ? " (counted over its first 500 items)" : "") : "none";
+  return [
+    "## Plan",
+    "",
+    `- plan.md: ${file ? `${file.path} \u2014 ${fileSource(file)}` : "none"}`,
+    `- Draft: ${draftId ?? "none"}`,
+    `- Board: ${boardLine}`
+  ].join("\n");
+}
+function releaseSection(change) {
+  const lines = change.release.prs.map(
+    (pr) => `- ${prLink(pr)} \xB7 ${pr.title} \xB7 ` + (pr.approvingReview ? `approved by ${pr.approvingReview.by} at ${pr.approvingReview.at}` : "no approving review on its head yet")
+  );
+  return `## Release
+
+${lines.length > 0 ? lines.join("\n") : "No release pull request is open."}`;
+}
+function formatChange(change) {
+  const header = `# ${change.title}
+
+\`${change.key}\` \xB7 size: ${change.size}` + (change.archived ? " \xB7 archived: read-only, done" : "") + ` \xB7 synced ${change.syncedAt}`;
+  return [
+    header,
+    partsTable(change),
+    decisionSection(change),
+    contractSection(change),
+    behaviourSection(change),
+    planSection(change),
+    releaseSection(change),
+    // Compact: a change's every scenario with its steps rides in this block.
+    "```json\n" + JSON.stringify(change) + "\n```",
+    briefVerdict(change.states)
+  ].join("\n\n");
+}
+function registerGetChange(server, apiClient) {
+  server.registerTool(
+    "get_change",
+    {
+      title: "Get Change",
+      description: `Read one change (a specs/changes/<slug>/ folder of a connected repository) as SystemDox last synced it from GitHub: the state of each part of its brief (decision, contract, behaviour, plan) and of its release, each with its pull request; the decision's ADR and status; the contract files; every feature file that names the change, with its scenarios as id \xB7 state \xB7 title; the plan (plan.md, the draft, the board); the release pull requests; and the Change object as JSON. The last line says "The brief is passed" or "The brief is not passed: <part> is <state>". Call it before building a story, and stop if the brief is not passed or the story's scenarios are not proposed. Read-only.`,
+      inputSchema: {
+        repo: z6.string().regex(REPO_RE, "the repository as owner/name, e.g. acme/booking-api").describe("The repository that holds the change, as owner/name"),
+        slug: z6.string().max(SLUG_MAX).regex(SLUG_RE, "a change folder's name: lower-case words joined by -, e.g. customer-reminders").describe("The change's folder name: specs/changes/<slug>/")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ repo, slug }) => {
+      const [owner, name] = repo.split("/");
+      let change;
+      try {
+        change = await apiClient.getFresh(
+          `/v1/changes/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/${encodeURIComponent(slug)}`
+        );
+      } catch (err) {
+        if (err.status === 404) {
+          return {
+            content: [{ type: "text", text: `No such change ${repo}/${slug}` }],
+            isError: true
+          };
+        }
+        throw err;
+      }
+      return { content: [{ type: "text", text: formatChange(change) }] };
+    }
+  );
+}
+
+// src/tools/get-context.ts
+import { z as z7 } from "zod";
+
+// src/lib/scoring.ts
+var WEIGHT_PATH = 0.4;
+var WEIGHT_KEYWORD = 0.3;
+var WEIGHT_RECENCY = 0.15;
+var WEIGHT_SEVERITY = 0.15;
+var SEVERITY_SCORES = {
+  critical: 1,
+  high: 0.75,
+  medium: 0.5,
+  low: 0.25
+};
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text3) {
+  return Math.ceil(text3.length / CHARS_PER_TOKEN);
+}
+function truncateToTokens(text3, maxTokens) {
+  const maxChars = Math.max(0, maxTokens) * CHARS_PER_TOKEN;
+  if (text3.length <= maxChars) return { text: text3, truncated: false };
+  const head = text3.slice(0, maxChars);
+  const floor = Math.floor(maxChars * 0.75);
+  const paragraph = head.lastIndexOf("\n\n");
+  const line = head.lastIndexOf("\n");
+  let cut = maxChars;
+  if (paragraph >= floor) cut = paragraph;
+  else if (line >= floor) cut = line;
+  return { text: head.slice(0, cut).trimEnd(), truncated: true };
+}
+function scorePathMatch(item, languages, categories) {
+  if (languages.length === 0 && categories.length === 0) return 0.5;
+  let score = 0;
+  const itemLang = item.language?.toLowerCase() ?? "";
+  const itemCat = item.category?.toLowerCase() ?? "";
+  if (itemLang && languages.some((l) => itemLang.includes(l))) {
+    score += 0.6;
+  }
+  if (itemCat && categories.some((c) => itemCat.includes(c))) {
+    score += 0.4;
+  }
+  return Math.min(score, 1);
+}
+function scoreKeywordMatch(item, keywords) {
+  if (keywords.length === 0) return 0;
+  const searchable = `${item.title} ${item.content}`.toLowerCase();
+  let matches = 0;
+  for (const kw of keywords) {
+    if (searchable.includes(kw)) matches++;
+  }
+  return Math.min(matches / keywords.length, 1);
+}
+function scoreRecency(item) {
+  if (!item.updatedAt) return 0.5;
+  const now = Date.now();
+  const updated = new Date(item.updatedAt).getTime();
+  const daysSince = (now - updated) / (1e3 * 60 * 60 * 24);
+  if (daysSince <= 7) return 1;
+  if (daysSince <= 30) return 0.75;
+  if (daysSince <= 90) return 0.5;
+  return 0.25;
+}
+function scoreSeverity(item) {
+  if (!item.severity) return 0.5;
+  return SEVERITY_SCORES[item.severity] ?? 0.5;
+}
+function extractKeywords(text3) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "can",
+    "shall",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "about",
+    "between",
+    "through",
+    "after",
+    "before",
+    "during",
+    "without",
+    "this",
+    "that",
+    "these",
+    "those",
+    "it",
+    "its",
+    "and",
+    "or",
+    "but",
+    "not",
+    "no",
+    "all",
+    "each",
+    "every",
+    "both",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "than",
+    "too",
+    "very",
+    "just",
+    "also",
+    "only",
+    "new",
+    "add",
+    "update",
+    "fix",
+    "change",
+    "make",
+    "use",
+    "get",
+    "set",
+    "need",
+    "want",
+    "implement",
+    "create"
+  ]);
+  return text3.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+}
+function scoreItems(items, taskDescription, filePaths) {
+  const languages = detectLanguages(filePaths);
+  const categories = detectCategories(filePaths);
+  const keywords = extractKeywords(taskDescription);
+  return items.map((item) => {
+    const pathScore = scorePathMatch(item, languages, categories);
+    const keywordScore = scoreKeywordMatch(item, keywords);
+    const recencyScore = scoreRecency(item);
+    const severityScore = scoreSeverity(item);
+    const score = pathScore * WEIGHT_PATH + keywordScore * WEIGHT_KEYWORD + recencyScore * WEIGHT_RECENCY + severityScore * WEIGHT_SEVERITY;
+    return {
+      type: item.type,
+      id: item.id,
+      title: item.title,
+      content: item.content,
+      score,
+      tokenEstimate: estimateTokens(item.content)
+    };
+  }).sort((a, b) => b.score - a.score);
+}
+function selectWithinBudget(items, maxTokens) {
+  const selected = [];
+  let tokensUsed = 0;
+  for (const item of items) {
+    if (tokensUsed + item.tokenEstimate > maxTokens) continue;
+    selected.push(item);
+    tokensUsed += item.tokenEstimate;
+  }
+  return { selected, tokensUsed, totalItems: items.length };
+}
+
+// src/lib/context-builder.ts
+var DEFAULT_BUDGET = 4e3;
+var RESERVE_TOKENS = 200;
+var GUARDRAIL_SHARE = 0.35;
+var MIN_BODY_TOKENS = 150;
+var MAX_HYDRATED = 8;
+var MAX_TAIL = 10;
+var TAIL_SHARE = 0.15;
+var TRUNCATION_NOTICE_TOKENS = 30;
+function formatGuardrail(g) {
+  let text3 = `## ${g.title} [${g.severity}]
+
+${g.description}`;
+  if (g.pattern) text3 += `
+
+**Bad:** \`\`\`
+${g.pattern}
+\`\`\``;
+  if (g.fix) text3 += `
+
+**Good:** \`\`\`
+${g.fix}
+\`\`\``;
+  return text3;
+}
+function formatSpecHeadline(s) {
+  return `### ${s.name}
+\`draft_id: ${s.draftId}\` \xB7 ${s.status} \xB7 ${s.requirementCount} requirements`;
+}
+function formatDocHeadline(d) {
+  return `### ${d.title}
+\`doc_id: ${d.id}\` \xB7 \`${d.repo_full_name}/${d.path}\` \xB7 ${d.doc_type}`;
+}
+function formatStack(entries2) {
+  return entries2.map(
+    (e) => `- ${e.name}${e.version ? ` v${e.version}` : ""}${e.notes ? ` \u2014 ${e.notes}` : ""}`
+  ).join("\n");
+}
+function formatRules(rules) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const r of rules) {
+    const cat = r.category || "other";
+    if (!byCategory.has(cat)) byCategory.set(cat, []);
+    byCategory.get(cat).push(r);
+  }
+  let text3 = "";
+  for (const [cat, catRules] of byCategory) {
+    text3 += `### ${cat.charAt(0).toUpperCase() + cat.slice(1)}
+`;
+    for (const r of catRules) {
+      text3 += `- ${r.text}
+`;
+    }
+    text3 += "\n";
+  }
+  return `## Project Rules (${rules.length})
+
+${text3.trim()}`;
+}
+async function fetchSpecBody(api, draftId) {
+  const spec = await api.get(
+    `/v1/specs/${encodeURIComponent(draftId)}`
+  );
+  const parts = [];
+  if (spec.proposalContent) {
+    parts.push(`**Proposal**
+
+${spec.proposalContent}`);
+  }
+  for (const r of spec.requirements ?? []) {
+    parts.push(`**${r.name}**
+
+${r.content}`);
+  }
+  if (spec.taskContent) {
+    parts.push(`**Tasks**
+
+${spec.taskContent}`);
+  }
+  const body = parts.join("\n\n").trim();
+  if (!body) throw new Error("spec has no content");
+  return body;
+}
+async function fetchDocBody(api, docId, anchor) {
+  const doc = await api.get(
+    `/v1/docs/${encodeURIComponent(docId)}/content`,
+    anchor ? { section: anchor } : void 0
+  );
+  if (doc.error) throw new Error(doc.error);
+  const body = (doc.content ?? "").trim();
+  if (!body) throw new Error("document is empty");
+  return body;
+}
+function githubDeepLink(repoFullName, path, anchor) {
+  return `https://github.com/${repoFullName}/blob/HEAD/${path}#${anchor}`;
+}
+function formatSectionPointer(repoFullName, path, s) {
+  return `\`${path}#${s.anchor}\` \xB7 \`chunk_id: ${s.chunkId}\` \xB7 [${s.heading}](${githubDeepLink(repoFullName, path, s.anchor)})`;
+}
+var SECTION_STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "of",
+  "to",
+  "and",
+  "or",
+  "for",
+  "in",
+  "on",
+  "with",
+  "how",
+  "why",
+  "what",
+  "add",
+  "new",
+  "use",
+  "using",
+  "update",
+  "fix"
+]);
+function selectSection(outline, taskDescription) {
+  if (!outline || outline.length === 0) return void 0;
+  const keywords = taskDescription.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !SECTION_STOP_WORDS.has(w));
+  let best = outline[0];
+  let bestScore = -1;
+  for (const s of outline) {
+    const heading = s.heading.toLowerCase();
+    let score = 0;
+    for (const kw of keywords) if (heading.includes(kw)) score++;
+    if (score > bestScore) {
+      best = s;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+async function hydrate(api, item, meta) {
+  try {
+    const body = meta.type === "spec" ? await fetchSpecBody(api, meta.id) : await fetchDocBody(api, meta.id, meta.section?.anchor);
+    return { item, meta, body };
+  } catch (err) {
+    return {
+      item,
+      meta,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function buildContext(api, { taskDescription, filePaths = [], maxTokens }) {
+  const budget = maxTokens ?? DEFAULT_BUDGET;
+  const failures = [];
+  const orEmpty = (empty) => (err) => {
+    failures.push(err);
+    return empty;
+  };
+  const [rawGuardrails, rawSpecs, docs, stack, rules, docRepos] = await Promise.all([
+    api.get("/v1/guardrails").catch(orEmpty([])),
+    api.get("/v1/specs").catch(orEmpty([])),
+    api.get("/v1/docs").catch(orEmpty({ items: [] })),
+    api.get("/v1/ai/settings/stack").catch(orEmpty([])),
+    api.get("/v1/standards/rules").catch(orEmpty([])),
+    // Capability states — FAIL-OPEN: an unreadable config (older backend, a
+    // blip) gates nothing, it can never hide working context.
+    api.get("/v1/doc-repos").catch(() => null)
+  ]);
+  if (failures.length === 5) throw failures[0];
+  const disabled = (key2) => docRepos?.capabilities?.[key2]?.status === "disabled";
+  const guardrails = disabled("fitness") ? [] : rawGuardrails;
+  const specs = disabled("requirements") && disabled("design") && disabled("specs") ? [] : rawSpecs;
+  const refs = /* @__PURE__ */ new Map();
+  const key = (type, id) => `${type}:${id}`;
+  const scorable = [
+    ...guardrails.map((g) => ({
+      type: "guardrail",
+      id: g.id,
+      title: g.title,
+      content: formatGuardrail(g),
+      category: g.category,
+      severity: g.severity,
+      updatedAt: g.updatedAt
+    })),
+    ...specs.filter((s) => s.status !== "archived").map((s) => {
+      refs.set(key("spec", s.draftId), {
+        type: "spec",
+        id: s.draftId,
+        title: s.name,
+        listLine: `- **${s.name}** \u2014 \`draft_id: ${s.draftId}\` (${s.status}, ${s.requirementCount} requirements)`,
+        fetchHint: `get_specs(draft_id="${s.draftId}")`
+      });
+      return {
+        type: "spec",
+        id: s.draftId,
+        title: s.name,
+        content: formatSpecHeadline(s),
+        updatedAt: s.updatedAt
+      };
+    }),
+    ...docs.items.map((d) => {
+      const section = selectSection(d.outline, taskDescription);
+      const pointer = section ? formatSectionPointer(d.repo_full_name, d.path, section) : void 0;
+      refs.set(key("doc", d.id), {
+        type: "doc",
+        id: d.id,
+        title: d.title,
+        section,
+        pointer,
+        listLine: `- **${d.title}** \u2014 \`doc_id: ${d.id}\` (\`${d.repo_full_name}/${d.path}\`)` + (pointer ? `
+  \u21B3 ${pointer}` : ""),
+        fetchHint: section ? `get_docs(doc_id="${d.id}", section="${section.anchor}")` : `get_docs(doc_id="${d.id}")`
+      });
+      return {
+        type: "doc",
+        id: d.id,
+        title: d.title,
+        content: formatDocHeadline(d),
+        category: d.doc_type === "adr" ? "architecture" : void 0,
+        updatedAt: d.synced_at
+      };
+    })
+  ];
+  const ranked = scoreItems(scorable, taskDescription, filePaths);
+  const sections = [];
+  let overhead = 0;
+  if (stack.length > 0) {
+    const section = `## Tech Stack
+
+${formatStack(stack)}`;
+    sections.push(section);
+    overhead += estimateTokens(section);
+  }
+  if (rules.length > 0) {
+    const section = formatRules(rules);
+    sections.push(section);
+    overhead += estimateTokens(section);
+  }
+  let remaining = budget - RESERVE_TOKENS - overhead;
+  const rankedGuardrails = ranked.filter((i) => i.type === "guardrail");
+  const { selected: selectedGuardrails, tokensUsed: guardrailTokens } = selectWithinBudget(
+    rankedGuardrails,
+    Math.max(0, Math.floor(remaining * GUARDRAIL_SHARE))
+  );
+  remaining -= guardrailTokens;
+  const rankedRefs = ranked.filter(
+    (i) => i.type === "spec" || i.type === "doc"
+  );
+  const avgHeadline = rankedRefs.length ? Math.ceil(
+    rankedRefs.slice(0, MAX_HYDRATED).reduce((sum, i) => sum + i.tokenEstimate, 0) / Math.min(rankedRefs.length, MAX_HYDRATED)
+  ) : 0;
+  const affordable = Math.floor(
+    Math.max(0, remaining) / (MIN_BODY_TOKENS + avgHeadline)
+  );
+  const shortlist = rankedRefs.slice(
+    0,
+    Math.max(0, Math.min(MAX_HYDRATED, affordable))
+  );
+  for (const item of shortlist) {
+    remaining -= item.tokenEstimate;
+  }
+  remaining = Math.max(0, remaining);
+  const hydrated = await Promise.all(
+    shortlist.map(
+      (item) => hydrate(api, item, refs.get(key(item.type, item.id)))
+    )
+  );
+  const tailCandidates = rankedRefs.slice(shortlist.length, shortlist.length + MAX_TAIL).map((i) => refs.get(key(i.type, i.id)));
+  const tailCost = tailCandidates.reduce(
+    (sum, m) => sum + estimateTokens(m.listLine),
+    0
+  );
+  const tailReserve = Math.min(
+    tailCost,
+    Math.floor(remaining * TAIL_SHARE)
+  );
+  const bodyBudgetStart = Math.max(0, remaining - tailReserve);
+  let bodyBudget = bodyBudgetStart;
+  let itemsLeft = hydrated.length;
+  let itemsWithBody = 0;
+  let bodyFailures = 0;
+  const blocks = [];
+  for (const h of hydrated) {
+    itemsLeft--;
+    const headline = h.meta.pointer ? `${h.item.content}
+${h.meta.pointer}` : h.item.content;
+    const emit = (block) => {
+      bodyBudget -= Math.max(
+        0,
+        estimateTokens(block) - h.item.tokenEstimate
+      );
+      blocks.push(block);
+    };
+    if (h.error !== void 0) {
+      bodyFailures++;
+      emit(
+        `${headline}
+
+_Body unavailable (${h.error}) \u2014 retry with \`${h.meta.fetchHint}\`._`
+      );
+      continue;
+    }
+    const available = Math.max(0, bodyBudget);
+    const allowance = Math.min(
+      Math.max(MIN_BODY_TOKENS, Math.floor(available / (itemsLeft + 1))),
+      available
+    );
+    if (allowance < MIN_BODY_TOKENS) {
+      emit(
+        `${headline}
+
+_Body omitted (token budget exhausted) \u2014 fetch with \`${h.meta.fetchHint}\`._`
+      );
+      continue;
+    }
+    const { text: body2, truncated } = truncateToTokens(
+      h.body,
+      allowance - TRUNCATION_NOTICE_TOKENS
+    );
+    itemsWithBody++;
+    emit(
+      `${headline}
+
+${body2}` + (truncated ? `
+
+_[truncated to fit the token budget \u2014 full text via \`${h.meta.fetchHint}\`]_` : "")
+    );
+  }
+  remaining = Math.max(0, remaining - (bodyBudgetStart - bodyBudget));
+  if (selectedGuardrails.length > 0) {
+    sections.push(
+      `## Checks (${selectedGuardrails.length})
+
+` + selectedGuardrails.map((i) => i.content).join("\n\n---\n\n")
+    );
+  }
+  if (blocks.length > 0) {
+    sections.push(
+      `## Relevant Specs & Docs (${blocks.length})
+
+_Highest-ranked items \u2014 docs are scoped to their most relevant section. Each carries the ID / \`chunk_id\` to fetch more._
+
+` + blocks.join("\n\n---\n\n")
+    );
+  }
+  const tailLines = [];
+  for (const meta of tailCandidates) {
+    const cost = estimateTokens(meta.listLine);
+    if (cost > remaining) break;
+    tailLines.push(meta.listLine);
+    remaining -= cost;
+  }
+  if (tailLines.length > 0) {
+    sections.push(
+      `## Also Indexed (${tailLines.length})
+
+_Ranked lower \u2014 fetch with \`get_specs\` / \`get_docs\` if you need them._
+
+` + tailLines.join("\n")
+    );
+  }
+  const itemsListed = blocks.length - itemsWithBody + tailLines.length;
+  const itemsOmitted = ranked.length - selectedGuardrails.length - blocks.length - tailLines.length;
+  const body = sections.join("\n\n");
+  const tokensUsed = estimateTokens(body);
+  const stats = {
+    budget,
+    tokensUsed,
+    itemsWithBody,
+    bodyFailures,
+    itemsListed,
+    itemsOmitted: Math.max(0, itemsOmitted),
+    guardrails: selectedGuardrails.length
+  };
+  if (sections.length === 0) {
+    const text3 = failures.length ? `No context found for this task, but ${failures.length} of 5 reads failed, so this is not an all-clear: the team's rules may not have been read.` : "No relevant context found for this task.";
+    return { text: text3, stats };
+  }
+  const footer = `
+
+---
+_Context: ${itemsWithBody} full text, ${itemsListed} listed, ${stats.itemsOmitted} omitted \xB7 ~${tokensUsed} of ${budget} tokens` + (bodyFailures > 0 ? ` \xB7 ${bodyFailures} body fetch(es) failed` : "") + (failures.length > 0 ? ` \xB7 ${failures.length} of 5 reads failed` : "") + `_`;
+  return { text: body + footer, stats };
+}
+
+// src/tools/get-context.ts
+function registerGetContext(server, apiClient) {
+  server.registerTool(
+    "get_context",
+    {
+      title: "Get Context",
+      description: "Intelligent context aggregator: fetches checks, specs, docs, and tech stack, ranks them by relevance to your current task, and returns the full text of the highest-ranked items within a token budget \u2014 each with the ID needed to fetch the rest. Use this instead of calling individual tools when you want curated, relevant context.",
+      inputSchema: {
+        task_description: z7.string().describe(
+          "What you're working on (e.g., 'add a new REST endpoint for user preferences')"
+        ),
+        file_paths: z7.array(z7.string()).optional().describe(
+          "File paths being edited \u2014 used for language/category detection"
+        ),
+        max_tokens: z7.number().optional().describe("Maximum token budget for the response (default: 4000)")
+      }
+    },
+    async ({ task_description, file_paths, max_tokens }) => {
+      const { text: text3 } = await buildContext(apiClient, {
+        taskDescription: task_description,
+        filePaths: file_paths,
+        maxTokens: max_tokens
+      });
+      return {
+        content: [{ type: "text", text: text3 }]
+      };
+    }
+  );
+}
+
+// src/lib/session-brief.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/lib/skills.ts
+import { createHash } from "crypto";
+import { lstat, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, relative, resolve, sep } from "path";
+var MANIFEST_FILE = ".systemdox-skill.json";
+var ENTRY_FILE = "SKILL.md";
+var PLUGIN_MANIFEST_FOLDER = ".claude-plugin";
+var MAX_FILES = 100;
+var MAX_FILE_BYTES = 256 * 1024;
+var MAX_TOTAL_BYTES = 1024 * 1024;
+var NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SEGMENT_RE = /^[A-Za-z0-9._-]+$/;
+var SKIPPED = /* @__PURE__ */ new Set([MANIFEST_FILE, ".git", "node_modules", "__pycache__", ".DS_Store"]);
+var SkillInstallRefused = class extends Error {
+  constructor(dest, edited) {
+    super(
+      `${dest} has local changes in ${edited.length} file(s): ${edited.join(", ")}. Nothing was written. Move your changes aside, or install again with overwrite.`
+    );
+    this.dest = dest;
+    this.edited = edited;
+  }
+  dest;
+  edited;
+};
+function sha256(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function isValidName(name) {
+  return name.length <= 64 && NAME_RE.test(name);
+}
+function isValidPath(path) {
+  return path.length > 0 && path.length <= 512 && !path.startsWith("/") && path.split("/").every((s) => SEGMENT_RE.test(s) && s !== "." && s !== ".." && s !== PLUGIN_MANIFEST_FOLDER);
+}
+function frontmatterName(skillMd) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(skillMd);
+  if (!block) return void 0;
+  const line = /^name:[ \t]*(.+?)[ \t]*$/m.exec(block[1]);
+  return line ? line[1].replace(/^(['"])(.*)\1$/, "$2") : void 0;
+}
+function defaultSkillDir(name) {
+  return join(homedir(), ".claude", "skills", name);
+}
+async function walk(root, { skipHidden }, dir = root, out = { files: [], links: [], hidden: [] }) {
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    if (SKIPPED.has(entry.name) || entry.name.endsWith(".pyc")) continue;
+    const full = join(dir, entry.name);
+    const rel = relative(root, full).split(sep).join("/");
+    if (entry.isSymbolicLink()) out.links.push(rel);
+    else if (skipHidden && entry.name.startsWith(".")) out.hidden.push(rel);
+    else if (entry.isDirectory()) await walk(root, { skipHidden }, full, out);
+    else if (entry.isFile()) out.files.push(rel);
+  }
+  out.files.sort();
+  return out;
+}
+async function readTextFiles(root, paths, what) {
+  if (paths.length > MAX_FILES) {
+    throw new Error(`${root} holds ${paths.length} files: ${what} holds at most ${MAX_FILES}`);
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const files = [];
+  let total = 0;
+  for (const path of paths) {
+    if (!isValidPath(path)) {
+      throw new Error(`${path}: file names may use letters, digits, ".", "_" and "-" only`);
+    }
+    const raw = await readFile(join(root, ...path.split("/")));
+    if (raw.includes(0)) throw new Error(`${path} is binary: ${what} holds text files only`);
+    if (raw.length > MAX_FILE_BYTES) {
+      throw new Error(`${path} is ${raw.length} bytes: a file holds at most ${MAX_FILE_BYTES}`);
+    }
+    total += raw.length;
+    if (total > MAX_TOTAL_BYTES) {
+      throw new Error(`the files pass ${MAX_TOTAL_BYTES} bytes at ${path}`);
+    }
+    let content;
+    try {
+      content = decoder.decode(raw);
+    } catch {
+      throw new Error(`${path} is not UTF-8 text`);
+    }
+    files.push({ path, content });
+  }
+  return files;
+}
+async function readSkillDirectory(directory) {
+  const root = resolve(directory);
+  if (!existsSync(join(root, ENTRY_FILE))) {
+    throw new Error(`${root} has no ${ENTRY_FILE}: a skill folder holds SKILL.md at its root`);
+  }
+  const walked = await walk(root, { skipHidden: true });
+  if (walked.links.length) {
+    throw new Error(`${walked.links.join(", ")}: links are not followed; copy the file into the skill folder`);
+  }
+  const files = await readTextFiles(root, walked.files, "a skill");
+  const skillMd = files.find((f) => f.path === ENTRY_FILE);
+  const name = frontmatterName(skillMd.content);
+  if (!name) throw new Error(`${ENTRY_FILE} has no frontmatter name`);
+  return { name, files, skipped: walked.hidden };
+}
+function within(dest, path) {
+  if (!isValidPath(path)) throw new Error(`refusing to write ${JSON.stringify(path)}: not a skill path`);
+  const full = resolve(dest, ...path.split("/"));
+  if (!full.startsWith(resolve(dest) + sep)) throw new Error(`refusing to write outside ${dest}: ${path}`);
+  return full;
+}
+async function readManifest(dest) {
+  try {
+    return JSON.parse(await readFile(join(dest, MANIFEST_FILE), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function installSkill(version, dest, { overwrite = false } = {}) {
+  if (!isValidName(version.name)) throw new Error(`refusing to install ${JSON.stringify(version.name)}: not a skill name`);
+  const incoming = new Map(version.files.map((f) => [f.path, f]));
+  for (const f of version.files) within(dest, f.path);
+  if (existsSync(dest) && (await lstat(dest)).isSymbolicLink()) {
+    throw new Error(`${dest} is a link: install into a real folder`);
+  }
+  const walked = existsSync(dest) ? await walk(dest, { skipHidden: false }) : { files: [], links: [], hidden: [] };
+  if (walked.links.length) {
+    throw new Error(`${dest} holds links (${walked.links.join(", ")}): remove them, nothing was written`);
+  }
+  const present = walked.files;
+  const manifest = await readManifest(dest);
+  const known2 = Object.fromEntries(
+    Object.entries(manifest?.files ?? {}).filter(([p, h]) => isValidPath(p) && typeof h === "string")
+  );
+  const edited = [];
+  const untracked = [];
+  for (const path of present) {
+    const content = await readFile(join(dest, ...path.split("/")), "utf8");
+    if (Object.hasOwn(known2, path)) {
+      if (sha256(content) !== known2[path]) edited.push(path);
+    } else if (!incoming.has(path) || sha256(content) !== incoming.get(path).sha256) {
+      if (incoming.has(path) || !manifest) edited.push(path);
+      else untracked.push(path);
+    }
+  }
+  const blocking = edited.filter((p) => incoming.has(p) || !manifest);
+  if (blocking.length && !overwrite) throw new SkillInstallRefused(dest, blocking);
+  const written = [];
+  for (const f of version.files) {
+    const full = within(dest, f.path);
+    await mkdir(dirname(full), { recursive: true });
+    await writeFile(full, f.content, "utf8");
+    written.push(f.path);
+  }
+  const removed = [];
+  const keptEdited = [];
+  for (const path of Object.keys(known2)) {
+    if (incoming.has(path) || !present.includes(path)) continue;
+    if (edited.includes(path)) {
+      keptEdited.push(path);
+      continue;
+    }
+    await rm(within(dest, path));
+    removed.push(path);
+  }
+  const next = {
+    name: version.name,
+    version: version.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: Object.fromEntries(version.files.map((f) => [f.path, f.sha256]))
+  };
+  await writeFile(join(dest, MANIFEST_FILE), JSON.stringify(next, null, 2) + "\n", "utf8");
+  return {
+    dest,
+    version: version.version,
+    written,
+    removed,
+    keptUntracked: untracked.filter((p) => !incoming.has(p)),
+    keptEdited
+  };
+}
+function fenceFor(text3) {
+  const longest = Math.max(0, ...(text3.match(/`+/g) ?? []).map((r) => r.length));
+  return "`".repeat(Math.max(3, longest + 1));
+}
+function afterInstall(skillMd) {
+  return `No restart is needed: a running Claude Code session picks it up. If one does not list it yet, read ${skillMd} and follow it, or run /reload-skills.`;
+}
+function describeInstall(name, r) {
+  const lines = [
+    `Installed ${name} version ${r.version} into ${r.dest} (${r.written.length} file(s)).`
+  ];
+  if (r.removed.length) lines.push(`Removed (no longer in the skill): ${r.removed.join(", ")}`);
+  if (r.keptEdited.length) {
+    lines.push(`Kept, edited here and no longer in the skill: ${r.keptEdited.join(", ")}`);
+  }
+  if (r.keptUntracked.length) lines.push(`Kept, added here: ${r.keptUntracked.join(", ")}`);
+  lines.push(afterInstall(join(r.dest, "SKILL.md")));
+  return lines.join("\n");
+}
+
+// src/lib/team-setup-files.ts
+import { execFile } from "child_process";
+import { chmod, mkdir as mkdir2, readFile as readFile2, rename, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2, userInfo } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+import { promisify } from "util";
+var SLUG_RE2 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isWorkspace(value) {
+  return typeof value === "string" && value.length <= 64 && SLUG_RE2.test(value);
+}
+function homeDir() {
+  return homedir2();
+}
+function systemdoxDir() {
+  return join2(homeDir(), ".claude", "systemdox");
+}
+function workspaceDir(workspace) {
+  if (!isWorkspace(workspace)) throw new Error(`${JSON.stringify(workspace)} is not a workspace name`);
+  return join2(systemdoxDir(), workspace);
+}
+function statePath(workspace) {
+  return join2(workspaceDir(workspace), "state.json");
+}
+async function readJson(path, empty) {
+  let text3;
+  try {
+    text3 = await readFile2(path, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") return empty;
+    throw e;
+  }
+  try {
+    return JSON.parse(text3);
+  } catch {
+    throw new Error(`${path} is not valid JSON: fix or remove it, then run this again`);
+  }
+}
+async function writeJsonAtomically(path, value, mode) {
+  await mkdir2(dirname2(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  await writeFile2(tmp, JSON.stringify(value, null, 2) + "\n", mode === void 0 ? "utf8" : { encoding: "utf8", mode });
+  await rename(tmp, path);
+}
+var run = promisify(execFile);
+async function readState(workspace) {
+  return readJson(statePath(workspace), {});
+}
+async function writeState(workspace, state) {
+  await writeJsonAtomically(statePath(workspace), state);
+}
+async function updateState(workspace, change) {
+  const state = await readState(workspace);
+  change(state);
+  await writeState(workspace, state);
+  return state;
+}
+
+// src/lib/session-brief.ts
+var BRIEF_TIMEOUT_MS = 8e3;
+var SETUP_COMMAND = "npx -y @systemdox/mcp-server setup";
+var REFUSED = `SystemDox refused this computer's key, so the team's rules and skills cannot be read and every SystemDox tool fails. Tell the person once: a new key comes from the SystemDox console, Settings \u203A API keys, and \`${SETUP_COMMAND}\` in their own terminal stores it.`;
+var NOT_CHECKED = "SystemDox could not be read when this session started, so the team's skills were not checked. Call get_team_setup to check again before relying on them.";
+var CANNOT_SEE = "This server cannot see this computer's disk. For each skill listed under Team skills: if ~/.claude/skills/<name>/ is absent, or its .systemdox-skill.json names another version than get_team_setup lists, call install_skill with that version and write what it returns, unless the latest team plugin carries it. Leave a folder with no such file alone. If a file there differs from the hash that file holds for it, it was edited: ask the person before replacing it.";
+function noKey(reason) {
+  return `This computer has no SystemDox key it can use (${reason}), so the team's rules and skills cannot be read and every SystemDox tool fails. Tell the person once: \`${SETUP_COMMAND}\` in their own terminal asks for one.`;
+}
+async function readJsonQuietly(path) {
+  try {
+    return JSON.parse(await readFile3(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function computerState(setup) {
+  const id = `${setup.workspace}-setup@systemdox-${setup.workspace}`;
+  const installed = await readJsonQuietly(join3(homeDir(), ".claude", "plugins", "installed_plugins.json"));
+  const entries2 = installed?.plugins?.[id];
+  const entry = Array.isArray(entries2) ? entries2.find((e) => (e?.scope ?? "user") === "user") : void 0;
+  const state = {
+    missing: [],
+    behind: [],
+    notFromSystemDox: [],
+    pluginInstalled: !!entry,
+    pluginVersion: entry?.version
+  };
+  const pluginCurrent = !!entry && !!setup.plugin && entry.version === `${setup.plugin.version}.0.0`;
+  for (const skill of setup.sessionBrief?.skills ?? []) {
+    const dir = defaultSkillDir(skill.name);
+    if (!existsSync2(dir)) {
+      if (!(pluginCurrent && setup.plugin?.skills?.[skill.name] !== void 0)) state.missing.push(skill.name);
+      continue;
+    }
+    const manifest = await readJsonQuietly(join3(dir, MANIFEST_FILE));
+    if (typeof manifest?.version !== "number" || !Number.isInteger(manifest.version)) {
+      state.notFromSystemDox.push(skill.name);
+    } else if (manifest.version !== skill.latestVersion) {
+      state.behind.push({ name: skill.name, here: manifest.version, latest: skill.latestVersion });
+    }
+  }
+  return state;
+}
+function hasPersonParts(setup) {
+  return Object.keys(setup.parts ?? {}).length > 0 || (setup.memory ?? []).length > 0 || (setup.sessionBrief?.heldSkills ?? []).some((h) => h.reason === "not-plain");
+}
+var MORE = (n) => `${n} more (get_team_setup lists them)`;
+var LIST_MIN = `all ${MORE(100)}`.length;
+async function readTeamSetup(apiClient, { keyProblem, timeoutMs = BRIEF_TIMEOUT_MS } = {}) {
+  if (keyProblem) return { problem: noKey(keyProblem) };
+  try {
+    const setup = await apiClient.getOwnTeamSetup(AbortSignal.timeout(timeoutMs));
+    return typeof setup?.workspace === "string" ? { setup } : { problem: NOT_CHECKED };
+  } catch (err) {
+    const status = err?.status;
+    return { problem: status === 401 || status === 403 ? REFUSED : NOT_CHECKED };
+  }
+}
+
+// src/tools/get-team-setup.ts
+var HELD_BECAUSE = {
+  "not-plain": `it is not a plain skill: it has frontmatter beyond a name and a description, files outside its own folders, or a command that runs as it loads. The team plugin carries it, and \`${SETUP_COMMAND}\` shows that before the person accepts`,
+  "outside-default-space": "it is outside the default space, so the team plugin does not carry it either. The person can read it in the console, then install it with `npx -y @systemdox/mcp-server install-skill <name>`",
+  "not-checked": "it could not be checked. Ask again later"
+};
+function describeSetup(setup) {
+  const lines = [`# Team setup of ${setup.workspace}`, ""];
+  const skills = setup.sessionBrief?.skills ?? [];
+  const held = setup.sessionBrief?.heldSkills ?? [];
+  lines.push(`## Skills a session installs by itself (${skills.length})`, "");
+  if (skills.length) {
+    for (const s of skills) lines.push(`- **${s.name}** version ${s.latestVersion}: ${s.description}`);
+  } else if (!setup.sessionBrief && setup.skills.length) {
+    lines.push(`- ${setup.skills.join(", ")}`);
+  } else {
+    lines.push("None.");
+  }
+  lines.push("");
+  if (held.length) {
+    lines.push(`## Skills that wait for the person (${held.length})`, "");
+    for (const h of held) lines.push(`- **${h.name}**: ${HELD_BECAUSE[h.reason] ?? h.reason}`);
+    lines.push("", "Do not install these yourself: each is the person's to decide.", "");
+  }
+  if (setup.plugin) {
+    lines.push(`## Team plugin`, "", `\`${setup.workspace}-setup\` version ${setup.plugin.version}.`);
+    for (const c of setup.plugin.hookCommands ?? []) lines.push(`- Hook: ${JSON.stringify(c)}`);
+    for (const m of setup.plugin.mcpServers ?? []) {
+      lines.push(`- MCP server ${JSON.stringify(m.name)}: ${JSON.stringify(m.url ?? [m.command, ...m.args ?? []].filter(Boolean).join(" "))}`);
+    }
+    lines.push("");
+  }
+  const parts = Object.entries(setup.parts ?? {});
+  if (parts.length) {
+    lines.push(`## Published parts`, "", ...parts.map(([p, v]) => `- ${p}: version ${v}`), "");
+  }
+  if (setup.memory?.length) {
+    lines.push(`## Team memory`, "", ...setup.memory.map((m) => `- ${m.project}: ${m.fileCount} file(s)`), "");
+  }
+  return lines;
+}
+function describeComputer(setup, state) {
+  const lines = ["## This computer", ""];
+  if (!setup.sessionBrief) {
+    return [...lines, "This SystemDox API is too old to compare this computer with the team setup."];
+  }
+  const skills = setup.sessionBrief.skills;
+  const latest = new Map(skills.map((s) => [s.name, s.latestVersion]));
+  lines.push(
+    state.missing.length ? `- Missing: ${state.missing.map((name) => `${name} version ${latest.get(name)}`).join(", ")}` : `- Missing: none of ${skills.length}`
+  );
+  if (state.behind.length) {
+    lines.push(`- Behind: ${state.behind.map((b) => `${b.name} (version ${b.here} here, latest ${b.latest})`).join(", ")}`);
+  }
+  if (state.notFromSystemDox.length) lines.push(`- Not from SystemDox, left alone: ${state.notFromSystemDox.join(", ")}`);
+  if (setup.plugin) {
+    lines.push(
+      state.pluginInstalled ? `- Team plugin: installed${state.pluginVersion ? `, ${state.pluginVersion}` : ""}; the latest is version ${setup.plugin.version}` : "- Team plugin: not installed"
+    );
+  }
+  lines.push("", "## What to do", "");
+  const steps = [];
+  if (state.missing.length) steps.push("Call install_skill for each missing skill, at the version named above. These are plain skills: installing writes files and runs nothing.");
+  if (state.behind.length) {
+    steps.push("Call install_skill for each skill behind, at the latest version named above. If it refuses because files were edited, tell the person and leave them.");
+  }
+  if (hasPersonParts(setup) && !state.pluginInstalled) {
+    steps.push(
+      `Hooks, MCP servers, team instructions and memory need the person: \`${SETUP_COMMAND}\` in their own terminal. Never answer its prompts for them.`
+    );
+  }
+  lines.push(...steps.length ? steps.map((s, i) => `${i + 1}. ${s}`) : ["Nothing."]);
+  return lines;
+}
+function registerGetTeamSetup(server, apiClient, { localFiles, keyProblem }) {
+  server.registerTool(
+    "get_team_setup",
+    {
+      title: "Get Team Setup",
+      description: localFiles ? "What this workspace's team setup holds (skills, plugin, hooks, MCP servers, memory) and what this computer lacks, with what to do about it. Call it to check whether this computer is set up. Reads only." : "What this workspace's team setup holds (skills, plugin, hooks, MCP servers, memory), and how to check this computer against it. Reads only.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const read = await readTeamSetup(apiClient, { keyProblem, timeoutMs: 15e3 });
+      if ("problem" in read) return { content: [{ type: "text", text: read.problem }] };
+      const lines = describeSetup(read.setup);
+      if (localFiles) lines.push(...describeComputer(read.setup, await computerState(read.setup)));
+      else lines.push(CANNOT_SEE);
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+
+// src/tools/document-graph.ts
+import { z as z8 } from "zod";
+var DEFAULT_LIMIT2 = 50;
+var MAX_LIMIT = 200;
+var DEFAULT_HOPS = 6;
+var MAX_HOPS = 8;
+function place(file, line) {
+  return file ? `${file}:${line}` : "made by a person";
+}
+function known(provenance, confidence) {
+  return `${provenance} ${confidence}`;
+}
+function formatNeighbours(answer) {
+  const lines = [`# ${answer.doc.label}`, `\`${answer.doc.id}\``, ""];
+  if (answer.links.length === 0) lines.push("No links.");
+  for (const link of answer.links) {
+    lines.push(
+      `- ${link.direction} \xB7 ${link.relation} \xB7 ${known(link.provenance, link.confidence)} \xB7 ${link.other.label} \xB7 \`${link.other.id}\` \xB7 ${place(link.file, link.line)}`
+    );
+  }
+  if (answer.truncated) {
+    lines.push("", `Showing ${answer.links.length} of ${answer.total}. Raise limit to see more.`);
+  }
+  if (answer.ambiguous.length > 0) {
+    lines.push("", "## Ambiguous: not drawn, because each could mean several documents");
+    for (const entry of answer.ambiguous) {
+      const candidates = entry.candidates.map((c) => `${c.label} (${c.repo}, \`${c.id}\`)`);
+      lines.push(`- ${entry.reference} at ${place(entry.file, entry.line)}: ${candidates.join("; ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatPath(answer, maxHops) {
+  if (!answer.found) return `No path within ${maxHops} hops.`;
+  const lines = answer.steps.map((step, index) => {
+    const arrow = step.reversed ? "<-" : "->";
+    return `${index + 1}. ${step.from.label} ${arrow} ${step.relation} ${arrow} ${step.to.label} \xB7 ${known(step.provenance, step.confidence)} \xB7 ${place(step.file, step.line)}`;
+  });
+  return [...lines, "", `Path confidence: ${answer.confidence}`].join("\n");
+}
+function formatStats(stats, repoLinks) {
+  const { declared, extracted, inferred, ambiguous } = stats.links;
+  const lines = [
+    `# The graph: ${stats.nodeCount} documents, ${stats.edgeCount} links`,
+    "",
+    `Links: ${declared} declared \xB7 ${extracted} extracted \xB7 ${inferred} inferred \xB7 ${ambiguous} ambiguous (not drawn)`,
+    "",
+    "## Repositories"
+  ];
+  for (const repo of stats.repos) {
+    const state = repo.behind ? `BEHIND: pushed ${repo.headCommit || "unknown"} at ${repo.pushedAt}, index at ${repo.indexedCommit || "unknown"}` : `index at ${repo.indexedCommit || "unknown"}`;
+    lines.push(`- ${repo.repo}: ${repo.documents} documents, ${repo.links} links, ${state}`);
+  }
+  if (repoLinks.length > 0) {
+    lines.push("", "## Repository links");
+    for (const link of repoLinks) {
+      lines.push(
+        `- ${link.source} ${link.relation} ${link.target} \xB7 ${known(link.provenance, link.confidence)} \xB7 ${place(link.file, link.line)}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function refused(err) {
+  const status = err.status;
+  if (status !== 404 && status !== 400) throw err;
+  return {
+    content: [{ type: "text", text: err.message }],
+    isError: true
+  };
+}
+function registerDocumentGraph(server, apiClient) {
+  server.registerTool(
+    "get_document_links",
+    {
+      description: "What one document links to and from, strongest first. Each link says how it is known: declared (a person made it), extracted (the file says so), or inferred (a reading that could be wrong), with a confidence and the file and line it came from. A reference that could mean several documents is listed as ambiguous with its candidates, and is never drawn as a link. doc_id is the id get_docs returns. Read-only.",
+      inputSchema: {
+        doc_id: z8.string().min(1).max(400).describe("A document id, as get_docs returns it"),
+        direction: z8.enum(["out", "in", "both"]).optional().describe("Default both"),
+        relation: z8.enum(["links_to", "cites", "mentions", "satisfies", "references"]).optional().describe("Only links of this kind"),
+        limit: z8.number().int().min(1).max(MAX_LIMIT).optional().describe(`Most links to show (default ${DEFAULT_LIMIT2})`)
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ doc_id, direction, relation, limit }) => {
+      const params = { doc: doc_id, limit: String(limit ?? DEFAULT_LIMIT2) };
+      if (direction) params.direction = direction;
+      if (relation) params.relation = relation;
+      try {
+        const answer = await apiClient.get("/v1/graph/neighbours", params);
+        return { content: [{ type: "text", text: formatNeighbours(answer) }] };
+      } catch (err) {
+        return refused(err);
+      }
+    }
+  );
+  server.registerTool(
+    "trace_document_path",
+    {
+      description: "The shortest way two documents connect, walking links in either direction. Each step says how it is known, and the path is only as strong as its weakest step. Read-only.",
+      inputSchema: {
+        from: z8.string().min(1).max(400).describe("A document id, as get_docs returns it"),
+        to: z8.string().min(1).max(400).describe("A document id, as get_docs returns it"),
+        max_hops: z8.number().int().min(1).max(MAX_HOPS).optional().describe(`Longest path to look for (default ${DEFAULT_HOPS})`)
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ from, to, max_hops }) => {
+      const hops = max_hops ?? DEFAULT_HOPS;
+      try {
+        const answer = await apiClient.get("/v1/graph/path", {
+          from,
+          to,
+          maxHops: String(hops)
+        });
+        return { content: [{ type: "text", text: formatPath(answer, hops) }] };
+      } catch (err) {
+        return refused(err);
+      }
+    }
+  );
+  server.registerTool(
+    "get_graph_stats",
+    {
+      description: "The state of the graph: links counted by how they are known, each repository's freshness (marked BEHIND when a push has not finished indexing), and how repositories depend on each other, from the files that declare it. Read-only.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const [stats, repos] = await Promise.all([
+        apiClient.getFresh("/v1/graph/stats"),
+        apiClient.getFresh("/v1/graph/repos")
+      ]);
+      return { content: [{ type: "text", text: formatStats(stats, repos.links) }] };
+    }
+  );
+}
+
+// src/tools/create-guardrail.ts
+import { z as z9 } from "zod";
+var DESCRIPTION2 = "Create a new check in SystemDox. Use this when you discover a pattern that should be enforced (banned pattern, required pattern, coding rule).";
+var CATEGORIES = [
+  "imports",
+  "auth",
+  "error-handling",
+  "architecture",
+  "testing",
+  "security",
+  "conventions",
+  "data-access"
+];
+var inputSchema2 = () => ({
+  title: z9.string().describe("Short title for the check"),
+  description: z9.string().describe("Detailed description of what the check enforces and why"),
+  severity: z9.enum(["critical", "high", "medium", "low"]).describe("Severity level"),
+  category: z9.enum(CATEGORIES).optional().describe("Category (defaults to conventions)"),
+  pattern: z9.string().optional().describe("Bad code pattern that should be avoided"),
+  fix: z9.string().optional().describe("Correct code pattern to use instead"),
+  fitness_test: z9.string().optional().describe("Shell command to detect violations in CI")
+});
+function registerCreateGuardrail(server, apiClient) {
+  const handler = async ({
+    title,
+    description,
+    severity,
+    category,
+    pattern,
+    fix,
+    fitness_test
+  }) => {
+    const result = await apiClient.post(
+      "/v1/guardrails",
+      {
+        entries: [
+          {
+            title,
+            description,
+            severity,
+            category: category ?? "conventions",
+            pattern: pattern ?? "",
+            fix: fix ?? "",
+            fitnessTest: fitness_test ?? ""
+          }
+        ]
+      }
+    );
+    apiClient.invalidateCache("/v1/guardrails");
+    const saved = result[0];
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Check created: **${saved.title}** (id: ${saved.id}, severity: ${saved.severity}, category: ${saved.category})`
+        }
+      ]
+    };
+  };
+  server.registerTool(
+    "create_check",
+    {
+      title: "Create Check",
+      description: DESCRIPTION2,
+      inputSchema: inputSchema2(),
+      annotations: {
+        readOnlyHint: false
+      }
+    },
+    handler
+  );
+  server.registerTool(
+    "create_guardrail",
+    {
+      title: "Create Check (legacy name)",
+      description: legacyToolDescription("create_check", DESCRIPTION2),
+      inputSchema: inputSchema2(),
+      annotations: {
+        readOnlyHint: false
+      }
+    },
+    handler
+  );
+}
+
+// src/tools/update-spec.ts
+import { z as z10 } from "zod";
+function registerUpdateSpec(server, apiClient) {
+  server.registerTool(
+    "update_spec",
+    {
+      title: "Update Spec",
+      description: "Update an existing SystemDox spec's proposal, tasks, or requirements. Only draft specs can be modified \u2014 published specs must be versioned first.",
+      inputSchema: {
+        draft_id: z10.string().describe("ID of the spec to update"),
+        section: z10.enum(["proposal", "tasks", "requirements"]).describe("Which section to update"),
+        content: z10.string().describe(
+          "New markdown content for the section. For requirements, provide the full requirement content."
+        ),
+        requirement_name: z10.string().optional().describe(
+          "Name of the requirement (required when section is 'requirements')"
+        )
+      },
+      annotations: {
+        readOnlyHint: false
+      }
+    },
+    async ({ draft_id, section, content, requirement_name }) => {
+      const spec = await apiClient.get(`/v1/specs/${draft_id}`);
+      if (spec.status !== "draft") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Cannot modify spec "${spec.name}" \u2014 status is "${spec.status}". Only draft specs can be updated.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const body = {};
+      if (section === "proposal") {
+        body.proposalContent = content;
+      } else if (section === "tasks") {
+        body.taskContent = content;
+      } else if (section === "requirements") {
+        const existing = spec.requirements;
+        const newReq = {
+          name: requirement_name ?? "Untitled Requirement",
+          content
+        };
+        body.requirements = [...existing, newReq];
+      }
+      await apiClient.put(`/v1/specs/${draft_id}`, body);
+      apiClient.invalidateCache(`/v1/specs/${draft_id}`);
+      apiClient.invalidateCache("/v1/specs");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Updated spec "${spec.name}" \u2014 ${section} section modified.`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/report-decision.ts
+import { z as z11 } from "zod";
+function registerReportDecision(server, apiClient) {
+  server.registerTool(
+    "report_decision",
+    {
+      title: "Report Decision",
+      description: "Record an architecture decision made during development. Creates a draft ADR in SystemDox for human review.",
+      inputSchema: {
+        title: z11.string().describe("Decision title (e.g., 'Use WebSocket for real-time updates')"),
+        context: z11.string().describe("What prompted this decision \u2014 the problem or constraint"),
+        decision: z11.string().describe("What was decided and why"),
+        consequences: z11.string().describe("What this decision means going forward \u2014 trade-offs, follow-up work"),
+        related_files: z11.array(z11.string()).optional().describe("File paths related to this decision")
+      },
+      annotations: {
+        readOnlyHint: false
+      }
+    },
+    async ({ title, context, decision, consequences, related_files }) => {
+      const adrTitle = `ADR: ${title}`;
+      const created = await apiClient.post("/v1/specs", {
+        name: adrTitle
+      });
+      const relatedSection = related_files && related_files.length > 0 ? `
+
+## Related Files
+
+${related_files.map((f) => `- \`${f}\``).join("\n")}` : "";
+      const adrContent = `# ${adrTitle}
+
+**Date:** ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
+**Status:** Draft (pending review)
+
+## Context
+
+${context}
+
+## Decision
+
+${decision}
+
+## Consequences
+
+${consequences}` + relatedSection;
+      await apiClient.put(`/v1/specs/${created.draftId}`, {
+        proposalContent: adrContent
+      });
+      apiClient.invalidateCache("/v1/specs");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Architecture decision recorded: **${adrTitle}** (spec id: ${created.draftId})
+
+Status: draft \u2014 review in SystemDox before publishing.`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/get-project-rules.ts
+import { z as z12 } from "zod";
+var CATEGORY_LABELS = {
+  deployment: "Deployment",
+  architecture: "Architecture",
+  security: "Security",
+  testing: "Testing",
+  process: "Process",
+  other: "Other"
+};
+function registerGetProjectRules(server, apiClient) {
+  server.registerTool(
+    "get_project_rules",
+    {
+      title: "Get Project Rules",
+      description: "Retrieve project rules defined in SystemDox Standards. These are team-defined principles covering deployment, architecture, security, testing, and process. Filter by category to get only relevant rules.",
+      inputSchema: {
+        category: z12.enum(["deployment", "architecture", "security", "testing", "process", "other"]).optional().describe("Filter by rule category")
+      }
+    },
+    async ({ category }) => {
+      const rules = await apiClient.get(
+        "/v1/standards/rules"
+      );
+      let filtered = rules;
+      if (category) {
+        filtered = filtered.filter(
+          (r) => r.category.toLowerCase() === category.toLowerCase()
+        );
+      }
+      if (filtered.length === 0) {
+        const text4 = rules.length === 0 ? `No project rules found. Add rules at ${configLink("/docs/rules", await workspaceBase(apiClient))}` : `No project rules found${category ? ` in category "${category}"` : ""}.`;
+        return {
+          content: [{ type: "text", text: text4 }]
+        };
+      }
+      const grouped = /* @__PURE__ */ new Map();
+      for (const rule of filtered) {
+        const cat = rule.category || "other";
+        if (!grouped.has(cat)) grouped.set(cat, []);
+        grouped.get(cat).push(rule);
+      }
+      let text3 = `Found ${filtered.length} project rule(s):
+
+`;
+      for (const [cat, catRules] of grouped) {
+        const label = CATEGORY_LABELS[cat] ?? cat;
+        text3 += `## ${label}
+
+`;
+        for (const rule of catRules) {
+          text3 += `- ${rule.text}
+`;
+        }
+        text3 += "\n";
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: text3
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/create-project-rule.ts
+import { z as z13 } from "zod";
+function registerCreateProjectRule(server, apiClient) {
+  server.registerTool(
+    "create_project_rule",
+    {
+      title: "Create Project Rule",
+      description: "Create a new project rule in SystemDox Standards. Use this when you discover a team principle or convention that should be enforced across the project.",
+      inputSchema: {
+        text: z13.string().describe(
+          "The rule statement \u2014 one enforceable principle per rule (e.g. 'All deployments MUST go through GitHub Actions workflows')"
+        ),
+        category: z13.enum(["deployment", "architecture", "security", "testing", "process", "other"]).describe("Rule category")
+      },
+      annotations: {
+        readOnlyHint: false
+      }
+    },
+    async ({ text: text3, category }) => {
+      const saved = await apiClient.post(
+        "/v1/standards/rules",
+        { text: text3, category }
+      );
+      apiClient.invalidateCache("/v1/standards/rules");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Project rule created: **${saved.text}** (id: ${saved.id}, category: ${saved.category})`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/get-prompt-templates.ts
+function registerGetPromptTemplates(server, apiClient) {
+  server.registerTool(
+    "get_prompt_templates",
+    {
+      title: "Get Prompt Templates",
+      description: "Retrieve reusable prompt templates from SystemDox Standards. These are preconfigured prompts that Gen AI should use when generating content \u2014 e.g. code review checklists, documentation templates, or analysis frameworks.",
+      inputSchema: {}
+    },
+    async () => {
+      const templates = await apiClient.get(
+        "/v1/standards/prompt-templates"
+      );
+      if (templates.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No prompt templates found. Add templates at ${configLink("/docs/prompts", await workspaceBase(apiClient))}`
+            }
+          ]
+        };
+      }
+      const text3 = templates.map(
+        (t) => `## ${t.name}
+
+` + (t.description ? `*${t.description}*
+
+` : "") + `\`\`\`
+${t.prompt}
+\`\`\``
+      ).join("\n\n---\n\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Found ${templates.length} prompt template(s):
+
+${text3}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/create-prompt-template.ts
+import { z as z14 } from "zod";
+function registerCreatePromptTemplate(server, apiClient) {
+  server.registerTool(
+    "create_prompt_template",
+    {
+      title: "Create Prompt Template",
+      description: "Create a new reusable prompt template in SystemDox Standards. Use this to store preconfigured prompts for common AI tasks like code reviews, documentation generation, or analysis frameworks.",
+      inputSchema: {
+        name: z14.string().describe("Short name for the template"),
+        description: z14.string().optional().describe("Brief description of when to use this template"),
+        prompt: z14.string().describe("The full prompt text that Gen AI will use when generating content")
+      },
+      annotations: {
+        readOnlyHint: false
+      }
+    },
+    async ({ name, description, prompt }) => {
+      const saved = await apiClient.post(
+        "/v1/standards/prompt-templates",
+        {
+          name,
+          description: description ?? "",
+          prompt
+        }
+      );
+      apiClient.invalidateCache("/v1/standards/prompt-templates");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Prompt template created: **${saved.name}** (id: ${saved.id})`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/skills.ts
+import { z as z15 } from "zod";
+import { homedir as homedir3 } from "os";
+import { basename, resolve as resolve2 } from "path";
+var SKILLS = "/v1/standards/skills";
+function expandHome(path) {
+  return path.replace(/^~(?=$|[\\/])/, homedir3());
+}
+function text(t) {
+  return { content: [{ type: "text", text: t }] };
+}
+function registerSkillTools(server, apiClient, { localFiles }) {
+  const fileSchema = z15.object({
+    path: z15.string().describe('Path inside the skill folder, forward slashes, e.g. "references/guide.md"'),
+    content: z15.string().describe("The file's full text, exactly as it is")
+  });
+  server.registerTool(
+    "publish_skill",
+    {
+      title: "Publish Skill",
+      description: localFiles ? "Publish a Claude Code skill folder (SKILL.md plus its references and scripts) to SystemDox so it can be installed on any computer. Pass `directory` (e.g. ~/.claude/skills/<name>): the server reads the files itself, byte for byte. Publishing a name again makes a new version. Never retype the files into `files` when the folder is on this computer." : "Publish a Claude Code skill (SKILL.md plus its references and scripts) to SystemDox so it can be installed on any computer. Pass every file of the folder in `files`, exactly as it is. Publishing a name again makes a new version.",
+      inputSchema: {
+        ...localFiles ? {
+          directory: z15.string().optional().describe("The skill folder on this computer, holding SKILL.md at its root")
+        } : {},
+        files: z15.array(fileSchema).optional().describe(localFiles ? "Only when there is no folder to read" : "Every file of the skill folder"),
+        name: z15.string().optional().describe("The skill's name; defaults to SKILL.md's frontmatter name and must match it"),
+        spaceId: z15.string().optional().describe("Space for a NEW skill (default: your default space)"),
+        note: z15.string().max(500).optional().describe(`A short change note for this version, shown in the console's history (e.g. "Fix the GA4 step")`),
+        baseVersion: z15.number().int().positive().optional().describe(
+          "The version these files were edited from. When given, the publish is refused (SYD-K017) if someone published a newer version since, instead of replacing their changes"
+        )
+      },
+      annotations: { readOnlyHint: false }
+    },
+    async (args) => {
+      let files;
+      let name;
+      let skipped = [];
+      if (localFiles && args.directory) {
+        ({ name, files, skipped } = await readSkillDirectory(expandHome(args.directory)));
+      } else if (args.files?.length) {
+        files = args.files;
+        const entry = files.find((f) => f.path === ENTRY_FILE);
+        name = entry ? frontmatterName(entry.content) : void 0;
+      } else {
+        throw new Error(localFiles ? "Pass `directory` (or `files`)." : "Pass `files`.");
+      }
+      name = args.name ?? name;
+      if (!name) throw new Error(`${ENTRY_FILE} has no frontmatter name; pass \`name\`.`);
+      const saved = await apiClient.post(
+        `${SKILLS}/${encodeURIComponent(name)}/versions`,
+        {
+          files,
+          ...args.spaceId ? { spaceId: args.spaceId } : {},
+          ...args.note ? { note: args.note } : {},
+          ...args.baseVersion ? { baseVersion: args.baseVersion } : {}
+        }
+      );
+      apiClient.invalidateCache(SKILLS);
+      return text(
+        `Published **${saved.name}** version ${saved.version} (${saved.fileCount} file(s), ${saved.totalBytes} bytes).
+Install it anywhere with: npx -y @systemdox/mcp-server install-skill ${saved.name}` + (skipped.length ? `
+Left out (hidden files are never part of a skill): ${skipped.join(", ")}` : "")
+      );
+    }
+  );
+  server.registerTool(
+    "list_skills",
+    {
+      title: "List Skills",
+      description: "List the Claude Code skills published to SystemDox that you can install: name, description, latest version. Use install_skill to install one.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const { skills } = await apiClient.get(SKILLS);
+      if (!skills.length) {
+        return text(
+          `No skills published yet. Publish one with publish_skill; they appear at ${configLink("/docs/team-setup/skills", await workspaceBase(apiClient))}`
+        );
+      }
+      return text(
+        `${skills.length} skill(s):
+
+` + skills.map((s) => `- **${s.name}** (version ${s.latestVersion}, updated ${s.updatedAt.slice(0, 10)}): ${s.description}`).join("\n")
+      );
+    }
+  );
+  server.registerTool(
+    "install_skill",
+    {
+      title: "Install Skill",
+      description: localFiles ? "Install a skill published to SystemDox onto this computer (default ~/.claude/skills/<name>/). Refuses, naming the files, when a file there was edited since it was installed, unless overwrite is true. Never runs anything." : "Fetch a skill published to SystemDox so you can install it: returns every file and the folder to write them into (default ~/.claude/skills/<name>/). Write each file exactly, then the manifest it shows.",
+      inputSchema: {
+        name: z15.string().describe("The skill's name"),
+        version: z15.number().int().positive().optional().describe("A version number (default: the latest)"),
+        target: z15.string().optional().describe("Folder to install into, e.g. a repo's .claude/skills/<name>"),
+        ...localFiles ? { overwrite: z15.boolean().optional().describe("Replace files edited since they were installed") } : {}
+      },
+      annotations: { readOnlyHint: !localFiles }
+    },
+    async (args) => {
+      const version = await apiClient.getFresh(
+        `${SKILLS}/${encodeURIComponent(args.name)}/versions/${args.version ?? "latest"}`
+      );
+      if (localFiles) {
+        const dest2 = args.target ? expandHome(args.target) : defaultSkillDir(version.name);
+        if (basename(resolve2(dest2)) !== version.name) {
+          throw new Error(`target must be a folder named ${version.name} (e.g. .claude/skills/${version.name}); got ${dest2}`);
+        }
+        const result = await installSkill(version, dest2, { overwrite: args.overwrite });
+        return text(describeInstall(version.name, result));
+      }
+      const dest = args.target ?? `~/.claude/skills/${version.name}`;
+      const manifest = {
+        name: version.name,
+        version: version.version,
+        installedAt: "<now, ISO 8601>",
+        files: Object.fromEntries(version.files.map((f) => [f.path, f.sha256]))
+      };
+      const body = version.files.map((f) => {
+        const fence = fenceFor(f.content);
+        return `### ${f.path}
+
+${fence}
+${f.content}${f.content.endsWith("\n") ? "" : "\n"}${fence}`;
+      }).join("\n\n");
+      return text(
+        `Skill **${version.name}** version ${version.version}: write these ${version.files.length} file(s) into ${dest}/ exactly as shown (the content between the fences), creating folders as needed. If a file there differs from ${MANIFEST_FILE}'s hash for it, it was edited: ask before replacing it. Then write ${MANIFEST_FILE} with this content. ${afterInstall(`${dest}/SKILL.md`)}
+
+### ${MANIFEST_FILE}
+
+\`\`\`json
+${JSON.stringify(manifest, null, 2)}
+\`\`\`
+
+${body}`
+      );
+    }
+  );
+}
+
+// src/tools/team-setup.ts
+import { z as z16 } from "zod";
+import { existsSync as existsSync4 } from "fs";
+import { lstat as lstat2 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join5, resolve as resolve4 } from "path";
+
+// src/lib/person-values.ts
+var PHONE = "phone";
+var EMAIL = "email";
+var HOME_PATH = "home-path";
+var NATIONAL_PREFIX = "+44";
+var W = "[\\p{L}\\p{N}_]";
+var D = "\\p{Nd}";
+var WORD_OR = (extra) => `[\\p{L}\\p{N}_${extra}]`;
+var PERSON_ID = "(?:(?:con|ctc)_[0-9A-Za-z]{10,40}|usr_[0-9A-Za-z-]{10,40})";
+var PERSON_TOKEN = `\`${PERSON_ID}\`(?:[ \\t]*\\([^()\\n]*\\))?`;
+var BEFORE = `(?<!${WORD_OR("+.:/\\\\\\-")})(?<!${D}[ -])`;
+var AFTER = `(?!${WORD_OR(":/\\\\")}|\\.${D}|[ -]?${D}|-${W})`;
+var E164 = `${BEFORE}\\+${D}+(?:[ -]${D}+)*${AFTER}`;
+var NATIONAL = `${BEFORE}0${D}*(?:[ -]${D}+)*${AFTER}`;
+var GROUP_SIZES = /* @__PURE__ */ new Set([2, 3, 4, 5, 6]);
+var ATEXT = "[A-Za-z0-9!#$%&'*+/=?^_{|}~\\-]";
+var EMAIL_RE = "(?<![A-Za-z0-9!#$%&*+/=?^_{|}~.@\\-])[A-Za-z0-9_]" + ATEXT + "*(?:\\." + ATEXT + "+)*@(?:[A-Za-z0-9](?:[A-Za-z0-9\\-]{0,61}[A-Za-z0-9])?\\.)+[A-Za-z]{2,63}(?![A-Za-z0-9\\-]|\\.[A-Za-z0-9])";
+var HOME_PREFIX = "(?:[A-Za-z]:\\\\+Users\\\\+|[A-Za-z]:/+Users/+|/Users/|/home/)";
+var HOME = `(?<!${WORD_OR(".~:/\\\\$}\\-")})${HOME_PREFIX}[^\\\\/\\s"'\`<>|:*?]+`;
+var KEY_PREFIX = `(?<!${W})(?:pweb_[a-z]+_key_|sk-ant-|sk_live_|rk_live_|github_pat_|gh[pousr]_|sntrys_|xox[baprs]-)[A-Za-z0-9_\\-]{4,}`;
+var global = (source, flags = "") => new RegExp(source, `gu${flags}`);
+var whole = (source, flags = "") => new RegExp(`^(?:${source})$`, `u${flags}`);
+function lineOf(text3, start) {
+  let line = 1;
+  for (let i = text3.indexOf("\n"); i !== -1 && i < start; i = text3.indexOf("\n", i + 1)) line++;
+  return line;
+}
+function phoneShape(value) {
+  const groups = value.replace(/^\++/, "").split(/[ -]/);
+  const digits = [...groups.join("")];
+  if (value.startsWith("+")) return digits.length >= 8 && digits.length <= 15 && digits[0] !== "0";
+  if (digits.length < 10 || digits.length > 11) return false;
+  return groups.length === 1 || groups.slice(1).every((g) => GROUP_SIZES.has([...g].length));
+}
+function normalise(kind, value) {
+  const v = typeof value === "string" ? value.trim() : "";
+  if (kind === PHONE) {
+    if (!(whole(E164).test(v) || whole(NATIONAL).test(v)) || !phoneShape(v)) {
+      throw new Error("not a phone number");
+    }
+    const digits = v.replace(/[ -]/g, "");
+    return digits.startsWith("+") ? digits : NATIONAL_PREFIX + digits.slice(1);
+  }
+  if (kind === EMAIL) {
+    if (!whole(EMAIL_RE).test(v)) throw new Error("not an email address");
+    return v.toLowerCase();
+  }
+  throw new Error(`not a value kind: ${JSON.stringify(kind)}`);
+}
+function findPersonValues(text3) {
+  if (typeof text3 !== "string" || !text3) return [];
+  const skipped = [...text3.matchAll(global(PERSON_TOKEN))].map((m) => [m.index, m.index + m[0].length]);
+  const found = [];
+  const add = (kind, m, normalised) => {
+    const start = m.index;
+    const end = start + m[0].length;
+    if (skipped.some(([s, e]) => s <= start && end <= e)) return;
+    if (found.some((f) => f.start < end && start < f.end)) return;
+    found.push({ kind, value: m[0], normalised, line: lineOf(text3, start), start, end });
+  };
+  for (const m of text3.matchAll(global(EMAIL_RE))) add(EMAIL, m, m[0].toLowerCase());
+  for (const source of [E164, NATIONAL]) {
+    for (const m of text3.matchAll(global(source))) {
+      if (phoneShape(m[0])) add(PHONE, m, normalise(PHONE, m[0]));
+    }
+  }
+  for (const m of text3.matchAll(global(HOME, "i"))) add(HOME_PATH, m, m[0]);
+  return found.sort((a, b) => a.start - b.start);
+}
+function findSecrets(text3) {
+  if (typeof text3 !== "string" || !text3) return [];
+  return [...text3.matchAll(global(KEY_PREFIX))].map((m) => ({ kind: "key-prefix", line: lineOf(text3, m.index) }));
+}
+
+// src/lib/team-setup-types.ts
+var PARTS2 = ["hooks", "mcp", "agents", "commands", "instructions"];
+var PERSON_ID_RE = new RegExp(`^${PERSON_ID}$`);
+
+// src/sync-memory.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
+
+// src/lib/memory-sync.ts
+import { createHash as createHash2 } from "crypto";
+var INDEX_FILE = "MEMORY.md";
+var SHAREABLE_TYPES = ["feedback", "project", "reference"];
+var FILE_PATH_RE = /^[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)*$/;
+var CONFLICT_COPY_RE = /\.local-\d{4}-\d{2}-\d{2}(?:-\d+)?\.md$/;
+function sha2562(text3) {
+  return createHash2("sha256").update(text3, "utf8").digest("hex");
+}
+function isFilePath(path) {
+  return path.length <= 512 && FILE_PATH_RE.test(path) && !path.split("/").some((s) => s === "." || s === "..");
+}
+function isConflictCopy(path) {
+  return CONFLICT_COPY_RE.test(path.split("/").pop() ?? path);
+}
+var BLOCK_RE = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+var YAML_FALSE = /* @__PURE__ */ new Set(["false", "False", "FALSE", "no", "No", "NO", "off", "Off", "OFF"]);
+function readFrontmatter(text3) {
+  const m = BLOCK_RE.exec(text3);
+  if (!m) return void 0;
+  const front = { shareFalse: false };
+  for (const line of m[1].split(/\r?\n/)) {
+    const kv = /^([A-Za-z_][\w-]*)[ \t]*:[ \t]*(.*?)[ \t]*$/.exec(line);
+    if (!kv) continue;
+    const raw = kv[2].replace(/[ \t]+#.*$/, "");
+    const quoted = /^(["'])(.*)\1$/.exec(raw);
+    const value = quoted ? quoted[2] : raw;
+    if (kv[1] === "type") front.type = value.trim().toLowerCase();
+    if (kv[1] === "share") front.shareFalse = quoted ? value.trim().toLowerCase() === "false" : YAML_FALSE.has(value);
+  }
+  return front;
+}
+function isShareable(path, text3) {
+  if (isConflictCopy(path) || !path.endsWith(".md")) return false;
+  const front = readFrontmatter(text3);
+  if (front?.shareFalse) return false;
+  if (path === INDEX_FILE) return true;
+  return !!front && SHAREABLE_TYPES.includes(front.type ?? "");
+}
+function addShareFalse(text3) {
+  const eol = text3.includes("\r\n") ? "\r\n" : "\n";
+  const m = BLOCK_RE.exec(text3);
+  if (!m) return `---${eol}share: false${eol}---${eol}${text3}`;
+  const lines = m[1].split(/\r?\n/).filter((l) => !/^share[ \t]*:/.test(l));
+  lines.push("share: false");
+  const closing = m[0].slice(m[0].lastIndexOf("---"));
+  return `---${eol}${lines.join(eol)}${eol}${closing}${text3.slice(m[0].length)}`;
+}
+function localDate(now) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())}`;
+}
+function conflictCopyName(path, date, taken) {
+  const stem = path.replace(/\.md$/, "");
+  for (let n = 1; ; n++) {
+    const name = `${stem}.local-${date}${n === 1 ? "" : `-${n}`}.md`;
+    if (!taken.has(name.toLowerCase())) return name;
+  }
+}
+function decide(path, base, team, local) {
+  if (team === local) return "unchanged";
+  if (team === base) return local === void 0 ? "delete-team" : "local";
+  if (local === base) return team === void 0 ? "delete-local" : "team";
+  if (path === INDEX_FILE && team !== void 0 && local !== void 0) return "index";
+  if (team === void 0) return "local";
+  if (local === void 0) return "team";
+  return "conflict";
+}
+function decideAll(input) {
+  const localHashes = Object.fromEntries(Object.entries(input.local).map(([p, t]) => [p, sha2562(t)]));
+  const paths = /* @__PURE__ */ new Set([...Object.keys(input.base), ...Object.keys(input.team), ...Object.keys(localHashes)]);
+  const rows = {};
+  const needed = /* @__PURE__ */ new Set();
+  for (const path of [...paths].sort()) {
+    if (input.excluded.has(path)) continue;
+    const row = decide(path, input.base[path], input.team[path], localHashes[path]);
+    rows[path] = row;
+    if (row === "team" || row === "conflict" || row === "index") needed.add(input.team[path]);
+    if (row === "index" && input.base[path]) needed.add(input.base[path]);
+  }
+  return { rows, needed: [...needed] };
+}
+function planMerge(input, rows, texts) {
+  const plan = {
+    manifest: {},
+    upload: {},
+    writes: {},
+    deletes: [],
+    pulled: [],
+    pushed: [],
+    deletedHere: [],
+    deletedFromTeam: [],
+    conflicts: [],
+    indexTeamLines: []
+  };
+  const taken = new Set(input.taken);
+  const teamText = (path) => {
+    const text3 = texts[input.team[path]];
+    if (text3 === void 0) throw new Error(`the team's ${path} could not be read`);
+    return text3;
+  };
+  for (const path of input.excluded) if (input.team[path]) plan.manifest[path] = input.team[path];
+  for (const [path, row] of Object.entries(rows)) {
+    const team = input.team[path];
+    const local = input.local[path];
+    switch (row) {
+      case "unchanged":
+        if (team) plan.manifest[path] = team;
+        break;
+      case "local":
+        plan.manifest[path] = sha2562(local);
+        plan.upload[path] = local;
+        plan.pushed.push(path);
+        break;
+      case "delete-team":
+        plan.deletedFromTeam.push(path);
+        break;
+      case "team":
+        plan.manifest[path] = team;
+        plan.writes[path] = teamText(path);
+        plan.pulled.push(path);
+        break;
+      case "delete-local":
+        plan.deletes.push(path);
+        plan.deletedHere.push(path);
+        break;
+      case "conflict": {
+        const copy = conflictCopyName(path, input.date, taken);
+        taken.add(copy.toLowerCase());
+        plan.manifest[path] = team;
+        plan.writes[path] = teamText(path);
+        plan.writes[copy] = local;
+        plan.conflicts.push({ path, copy });
+        break;
+      }
+      case "index": {
+        const base = input.base[path] ? texts[input.base[path]] : void 0;
+        const merged = mergeIndex(base, teamText(path), local);
+        const hash = sha2562(merged.text);
+        plan.manifest[path] = hash;
+        if (merged.text !== local) {
+          plan.writes[path] = merged.text;
+          plan.pulled.push(path);
+        }
+        if (hash !== team) {
+          plan.upload[path] = merged.text;
+          plan.pushed.push(path);
+        }
+        plan.indexTeamLines.push(...merged.teamLines);
+        break;
+      }
+    }
+  }
+  return plan;
+}
+var LINK_RE = /\]\(\s*<?([^)\s>]+)>?(?:\s+["'(][^)]*)?\)/;
+function entries(lines) {
+  const seen = /* @__PURE__ */ new Map();
+  return lines.map((line) => {
+    const link = LINK_RE.exec(line);
+    const id = link ? `link:${link[1]}` : `text:${line}`;
+    const n = seen.get(id) ?? 0;
+    seen.set(id, n + 1);
+    return { key: n ? `${id}#${n}` : id, line };
+  });
+}
+var splitLines = (text3) => text3.split(/\r?\n/);
+function mergeIndex(base, team, local) {
+  const eol = local.includes("\r\n") ? "\r\n" : "\n";
+  const b = new Map(entries(base === void 0 ? [] : splitLines(base)).map((e) => [e.key, e.line]));
+  const teamEntries = entries(splitLines(team));
+  const t = new Map(teamEntries.map((e) => [e.key, e.line]));
+  const localEntries = entries(splitLines(local));
+  const result = [];
+  const teamLines = [];
+  for (const e of localEntries) {
+    const was = b.get(e.key);
+    const theirs = t.get(e.key);
+    if (theirs === e.line || theirs === was) result.push(e);
+    else if (e.line === was) {
+      if (theirs !== void 0) result.push({ key: e.key, line: theirs });
+    } else {
+      result.push(e);
+      if (theirs !== void 0) teamLines.push(theirs);
+    }
+  }
+  const baseEntries = entries(base === void 0 ? [] : splitLines(base));
+  const localKeys = new Set(localEntries.map((e) => e.key));
+  const replacedHere = /* @__PURE__ */ new Map();
+  baseEntries.forEach((e, i) => {
+    if (e.key.startsWith("text:") && !t.has(e.key) && !localKeys.has(e.key)) {
+      replacedHere.set(e.key, i ? baseEntries[i - 1].key : "");
+    }
+  });
+  const inResult = (key) => result.findIndex((e) => e.key === key);
+  teamEntries.forEach((e, i) => {
+    if (inResult(e.key) !== -1) return;
+    const was = b.get(e.key);
+    const before = i ? teamEntries[i - 1].key : "";
+    const both = e.key.startsWith("text:") && [...replacedHere].find(([, prev]) => prev === before);
+    if (was === void 0 && both) {
+      replacedHere.delete(both[0]);
+      teamLines.push(e.line);
+    } else if (was === void 0) {
+      let at = -1;
+      for (let j = i - 1; j >= 0 && at === -1; j--) at = inResult(teamEntries[j].key);
+      result.splice(at + 1, 0, e);
+    } else if (e.line !== was) {
+      teamLines.push(e.line);
+    }
+  });
+  return { text: result.map((e) => e.line).join(eol), teamLines };
+}
+var groupKey = (kind, normalised) => `${kind}:${normalised}`;
+function collectValues(files) {
+  const groups = /* @__PURE__ */ new Map();
+  const homePaths = [];
+  const findings = {};
+  for (const path of Object.keys(files).sort()) {
+    const found = findPersonValues(files[path]);
+    findings[path] = found;
+    for (const f of found) {
+      if (f.kind === HOME_PATH) {
+        if (!homePaths.includes(path)) homePaths.push(path);
+        continue;
+      }
+      const key = groupKey(f.kind, f.normalised);
+      const group = groups.get(key);
+      if (group) {
+        if (!group.files.includes(path)) group.files.push(path);
+      } else {
+        groups.set(key, {
+          kind: f.kind,
+          value: f.value,
+          normalised: f.normalised,
+          files: [path],
+          first: { path, line: f.line, text: splitLines(files[path])[f.line - 1].trim() }
+        });
+      }
+    }
+  }
+  return { groups: [...groups.values()], homePaths, findings };
+}
+function personToken(personId, label) {
+  return label ? `\`${personId}\` (${label})` : `\`${personId}\``;
+}
+function rewriteValues(text3, findings, replacement) {
+  let out = "";
+  let last = 0;
+  for (const f of [...findings].sort((a, b) => a.start - b.start)) {
+    const to = replacement(f);
+    if (to === void 0) continue;
+    out += text3.slice(last, f.start) + to;
+    last = f.end;
+  }
+  return out + text3.slice(last);
+}
+function lineDiff(before, after) {
+  const a = splitLines(before);
+  const b = splitLines(after);
+  const out = [];
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    if (a[i] === b[i]) continue;
+    if (a[i] !== void 0) out.push(`- ${a[i]}`);
+    if (b[i] !== void 0) out.push(`+ ${b[i]}`);
+  }
+  return out;
+}
+
+// src/sync-memory.ts
+var SYNC_MEMORY_COMMAND = "npx -y @systemdox/mcp-server sync-memory";
+var SyncFailed = class extends Error {
+};
+function refusal(e) {
+  if (!(e instanceof Error)) return {};
+  const { status, code } = e;
+  return { status: typeof status === "number" ? status : void 0, code: typeof code === "string" ? code : void 0 };
+}
+var toPath = (root, rel) => join4(root, ...rel.split("/"));
+async function readFolder(root) {
+  const files = {};
+  const names = /* @__PURE__ */ new Set();
+  async function walk2(dir, prefix) {
+    for (const e of await readdir2(dir, { withFileTypes: true })) {
+      if (e.name.startsWith(".")) continue;
+      const rel = prefix ? `${prefix}/${e.name}` : e.name;
+      if (e.isDirectory()) await walk2(join4(dir, e.name), rel);
+      else if (e.isFile()) {
+        names.add(rel.toLowerCase());
+        if (e.name.endsWith(".md")) files[rel] = await readFile4(join4(dir, e.name), "utf8");
+      }
+    }
+  }
+  if (existsSync3(root)) await walk2(root, "");
+  return { files, names };
+}
+async function pullTeam(client, ws, project) {
+  try {
+    const latest = await client.getMemory(ws, project);
+    return {
+      version: latest.version,
+      manifest: Object.fromEntries(Object.entries(latest.files).map(([p, f]) => [p, f.sha256])),
+      exists: true
+    };
+  } catch (e) {
+    if (refusal(e).status === 404) return { version: 0, manifest: {}, exists: false };
+    throw e;
+  }
+}
+async function readTexts(client, ws, project, hashes) {
+  const texts = {};
+  const one = async (batch) => {
+    let left = batch;
+    while (left.length) {
+      const got = await client.readBlobs(ws, project, left);
+      for (const b of got.blobs) texts[b.sha256] = b.content;
+      if (!got.blobs.length) break;
+      left = got.remaining;
+    }
+  };
+  for (let i = 0; i < hashes.length; i += 1e3) {
+    const batch = hashes.slice(i, i + 1e3);
+    try {
+      await one(batch);
+    } catch (e) {
+      if (!(refusal(e).status === 404)) throw e;
+      for (const h of batch) {
+        try {
+          await one([h]);
+        } catch (err) {
+          if (!(refusal(err).status === 404)) throw err;
+        }
+      }
+    }
+  }
+  return texts;
+}
+var Report = class {
+  pulled = /* @__PURE__ */ new Set();
+  pushed = /* @__PURE__ */ new Set();
+  deletedHere = /* @__PURE__ */ new Set();
+  deletedFromTeam = /* @__PURE__ */ new Set();
+  conflicts = [];
+  skipped = /* @__PURE__ */ new Map();
+  people = [];
+  toAnswer = /* @__PURE__ */ new Map();
+  add(plan) {
+    plan.pulled.forEach((p) => this.pulled.add(p));
+    plan.pushed.forEach((p) => this.pushed.add(p));
+    plan.deletedHere.forEach((p) => this.deletedHere.add(p));
+    plan.deletedFromTeam.forEach((p) => this.deletedFromTeam.add(p));
+    for (const c of plan.conflicts) this.conflicts.push(`${c.path}: the team's text; yours is beside it as ${c.copy}`);
+    for (const line of plan.indexTeamLines) this.conflicts.push(`${INDEX_FILE}: your line was kept; the team's was: ${line}`);
+  }
+  skip(path, reason) {
+    if (!this.skipped.has(path)) this.skipped.set(path, reason);
+  }
+  lines(summary, dryRun) {
+    const out = [summary];
+    const section = (title, items) => {
+      if (items.length) out.push("", `${title}:`, ...items.map((i) => `- ${i}`));
+    };
+    const sorted = (s) => [...s].sort();
+    section(dryRun ? "Would pull" : "Pulled", sorted(this.pulled));
+    section(dryRun ? "Would push" : "Pushed", sorted(this.pushed));
+    section(dryRun ? "Would delete" : "Deleted", [
+      ...sorted(this.deletedHere).map((p) => `${p} (here: the team deleted it)`),
+      ...sorted(this.deletedFromTeam).map((p) => `${p} (from the team: you deleted it)`)
+    ]);
+    section("Conflicts", this.conflicts);
+    section(
+      "Skipped",
+      [...this.skipped.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([p, why]) => `${p}: ${why}`)
+    );
+    section(
+      "People",
+      this.people.map(
+        (a) => [a.kind, a.answer, a.label, a.personId && `\`${a.personId}\``, a.files !== void 0 && `${a.files} files`].filter(Boolean).join(", ")
+      )
+    );
+    if (this.toAnswer.size) {
+      out.push(
+        "",
+        `Values still to answer: ${[...this.toAnswer.entries()].map(([kind, n]) => `${n} ${kind}`).join(", ")}.`
+      );
+    }
+    return out;
+  }
+};
+var ANSWER_WORDS = {
+  member: "a member's contact",
+  person: "someone else",
+  ours: "ours, not a person"
+};
+function labelProblem(label) {
+  if (!label) return "a label is needed";
+  if (label.length > 60) return "a label is at most 60 characters";
+  if (findPersonValues(label).length) return "a label is a role, never a phone number, an email address or a path";
+  return void 0;
+}
+async function askLabel(ask, out, question, optional) {
+  for (; ; ) {
+    const label = (await ask(question)).trim();
+    if (optional && !label) return void 0;
+    const problem = labelProblem(label);
+    if (!problem) return label;
+    out(`  ${problem}.`);
+  }
+}
+async function people(opts, ws, files, report, hint) {
+  const { client, out, ask, dryRun } = opts;
+  const terminal = !!ask && !dryRun;
+  const held = /* @__PURE__ */ new Set();
+  const leftOut = /* @__PURE__ */ new Set();
+  const current = { ...files };
+  for (const [path, text3] of Object.entries(current)) {
+    const secret = findSecrets(text3)[0];
+    if (secret) {
+      held.add(path);
+      report.skip(path, `a secret (${secret.kind}) on line ${secret.line}: remove it, then sync again`);
+    }
+  }
+  const { groups, findings } = collectValues(current);
+  const answers = /* @__PURE__ */ new Map();
+  for (let i = 0; i < groups.length; i += 500) {
+    const batch = groups.slice(i, i + 500);
+    const got = await client.lookupValues(ws, batch.map((g) => ({ kind: g.kind, value: g.value })));
+    batch.forEach((g, j) => {
+      const a = got.answers[j];
+      if (a && a.answer !== "unanswered") answers.set(groupKey(g.kind, g.normalised), a);
+    });
+  }
+  const vaultDown = /* @__PURE__ */ new Set();
+  if (terminal) {
+    const filed = [];
+    for (const g of groups) {
+      const key = groupKey(g.kind, g.normalised);
+      if (answers.has(key)) continue;
+      let choices = ["m", "p", "o", "x", "s"];
+      for (; ; ) {
+        const question = [
+          `${g.value} (${g.kind}) is in ${g.files.length} file${g.files.length === 1 ? "" : "s"}. First line it appears on, in ${g.first.path}:`,
+          `  ${g.first.text}`,
+          [
+            choices.includes("m") && "[m] a member's contact",
+            "[p] someone else",
+            "[o] ours, not a person",
+            "[x] leave these files out",
+            "[s] skip for now"
+          ].filter(Boolean).join("  "),
+          `Answer (${choices.join("/")}): `
+        ].join("\n");
+        const answer = (await ask(question)).trim().toLowerCase();
+        if (!choices.includes(answer)) continue;
+        if (answer === "s") break;
+        if (answer === "x") {
+          for (const path of g.files) {
+            if (leftOut.has(path)) continue;
+            current[path] = addShareFalse(current[path]);
+            await writeFile3(toPath(opts.dir, path), current[path], "utf8");
+            leftOut.add(path);
+          }
+          report.people.push({ kind: g.kind, answer: "left out (share: false)", files: g.files.length });
+          break;
+        }
+        if (answer === "p") {
+          const label2 = await askLabel(ask, out, "Their role, as a label (e.g. reseller, sales; never a name): ", false);
+          let entry = filed.length ? await (async () => {
+            const list = filed.map((f, i) => `  ${i + 1}. ${f.label}: ${f.groups.map((x) => x.value).join(", ")}`);
+            for (; ; ) {
+              const same = (await ask(["The same person as one filed above?", ...list, "Number, or Enter for a new person: "].join("\n"))).trim();
+              if (!same) return void 0;
+              const n = Number(same);
+              if (Number.isInteger(n) && n >= 1 && n <= filed.length && filed[n - 1].groups.length < 4) return filed[n - 1];
+            }
+          })() : void 0;
+          if (!entry) {
+            entry = { groups: [], label: label2 };
+            filed.push(entry);
+          }
+          entry.groups.push(g);
+          break;
+        }
+        const label = answer === "m" ? await askLabel(ask, out, "A role label for it (e.g. owner, business mobile), or Enter for none: ", true) : void 0;
+        let result;
+        try {
+          result = await client.answerValues(ws, [
+            { kind: g.kind, value: g.value, answer: answer === "m" ? "member" : "ours", ...label ? { label } : {} }
+          ]);
+        } catch (e) {
+          if (refusal(e).code === "SYD-K019") {
+            vaultDown.add(key);
+            out("  The vault did not answer (SYD-K019): the files holding it wait for the next sync.");
+            break;
+          }
+          throw e;
+        }
+        if (result.stored[0]) {
+          answers.set(key, result.stored[0]);
+          report.people.push({ kind: g.kind, answer: ANSWER_WORDS[result.stored[0].answer], label: result.stored[0].label, personId: result.stored[0].personId });
+          break;
+        }
+        const refused2 = result.refused[0];
+        if (refused2?.code === "SYD-K021") {
+          out(`  ${refused2.detail}. Add them in Staff first, or answer p to file them.`);
+          choices = choices.filter((c) => c !== "m");
+        } else if (refused2) out(`  ${refused2.detail}`);
+      }
+    }
+    for (let i = 0; i < filed.length; i += 50) {
+      const batch = filed.slice(i, i + 50);
+      let result;
+      try {
+        result = await client.fileMemoryPeople(
+          ws,
+          batch.map((f) => ({ values: f.groups.map((g) => ({ kind: g.kind, value: g.value })), label: f.label }))
+        );
+      } catch (e) {
+        if (refusal(e).code === "SYD-K019") {
+          out("Contacts did not answer (SYD-K019): the files holding those values wait for the next sync.");
+          batch.forEach((f) => f.groups.forEach((g) => vaultDown.add(groupKey(g.kind, g.normalised))));
+          continue;
+        }
+        throw e;
+      }
+      for (const stored of result.stored) {
+        let key;
+        try {
+          key = groupKey(stored.kind, normalise(stored.kind, stored.value));
+        } catch {
+          continue;
+        }
+        answers.set(key, stored);
+      }
+      for (const r of result.refused) {
+        out(`  ${batch[r.index]?.label ?? ""}: ${r.detail}`);
+      }
+      for (const f of batch) {
+        const a = answers.get(groupKey(f.groups[0].kind, f.groups[0].normalised));
+        if (a?.answer === "person") {
+          for (const g of f.groups) report.people.push({ kind: g.kind, answer: ANSWER_WORDS.person, label: a.label, personId: a.personId });
+        }
+      }
+    }
+  }
+  const rewritten = {};
+  for (const [path, text3] of Object.entries(current)) {
+    if (leftOut.has(path) || held.has(path)) continue;
+    const next = rewriteValues(text3, findings[path] ?? [], (f) => {
+      if (f.kind === HOME_PATH) return "~";
+      const a = answers.get(groupKey(f.kind, f.normalised));
+      return a && (a.answer === "member" || a.answer === "person") && a.personId ? personToken(a.personId, a.label) : void 0;
+    });
+    if (next !== text3) rewritten[path] = next;
+  }
+  const paths = Object.keys(rewritten).sort();
+  if (paths.length && terminal) {
+    out("", "The rewrite:");
+    for (const path of paths) out(path, ...lineDiff(current[path], rewritten[path]).map((l) => `  ${l}`));
+    const yes = /^y(es)?$/i.test((await ask(`Rewrite ${paths.length} file${paths.length === 1 ? "" : "s"} as shown? [y/N] `)).trim());
+    if (yes) {
+      for (const path of paths) {
+        await writeFile3(toPath(opts.dir, path), rewritten[path], "utf8");
+        current[path] = rewritten[path];
+      }
+    }
+  }
+  for (const [path, text3] of Object.entries(current)) {
+    if (leftOut.has(path) || held.has(path)) continue;
+    const pending = findPersonValues(text3).filter((f) => {
+      if (f.kind === HOME_PATH) return true;
+      return answers.get(groupKey(f.kind, f.normalised))?.answer !== "ours";
+    });
+    if (!pending.length) continue;
+    held.add(path);
+    const keys = pending.filter((f) => f.kind !== HOME_PATH).map((f) => groupKey(f.kind, f.normalised));
+    if (keys.some((k) => vaultDown.has(k))) {
+      report.skip(path, "the vault did not answer (SYD-K019) for a value in it; it syncs once the value is filed");
+    } else if (keys.some((k) => !answers.has(k))) {
+      report.skip(path, `it holds a value nobody has answered for: run \`${hint}\` in a terminal`);
+    } else {
+      report.skip(path, `it holds a value to rewrite as its identifier or ~: run \`${hint}\` in a terminal`);
+    }
+  }
+  for (const g of groups) {
+    const key = groupKey(g.kind, g.normalised);
+    if (!answers.has(key) && g.files.some((p) => !leftOut.has(p))) {
+      report.toAnswer.set(g.kind, (report.toAnswer.get(g.kind) ?? 0) + 1);
+    }
+  }
+  return { files: current, held, leftOut };
+}
+async function applyPlan(dir, plan) {
+  for (const [path, text3] of Object.entries(plan.writes)) {
+    const full = toPath(dir, path);
+    await mkdir3(dirname3(full), { recursive: true });
+    await writeFile3(full, text3, "utf8");
+  }
+  for (const path of plan.deletes) await rm3(toPath(dir, path), { force: true });
+}
+var sameManifest = (a, b) => Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([p, h]) => b[p] === h);
+async function upload(client, ws, project, plan, team, report) {
+  const byHash = /* @__PURE__ */ new Map();
+  for (const path of Object.keys(plan.upload)) {
+    const h = plan.manifest[path];
+    byHash.set(h, [...byHash.get(h) ?? [], path]);
+  }
+  const hashes = [...byHash.keys()];
+  const missing = [];
+  for (let i = 0; i < hashes.length; i += 1e4) {
+    missing.push(...(await client.findMissingBlobs(ws, project, hashes.slice(i, i + 1e4))).missing);
+  }
+  const blobs = missing.map((h) => ({ sha256: h, content: plan.upload[byHash.get(h)[0]] }));
+  let batch = [];
+  let bytes = 0;
+  const send = async () => {
+    if (!batch.length) return;
+    const result = await client.uploadBlobs(ws, project, batch);
+    for (const r of result.refused) {
+      for (const path of byHash.get(r.sha256) ?? []) {
+        if (team[path]) plan.manifest[path] = team[path];
+        else delete plan.manifest[path];
+        plan.pushed = plan.pushed.filter((p) => p !== path);
+        report.pushed.delete(path);
+        report.skip(path, `refused by SystemDox, ${r.detail.startsWith(r.code) ? r.detail : `${r.code}: ${r.detail}`}`);
+      }
+    }
+    batch = [];
+    bytes = 0;
+  };
+  for (const blob of blobs) {
+    const size = Buffer.byteLength(blob.content, "utf8");
+    if (batch.length === 100 || batch.length && bytes + size > 5 * 1024 * 1024 - 64 * 1024) await send();
+    batch.push(blob);
+    bytes += size;
+  }
+  await send();
+}
+async function syncMemory(opts) {
+  const { client, out } = opts;
+  const now = opts.now?.() ?? /* @__PURE__ */ new Date();
+  try {
+    const own = await client.getOwnTeamSetup();
+    const ws = own.workspace;
+    const project = opts.project ?? (own.memory.length === 1 ? own.memory[0].project : void 0);
+    if (!project) {
+      throw new SyncFailed(
+        own.memory.length ? `${ws} has ${own.memory.length} team memories (${own.memory.map((m) => m.project).join(", ")}): name one with --project.` : `${ws} has no team memory yet: name the project to start with --project.`
+      );
+    }
+    const dir = resolve3(opts.dir ?? join4(workspaceDir(ws), "memory", project));
+    const run2 = { ...opts, dir };
+    const hint = [SYNC_MEMORY_COMMAND, `--project ${project}`, opts.dir ? `--dir "${opts.dir}"` : ""].filter(Boolean).join(" ");
+    const report = new Report();
+    const date = localDate(now);
+    const stored = (await readState(ws)).memory?.[project];
+    let team = await pullTeam(client, ws, project);
+    let base = stored ? { version: stored.version, manifest: stored.manifest, exists: true } : { version: 0, manifest: {}, exists: false };
+    const folder = await readFolder(dir);
+    const shared = {};
+    const notShared = /* @__PURE__ */ new Set();
+    for (const [path, text3] of Object.entries(folder.files)) {
+      if (!isShareable(path, text3)) notShared.add(path);
+      else if (!isFilePath(path)) {
+        notShared.add(path);
+        report.skip(path, "its name has characters a team memory path cannot hold (letters, digits, '.', '_', '-')");
+      } else shared[path] = text3;
+    }
+    const importWrites = {};
+    if (opts.importDir) {
+      const other = await readFolder(resolve3(opts.importDir));
+      const taken = new Set(folder.names);
+      for (const [path, text3] of Object.entries(other.files).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!isShareable(path, text3) || !isFilePath(path)) continue;
+        const here = folder.files[path];
+        if (here === void 0) {
+          shared[path] = text3;
+          importWrites[path] = text3;
+          taken.add(path.toLowerCase());
+        } else if (here !== text3) {
+          const copy = conflictCopyName(path, date, taken);
+          taken.add(copy.toLowerCase());
+          importWrites[copy] = text3;
+          report.conflicts.push(`${path}: this folder's text; the imported one is beside it as ${copy}`);
+        }
+      }
+      folder.names = taken;
+      if (!opts.dryRun) {
+        for (const [path, text3] of Object.entries(importWrites)) {
+          const full = toPath(dir, path);
+          await mkdir3(dirname3(full), { recursive: true });
+          await writeFile3(full, text3, "utf8");
+        }
+      }
+    }
+    const found = await people(run2, ws, shared, report, hint);
+    for (const path of found.leftOut) {
+      delete found.files[path];
+      notShared.add(path);
+    }
+    const excluded = /* @__PURE__ */ new Set([...found.held, ...notShared]);
+    for (const path of found.held) delete found.files[path];
+    for (let attempt = 1; ; attempt++) {
+      const input = { base: base.manifest, team: team.manifest, local: found.files, excluded, taken: folder.names, date };
+      const { rows, needed } = decideAll(input);
+      const texts = needed.length ? await readTexts(client, ws, project, needed) : {};
+      const plan = planMerge(input, rows, texts);
+      report.add(plan);
+      if (opts.dryRun) {
+        const skipped = report.skipped.size;
+        out(
+          ...report.lines(
+            `Dry run of ${ws}/${project} against version ${team.version}: would pull ${report.pulled.size}, push ${report.pushed.size} and delete ${report.deletedHere.size + report.deletedFromTeam.size}; ${report.conflicts.length} conflicts, ${skipped} skipped. Nothing was asked, written or sent.`,
+            true
+          )
+        );
+        return 0;
+      }
+      await applyPlan(dir, plan);
+      let version = team.version;
+      if (!sameManifest(plan.manifest, team.manifest)) {
+        await upload(client, ws, project, plan, team.manifest, report);
+      }
+      if (!sameManifest(plan.manifest, team.manifest)) {
+        try {
+          version = (await client.pushMemoryVersion(ws, project, { baseVersion: team.version, manifest: plan.manifest })).version;
+        } catch (e) {
+          if (!(refusal(e).status === 409 && refusal(e).code === "SYD-K010")) throw e;
+          if (attempt === 2) {
+            out(
+              ...report.lines(
+                `Not pushed: ${ws}/${project} moved on twice while this sync merged. Your folder holds the merge; run sync-memory again.`,
+                false
+              )
+            );
+            return 2;
+          }
+          base = team;
+          for (const p of plan.pushed) report.pushed.delete(p);
+          const again = await readFolder(dir);
+          folder.names = again.names;
+          found.files = {};
+          for (const [path, text3] of Object.entries(again.files)) {
+            if (excluded.has(path) || !isShareable(path, text3) || !isFilePath(path)) continue;
+            found.files[path] = text3;
+          }
+          team = await pullTeam(client, ws, project);
+          continue;
+        }
+      }
+      await updateState(ws, (state) => {
+        state.memory = { ...state.memory, [project]: { version, manifest: plan.manifest } };
+      });
+      out(
+        ...report.lines(
+          `Synced ${ws}/${project} at version ${version}: ${report.pulled.size} pulled, ${report.pushed.size} pushed, ${report.deletedHere.size + report.deletedFromTeam.size} deleted, ${report.conflicts.length} conflicts, ${report.skipped.size} skipped.`,
+          false
+        )
+      );
+      return 0;
+    }
+  } catch (e) {
+    out(e.message);
+    return 1;
+  }
+}
+
+// src/tools/team-setup.ts
+var LAYOUT = {
+  hooks: { files: ["hooks/hooks.json"], folders: [{ dir: "scripts", md: false }], required: "hooks/hooks.json" },
+  mcp: { files: [".mcp.json"], folders: [], required: ".mcp.json" },
+  agents: { files: [], folders: [{ dir: "agents", md: true }] },
+  commands: { files: [], folders: [{ dir: "commands", md: true }] },
+  instructions: { files: ["CLAUDE.md"], folders: [], required: "CLAUDE.md" }
+};
+function expandHome2(path) {
+  return path.replace(/^~(?=$|[\\/])/, homedir4());
+}
+function text2(t) {
+  return { content: [{ type: "text", text: t }] };
+}
+async function isLink(path) {
+  try {
+    return (await lstat2(path)).isSymbolicLink();
+  } catch (e) {
+    if (e.code === "ENOENT") return false;
+    throw e;
+  }
+}
+async function readPartDirectory(part, directory) {
+  const root = resolve4(directory);
+  const layout = LAYOUT[part];
+  const paths = [];
+  const leftOut = [];
+  const links = [];
+  for (const path of layout.files) {
+    const segments = path.split("/");
+    let present = true;
+    for (let i = 1; i <= segments.length; i++) {
+      const rel = segments.slice(0, i).join("/");
+      if (await isLink(join5(root, ...segments.slice(0, i)))) {
+        links.push(rel);
+        present = false;
+        break;
+      }
+    }
+    if (present && existsSync4(join5(root, ...segments))) paths.push(path);
+  }
+  for (const { dir, md } of layout.folders) {
+    const full = join5(root, dir);
+    if (await isLink(full)) {
+      links.push(dir);
+      continue;
+    }
+    if (!existsSync4(full)) continue;
+    const walked = await walk(full, { skipHidden: true });
+    links.push(...walked.links.map((p) => `${dir}/${p}`));
+    leftOut.push(...walked.hidden.map((p) => `${dir}/${p}`));
+    for (const p of walked.files) {
+      if (md && !p.endsWith(".md")) leftOut.push(`${dir}/${p}`);
+      else paths.push(`${dir}/${p}`);
+    }
+  }
+  if (links.length) {
+    throw new Error(
+      `${links.join(", ")}: links are not followed; copy the file into the folder. Nothing was sent.`
+    );
+  }
+  if (layout.required && !paths.includes(layout.required)) {
+    throw new Error(`${root} has no ${layout.required}: the ${part} part needs it. Nothing was sent.`);
+  }
+  if (!paths.length) {
+    throw new Error(
+      `${root} has no ${layout.folders.map((f) => `${f.dir}/*.md`).join(" or ")}: nothing to publish for ${part}.`
+    );
+  }
+  return { files: await readTextFiles(root, paths.sort(), `the ${part} part`), leftOut };
+}
+function describePerson(id, person) {
+  const lines = [`**${person.label ?? "(no label)"}**, \`${id}\``];
+  if (person.mergedInto) {
+    lines.push(`\`${id}\` was merged into \`${person.mergedInto}\`: these are \`${person.mergedInto}\`'s details.`);
+  }
+  lines.push(`- Name: ${person.name ?? "(none held)"}`);
+  lines.push(`- Phone number: ${person.phone ?? "(none held)"}`);
+  lines.push(`- Email address: ${person.email ?? "(none held)"}`);
+  const token = `\`${person.mergedInto ?? id}\`${person.label ? ` (${person.label})` : ""}`;
+  lines.push(
+    "",
+    `These details are for this session only. Do not write them into a memory file, a note or a commit: a memory names this person by the identifier, as ${token}. A memory file that holds the details is offered for rewriting again at the next sync.`
+  );
+  return lines.join("\n");
+}
+function registerTeamSetupTools(server, apiClient, { localFiles }) {
+  const fileSchema = z16.object({
+    path: z16.string().describe(`Path inside the part's folder, forward slashes, e.g. "hooks/hooks.json"`),
+    content: z16.string().describe("The file's full text, exactly as it is")
+  });
+  server.registerTool(
+    "publish_setup_part",
+    {
+      title: "Publish Setup Part",
+      description: "Publish one part of your team's Claude Code setup to SystemDox: `hooks` (hooks/hooks.json and the scripts/ it calls), `mcp` (.mcp.json), `agents` (agents/*.md), `commands` (commands/*.md) or `instructions` (CLAUDE.md). Every part but instructions makes a new version of the team plugin, which each member accepts at their next update. Publishing hooks, mcp, agents or commands needs the admin role. " + (localFiles ? "Pass `directory`: the server reads only the files the part accepts, byte for byte, and refuses a link, a binary file or a file too large before anything is sent. Never retype the files into `files` when the folder is on this computer." : "Pass every file of the part in `files`, exactly as it is."),
+      inputSchema: {
+        part: z16.enum(PARTS2).describe("Which part of the setup"),
+        ...localFiles ? {
+          directory: z16.string().optional().describe(
+            "The folder on this computer: for hooks, the one holding hooks/hooks.json and scripts/; for mcp, the one holding .mcp.json; for instructions, the one holding CLAUDE.md; for agents or commands, the one holding agents/ or commands/"
+          )
+        } : {},
+        files: z16.array(fileSchema).optional().describe(localFiles ? "Only when there is no folder to read" : "Every file of the part")
+      },
+      annotations: { readOnlyHint: false }
+    },
+    async (args) => {
+      let files;
+      let leftOut = [];
+      if (localFiles && args.directory) {
+        ({ files, leftOut } = await readPartDirectory(args.part, expandHome2(args.directory)));
+      } else if (args.files?.length) {
+        files = args.files;
+      } else {
+        throw new Error(localFiles ? "Pass `directory` (or `files`)." : "Pass `files`.");
+      }
+      const { workspace } = await apiClient.getOwnTeamSetup();
+      const saved = await apiClient.publishPartVersion(workspace, args.part, files);
+      const lines = [`Published **${saved.part}** version ${saved.version}.`];
+      if (saved.part !== "instructions" && saved.pluginVersion !== void 0) {
+        lines.push(`Team plugin version ${saved.pluginVersion}; each member accepts it at their next update.`);
+      }
+      if (saved.replacedValues?.length) {
+        lines.push(
+          "Replaced by a reference to each member's own environment variable:",
+          ...saved.replacedValues.map((r) => `- ${r.server} ${r.field} ${r.name}: \${${r.name}}`)
+        );
+      }
+      if (leftOut.length) lines.push(`Left out (not part of ${args.part}): ${leftOut.join(", ")}`);
+      return text2(lines.join("\n"));
+    }
+  );
+  server.registerTool(
+    "resolve_person",
+    {
+      title: "Resolve Person",
+      description: "Read back a person that a team memory names by identifier, written as `con_\u2026` (label), `ctc_\u2026` or `usr_\u2026`: their label, name, phone number and email address, from the vault that holds them. The details are for this session only: never write them into a memory file; the memory keeps the identifier. Writes nothing.",
+      inputSchema: {
+        id: z16.string().regex(PERSON_ID_RE, "a con_, ctc_ or usr_ identifier, as written in the memory").describe("The identifier, e.g. con_01JC2Q8Y4M7T0X3K5N9P2R6S8V")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      const { workspace } = await apiClient.getOwnTeamSetup();
+      const person = await apiClient.resolvePerson(workspace, args.id);
+      return text2(describePerson(args.id, person));
+    }
+  );
+  if (!localFiles) return;
+  server.registerTool(
+    "sync_memory",
+    {
+      title: "Sync Memory",
+      description: `Sync one project's team memory on this computer with SystemDox: pull the files the team changed, push the ones changed here, keep both texts of a file changed on both sides. It never answers for a person: a file that still holds a phone number, an email address or a home-folder path is skipped and listed, with the command for the member to run in their own terminal (\`${SYNC_MEMORY_COMMAND}\`). Pass dryRun to see what it would do without writing or sending anything.`,
+      inputSchema: {
+        project: z16.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "a project name: lower case letters, digits and -").optional().describe("The project's team memory, e.g. puglieseweb-ltd; needed when the workspace has more than one"),
+        dryRun: z16.boolean().optional().describe("Show what would be pulled, pushed, deleted, conflicted and skipped, and change nothing")
+      },
+      annotations: { readOnlyHint: false }
+    },
+    async (args) => {
+      const lines = [];
+      const code = await syncMemory({
+        project: args.project,
+        dryRun: !!args.dryRun,
+        client: apiClient,
+        out: (...l) => lines.push(...l)
+      });
+      return { ...text2(lines.join("\n")), ...code ? { isError: true } : {} };
+    }
+  );
+}
+
+// src/server.ts
+var SERVER_VERSION = true ? "0.1.51" : "0.0.0-dev";
+function createServer(apiClient, { localFiles = false, instructions, keyProblem } = {}) {
+  const server = new McpServer(
+    {
+      name: "systemdox-mcp-server",
+      version: SERVER_VERSION
+    },
+    instructions ? { instructions } : void 0
+  );
+  registerGetGuardrails(server, apiClient);
+  registerGetSpecs(server, apiClient);
+  registerGetDocs(server, apiClient);
+  registerGetTechStack(server, apiClient);
+  registerGetPlanningContext(server, apiClient);
+  registerGetPlanBoard(server, apiClient);
+  registerGetChange(server, apiClient);
+  registerGetContext(server, apiClient);
+  registerGetProjectRules(server, apiClient);
+  registerGetPromptTemplates(server, apiClient);
+  registerGetTeamSetup(server, apiClient, { localFiles, keyProblem });
+  registerDocumentGraph(server, apiClient);
+  registerCreateGuardrail(server, apiClient);
+  registerUpdateSpec(server, apiClient);
+  registerReportDecision(server, apiClient);
+  registerCreateProjectRule(server, apiClient);
+  registerCreatePromptTemplate(server, apiClient);
+  registerSkillTools(server, apiClient, { localFiles });
+  registerTeamSetupTools(server, apiClient, { localFiles });
+  return server;
+}
+export {
+  createServer
+};