@ogygie/mcp 0.9.0

package/dist/server.js

@@ -0,0 +1,1304 @@
+// src/main.ts
+import { resolve as resolve2 } from "node:path";
+
+// ../ogygie-core/src/repo-adapter.ts
+import { readFile as readFileFromDisk, readdir, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join, resolve, sep } from "node:path";
+import { z as z2 } from "zod";
+
+// ../ogygie-core/src/error.schema.ts
+import { z } from "zod";
+var OgygieErrorSchema = z.object({
+  ogygie: z.literal(true).describe("Marker: lets an agent tell our errors from noise"),
+  code: z.string().regex(/^[A-Z][A-Z0-9_]+$/, "SCREAMING_SNAKE_CASE, stable over time"),
+  message: z.string().min(10).describe("Human-readable sentence (technical English)"),
+  file: z.string().nullable().describe("Relative path of the file involved, null when not localizable"),
+  cause: z.string().describe("The precise datum or condition that triggered the error"),
+  suggestedFix: z.string().describe("Concrete action to fix \u2014 never empty"),
+  details: z.record(z.string(), z.unknown()).default({}),
+  timestamp: z.iso.datetime()
+});
+function ogygieError(input) {
+  return OgygieErrorSchema.parse({
+    ogygie: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    details: {},
+    ...input
+  });
+}
+var OgygieFailure = class extends Error {
+  error;
+  httpStatus;
+  constructor(error, httpStatus = 500) {
+    super(error.message);
+    this.name = "OgygieFailure";
+    this.error = error;
+    this.httpStatus = httpStatus;
+  }
+};
+function throwOgygieError(input, httpStatus = 500) {
+  throw new OgygieFailure(ogygieError(input), httpStatus);
+}
+
+// ../ogygie-core/src/repo-adapter.ts
+var RepoFileEntrySchema = z2.object({
+  /** Path relative to the LISTED directory, "/" separated, never absolute. */
+  path: z2.string(),
+  sizeBytes: z2.number().int().nonnegative()
+});
+var NEVER_LISTED = /* @__PURE__ */ new Set(["node_modules"]);
+function isSkippedDirectory(name) {
+  return name.startsWith(".") || NEVER_LISTED.has(name);
+}
+function refusePathOutsideRepo(relativePath, cause) {
+  return throwOgygieError(
+    {
+      code: "PATH_OUTSIDE_REPO",
+      message: "The requested path resolves outside the repo root.",
+      file: relativePath,
+      cause,
+      suggestedFix: "Address a path INSIDE the repo, written relative to its root and without `..`."
+    },
+    400
+  );
+}
+function resolveInsideRoot(rootDir, relativePath) {
+  if (isAbsolute(relativePath)) {
+    refusePathOutsideRepo(relativePath, `"${relativePath}" is an absolute path`);
+  }
+  const root = resolve(rootDir);
+  const absolute = resolve(root, relativePath);
+  if (absolute !== root && !absolute.startsWith(root + sep)) {
+    refusePathOutsideRepo(relativePath, `"${relativePath}" resolves to "${absolute}", outside "${root}"`);
+  }
+  return absolute;
+}
+async function assertRealPathInsideRoot(rootDir, absolute, relativePath) {
+  let realRoot;
+  let realTarget;
+  try {
+    realRoot = await realpath(rootDir);
+    realTarget = await realpath(absolute);
+  } catch {
+    return;
+  }
+  if (realTarget !== realRoot && !realTarget.startsWith(realRoot + sep)) {
+    refusePathOutsideRepo(
+      relativePath,
+      `"${relativePath}" is a symbolic link leading to "${realTarget}", outside "${realRoot}"`
+    );
+  }
+}
+async function listFilesRecursively(absoluteDir, prefix) {
+  let entries;
+  try {
+    entries = await readdir(absoluteDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const relativePath = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      if (isSkippedDirectory(entry.name)) continue;
+      files.push(...await listFilesRecursively(join(absoluteDir, entry.name), relativePath));
+    } else if (entry.isFile()) {
+      const stats = await stat(join(absoluteDir, entry.name));
+      files.push({ path: relativePath, sizeBytes: stats.size });
+    }
+  }
+  return files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+async function resolveGitDirs(rootDir) {
+  const dotGit = join(rootDir, ".git");
+  let gitDir;
+  try {
+    const stats = await stat(dotGit);
+    if (stats.isDirectory()) {
+      gitDir = dotGit;
+    } else {
+      const pointer = (await readFileFromDisk(dotGit, "utf8")).trim();
+      const target = pointer.startsWith("gitdir:") ? pointer.slice("gitdir:".length).trim() : "";
+      if (target === "") return null;
+      gitDir = isAbsolute(target) ? target : resolve(rootDir, target);
+    }
+  } catch {
+    return null;
+  }
+  try {
+    const commonPointer = (await readFileFromDisk(join(gitDir, "commondir"), "utf8")).trim();
+    return { gitDir, commonDir: isAbsolute(commonPointer) ? commonPointer : resolve(gitDir, commonPointer) };
+  } catch {
+    return { gitDir, commonDir: gitDir };
+  }
+}
+async function readRefSha(dirs, refName) {
+  for (const base of [dirs.gitDir, dirs.commonDir]) {
+    try {
+      const sha = (await readFileFromDisk(join(base, refName), "utf8")).trim();
+      if (sha !== "") return sha;
+    } catch {
+    }
+  }
+  try {
+    const packed = await readFileFromDisk(join(dirs.commonDir, "packed-refs"), "utf8");
+    for (const line of packed.split("\n")) {
+      if (line.startsWith("#") || line.startsWith("^")) continue;
+      const [sha, name] = line.trim().split(" ");
+      if (name === refName && sha !== void 0 && sha !== "") return sha;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function createFilesystemRepoAdapter(rootDir) {
+  return {
+    async readFile(relativePath) {
+      const absolute = resolveInsideRoot(rootDir, relativePath);
+      await assertRealPathInsideRoot(rootDir, absolute, relativePath);
+      try {
+        return await readFileFromDisk(absolute, "utf8");
+      } catch (thrown) {
+        return throwOgygieError({
+          code: "REPO_FILE_NOT_FOUND",
+          message: "The requested file cannot be read from the repo.",
+          file: relativePath,
+          cause: `reading "${absolute}" failed: ${thrown instanceof Error ? thrown.message : String(thrown)}`,
+          suggestedFix: "Check the path against what the map declares \u2014 the manifest is the only chart of a repo."
+        });
+      }
+    },
+    async listDirectory(relativePath) {
+      const absolute = resolveInsideRoot(rootDir, relativePath);
+      await assertRealPathInsideRoot(rootDir, absolute, relativePath);
+      return listFilesRecursively(absolute, "");
+    },
+    async exists(relativePath) {
+      const absolute = resolveInsideRoot(rootDir, relativePath);
+      await assertRealPathInsideRoot(rootDir, absolute, relativePath);
+      try {
+        await stat(absolute);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async currentRef() {
+      const dirs = await resolveGitDirs(rootDir);
+      if (dirs === null) return null;
+      let head;
+      try {
+        head = (await readFileFromDisk(join(dirs.gitDir, "HEAD"), "utf8")).trim();
+      } catch {
+        return null;
+      }
+      if (!head.startsWith("ref:")) return head === "" ? null : head;
+      return readRefSha(dirs, head.slice("ref:".length).trim());
+    }
+  };
+}
+
+// ../ogygie-core/src/manifest.schema.ts
+import { z as z3 } from "zod";
+var FeatureNameSchema = z3.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "kebab-case required");
+var PackageDependencySchema = z3.string().regex(/^package:[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "expected package:<kebab-case-name>");
+var HttpRouteSchema = z3.object({
+  method: z3.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+  path: z3.string().startsWith("/api/"),
+  description: z3.string().min(10),
+  schemaInput: z3.string().describe("Exported name of the input Zod schema, e.g. CreateOrderInputSchema"),
+  schemaOutput: z3.string().describe("Exported name of the output Zod schema"),
+  invalidates: z3.array(z3.string()).optional().describe(
+    "Cache roots this mutation stales BEYOND its own path root (cross-feature dependency, read by the manifest-derived client \u2014 never guessed in a screen). Each value must be an existing feature name or route root"
+  )
+});
+var SharedTableKindSchema = z3.enum(["reference", "ownerless"]);
+var DbTableDeclarationSchema = z3.union([
+  z3.string(),
+  z3.object({
+    name: z3.string(),
+    shared: z3.literal(true),
+    sharedKind: SharedTableKindSchema.optional()
+  })
+]);
+var FeatureManifestSchema = z3.object({
+  name: FeatureNameSchema,
+  intent: z3.string().min(20).max(300).describe("The feature's 'why' in 1-3 sentences"),
+  app: z3.string().optional().describe("Name of the owning app (apps[].name); defaults to the api app"),
+  folder: z3.string().describe("Path relative to the app root, e.g. src/features/orders"),
+  spec: z3.string().nullable().describe("Path to the spec, e.g. specs/orders.spec.md, null for technical features"),
+  routes: z3.array(HttpRouteSchema),
+  dbTables: z3.array(DbTableDeclarationSchema).describe(
+    "Drizzle tables owned by this feature (one table = one owner). String = tenant-scoped; { name, shared: true } = shared referential"
+  ),
+  dependsOn: z3.array(z3.union([FeatureNameSchema, PackageDependencySchema])).describe(
+    "Features imported through their index.ts, and product packages as package:<name> \u2014 nothing else"
+  ),
+  status: z3.enum(["skeleton", "in-progress", "delivered"])
+});
+var OgygieVersionSchema = z3.string().regex(/^\d+\.\d+\.\d+$/, "expected a plain x.y.z version");
+var FrameworkManifestSchema = z3.object({
+  packages: z3.array(
+    z3.object({
+      name: z3.string().describe("Published npm name, e.g. @ogygie/core"),
+      path: z3.string().describe("Folder relative to the repo root"),
+      intent: z3.string().min(20),
+      /**
+       * The spec describing this package, when one does. Named EXPLICITLY
+       * because a published npm name (`@ogygie/mcp`) is not a spec id
+       * (`ogygie-mcp`) — the other two natures of entry match by name, this
+       * one cannot. Several packages may point at the same spec: a spec of
+       * the framework often spans the core and the CLI.
+       */
+      spec: z3.string().nullable(),
+      /**
+       * How far along, in the SAME words as the other natures. Required, and
+       * deliberately without default: a lifecycle gate that guesses a status
+       * confirms specs nobody delivered.
+       */
+      status: z3.enum(["skeleton", "in-progress", "delivered"])
+    })
+  ),
+  templates: z3.object({
+    project: z3.string().describe("Folder copied by `ogygie init`"),
+    feature: z3.string().describe("Reserved for `ogygie generate feature` (not wired yet)")
+  }),
+  governedFiles: z3.string().describe("Module declaring the exhaustive list of files `upgrade` may overwrite (D3)")
+});
+var VocabularyEntrySchema = z3.object({
+  canonical: z3.string().regex(/^[a-z][a-zA-Z0-9]*$/, "camelCase English term required").describe("The one machine term for this concept, e.g. gadget"),
+  forbiddenAliases: z3.array(
+    z3.string().min(2).regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "lowercase root (kebab-case allowed) required")
+  ).min(1).describe("Roots the code may never carry for this concept, e.g. widget"),
+  reference: z3.string().optional().describe("Anchor into AGENTS.product.md where the concept is explained")
+});
+var ProductVocabularySchema = z3.object({
+  entries: z3.array(VocabularyEntrySchema)
+});
+var PackageManifestSchema = z3.object({
+  name: FeatureNameSchema,
+  path: z3.string().describe("Folder relative to the repo root, e.g. packages/solver"),
+  intent: z3.string().min(20).max(300).describe("The package's 'why' in 1-3 sentences"),
+  spec: z3.string().nullable(),
+  dependsOn: z3.array(PackageDependencySchema).describe("Other PRODUCT packages, as package:<name> \u2014 never a feature: a package that depended on one would live under an app, and would be a feature"),
+  status: z3.enum(["skeleton", "in-progress", "delivered"])
+});
+var TenancyManifestSchema = z3.object({
+  column: z3.string().min(1).describe("SQL name of the tenant column, e.g. workspace_id \u2014 the one AGENTS.product.md announces"),
+  rawDbAllowed: z3.array(FeatureNameSchema).default([]).describe(
+    "Features allowed to reach the raw database: the tenancy socle, which BUILDS the contexts and therefore predates them. Every other feature goes through tenantDb"
+  )
+});
+var OgygieManifestSchema = z3.object({
+  version: z3.literal(1),
+  product: z3.object({
+    name: z3.string(),
+    description: z3.string().min(20)
+  }),
+  ogygieVersion: OgygieVersionSchema.optional(),
+  framework: FrameworkManifestSchema.optional(),
+  apps: z3.array(
+    z3.object({
+      name: z3.string(),
+      path: z3.string(),
+      type: z3.enum(["api", "front", "gateway"]),
+      entryPoint: z3.string(),
+      /**
+       * Code the product HOSTS without maintaining it — imported as-is from
+       * elsewhere, the framework's own dev tooling being the typical case.
+       * A vendored app is skipped by the vocabulary gate: a product's business
+       * vocabulary has no claim over code it will never rename.
+       *
+       * A literal `true`, like `shared` on a table: an app is either vendored
+       * (and says so) or the product's own (and stays silent) — no third
+       * state. The derogation is declared here, machine-readably, and the gate
+       * ANNOUNCES it on every run — one that stops being visible is one that
+       * gets forgotten.
+       */
+      vendored: z3.literal(true).optional()
+    })
+  ),
+  features: z3.array(FeatureManifestSchema),
+  tenancy: TenancyManifestSchema.optional().describe(
+    "Product values the framework gates need \u2014 absent, the tenancy checks do not run"
+  ),
+  packages: z3.array(PackageManifestSchema).optional().describe("Product code living outside every app \u2014 libraries, engines. Absent = the project has none"),
+  vocabulary: ProductVocabularySchema.optional().describe(
+    "The product's closed vocabulary \u2014 declared here, enforced by `ogygie verify-vocabulary`. Absent = gate silent"
+  ),
+  conventions: z3.object({
+    agentsMd: z3.literal("AGENTS.md"),
+    failuresMd: z3.literal("FAILURES.md"),
+    specsFolder: z3.literal("specs/")
+  })
+}).superRefine((manifest, context) => {
+  const featureNames = new Set(manifest.features.map((feature) => feature.name));
+  const packageNames = /* @__PURE__ */ new Set();
+  (manifest.packages ?? []).forEach((packageEntry, index) => {
+    if (featureNames.has(packageEntry.name)) {
+      context.addIssue({
+        code: "custom",
+        path: ["packages", index, "name"],
+        message: `"${packageEntry.name}" is already the name of a feature \u2014 one name designates one thing`
+      });
+    }
+    if (packageNames.has(packageEntry.name)) {
+      context.addIssue({
+        code: "custom",
+        path: ["packages", index, "name"],
+        message: `package "${packageEntry.name}" is declared twice`
+      });
+    }
+    packageNames.add(packageEntry.name);
+  });
+  const specIdOf3 = (specPath) => (specPath.split("/").pop() ?? specPath).replace(/\.spec\.md$/, "");
+  const ownedSpecIds = /* @__PURE__ */ new Set([
+    ...manifest.features.map((feature) => feature.name),
+    ...packageNames
+  ]);
+  (manifest.framework?.packages ?? []).forEach((packageEntry, index) => {
+    if (packageEntry.spec === null) return;
+    const specId = specIdOf3(packageEntry.spec);
+    if (ownedSpecIds.has(specId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["framework", "packages", index, "spec"],
+        message: `spec "${specId}" is already owned by a feature or a product package \u2014 one spec, one owner`
+      });
+    }
+  });
+  const checkPackageDependencies = (dependsOn, path) => {
+    dependsOn.forEach((dependency, dependencyIndex) => {
+      if (!dependency.startsWith("package:")) return;
+      const target = dependency.slice("package:".length);
+      if (!packageNames.has(target)) {
+        context.addIssue({
+          code: "custom",
+          path: [...path, dependencyIndex],
+          message: `dependency "${dependency}" matches no declared package`
+        });
+      }
+    });
+  };
+  manifest.features.forEach((feature, index) => {
+    checkPackageDependencies(feature.dependsOn, ["features", index, "dependsOn"]);
+  });
+  (manifest.packages ?? []).forEach((packageEntry, index) => {
+    checkPackageDependencies(packageEntry.dependsOn, ["packages", index, "dependsOn"]);
+  });
+  (manifest.tenancy?.rawDbAllowed ?? []).forEach((featureName, index) => {
+    if (!featureNames.has(featureName)) {
+      context.addIssue({
+        code: "custom",
+        path: ["tenancy", "rawDbAllowed", index],
+        message: `"${featureName}" matches no declared feature`
+      });
+    }
+  });
+  const canonicalOwners = /* @__PURE__ */ new Map();
+  const aliasOwners = /* @__PURE__ */ new Map();
+  (manifest.vocabulary?.entries ?? []).forEach((entry, index) => {
+    const canonicalRoot = entry.canonical.toLowerCase();
+    const firstOwner = canonicalOwners.get(canonicalRoot);
+    if (firstOwner !== void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["vocabulary", "entries", index, "canonical"],
+        message: `canonical "${entry.canonical}" is already declared by entry ${firstOwner}`
+      });
+    } else {
+      canonicalOwners.set(canonicalRoot, index);
+    }
+  });
+  (manifest.vocabulary?.entries ?? []).forEach((entry, index) => {
+    entry.forbiddenAliases.forEach((alias, aliasIndex) => {
+      const path = ["vocabulary", "entries", index, "forbiddenAliases", aliasIndex];
+      const canonicalOwner = canonicalOwners.get(alias);
+      if (canonicalOwner !== void 0) {
+        context.addIssue({
+          code: "custom",
+          path,
+          message: `alias "${alias}" is the canonical term of entry ${canonicalOwner} \u2014 a term cannot be both`
+        });
+        return;
+      }
+      const firstOwner = aliasOwners.get(alias);
+      if (firstOwner !== void 0) {
+        context.addIssue({
+          code: "custom",
+          path,
+          message: `alias "${alias}" is already forbidden by entry ${firstOwner} \u2014 one alias belongs to one concept`
+        });
+        return;
+      }
+      aliasOwners.set(alias, index);
+    });
+  });
+  const appsByName = new Map(manifest.apps.map((app) => [app.name, app]));
+  const knownInvalidationTargets = new Set(
+    manifest.features.map((feature) => feature.name)
+  );
+  for (const feature of manifest.features) {
+    for (const route of feature.routes) {
+      const root = route.path.split("/")[2];
+      if (root !== void 0) knownInvalidationTargets.add(root);
+    }
+  }
+  manifest.features.forEach((feature, index) => {
+    feature.routes.forEach((route, routeIndex) => {
+      for (const target of route.invalidates ?? []) {
+        if (!knownInvalidationTargets.has(target)) {
+          context.addIssue({
+            code: "custom",
+            path: ["features", index, "routes", routeIndex, "invalidates"],
+            message: `invalidates target "${target}" matches no feature name and no route root`
+          });
+        }
+      }
+    });
+  });
+  manifest.features.forEach((feature, index) => {
+    if (feature.app === void 0) return;
+    const owningApp = appsByName.get(feature.app);
+    if (owningApp === void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["features", index, "app"],
+        message: `app "${feature.app}" is not declared in apps[]`
+      });
+      return;
+    }
+    if (owningApp.type !== "api" && (feature.routes.length > 0 || feature.dbTables.length > 0)) {
+      context.addIssue({
+        code: "custom",
+        path: ["features", index],
+        message: "a non-api feature owns no HTTP routes and no DB tables \u2014 declare them on the api feature"
+      });
+    }
+  });
+});
+
+// src/schemas.ts
+import { z as z5 } from "zod";
+
+// ../ogygie-core/src/spec.schema.ts
+import { z as z4 } from "zod";
+var DeferredBehaviorSchema = z4.string().regex(
+  /^.+ blockedBy:[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
+  'Expected "<behavior> blockedBy:<feature-name>" (feature name in kebab-case)'
+);
+var SpecFrontmatterSchema = z4.object({
+  id: FeatureNameSchema.describe("Identical to the feature name in the manifest"),
+  status: z4.enum(["draft", "validated", "implemented"]),
+  depends_on: z4.array(FeatureNameSchema),
+  priority: z4.enum(["P0", "P1", "P2"]),
+  refs: z4.array(z4.string()).default([]).describe("References to the domain model, e.g. 'modele-gally \xA74.2'"),
+  deferred: z4.array(DeferredBehaviorSchema).default([]).describe("Behaviors deferred to a later feature (DECISIONS.md D13)")
+});
+function splitInlineArrayElements(inner) {
+  const elements = [];
+  let current = "";
+  let openQuote = null;
+  for (const character of inner) {
+    if (openQuote === null && (character === '"' || character === "'")) {
+      openQuote = character;
+      current += character;
+    } else if (character === openQuote) {
+      openQuote = null;
+      current += character;
+    } else if (openQuote === null && character === ",") {
+      elements.push(current);
+      current = "";
+    } else {
+      current += character;
+    }
+  }
+  elements.push(current);
+  return { elements, unbalancedQuote: openQuote !== null };
+}
+function unquote(raw, location, problems) {
+  const trimmed = raw.trim();
+  const first = trimmed[0];
+  if (first === '"' || first === "'") {
+    if (trimmed.length < 2 || !trimmed.endsWith(first)) {
+      problems.push(`${location}: unbalanced quotes in ${JSON.stringify(trimmed)}`);
+      return null;
+    }
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseSpecFrontmatter(text) {
+  const value = {};
+  const problems = [];
+  const lines = text.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const trimmed = (lines[index] ?? "").trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1 || trimmed.startsWith('"') || trimmed.startsWith("'")) {
+      problems.push(
+        `unparseable line ${JSON.stringify(trimmed)}: expected \`key: value\` \u2014 a spilled array element outside any array? (scalars and arrays of scalars only, D13)`
+      );
+      continue;
+    }
+    const key = trimmed.slice(0, colonIndex).trim();
+    let rawValue = trimmed.slice(colonIndex + 1).trim();
+    if (rawValue.startsWith("[")) {
+      let closed = rawValue.endsWith("]");
+      while (!closed && index + 1 < lines.length) {
+        index += 1;
+        rawValue = `${rawValue} ${(lines[index] ?? "").trim()}`;
+        closed = rawValue.endsWith("]");
+      }
+      if (!closed) {
+        problems.push(
+          `key "${key}": array opened with "[" and never closed with "]" before the end of the frontmatter \u2014 a truncated array would be silently read as empty, hence refused (D13)`
+        );
+        continue;
+      }
+      const { elements, unbalancedQuote } = splitInlineArrayElements(
+        rawValue.slice(1, -1)
+      );
+      if (unbalancedQuote) {
+        problems.push(`key "${key}": unbalanced quotes inside the array`);
+        continue;
+      }
+      const parsedElements = [];
+      let broken = false;
+      for (const element of elements) {
+        if (element.trim() === "") continue;
+        const unquoted = unquote(element, `key "${key}"`, problems);
+        if (unquoted === null) broken = true;
+        else parsedElements.push(unquoted);
+      }
+      if (!broken) value[key] = parsedElements;
+    } else {
+      const unquoted = unquote(rawValue, `key "${key}"`, problems);
+      if (unquoted !== null) value[key] = unquoted;
+    }
+  }
+  return { value, problems };
+}
+
+// src/schemas.ts
+var RepoIdSchema = z5.string().regex(/^[a-z0-9-]+$/);
+var FeatureNameSchema2 = z5.string().regex(/^[a-z0-9-]+$/);
+var SpecIdSchema = FeatureNameSchema2;
+var DecisionIdSchema = z5.string().regex(/^D\d+$/);
+var SpecStatusSchema = z5.enum(["draft", "validated", "implemented"]);
+var GovernanceFileSchema = z5.enum([
+  "AGENTS.md",
+  "AGENTS.product.md",
+  "FAILURES.md"
+]);
+var DECISION_FILES = ["DECISIONS.md", "DECISIONS.product.md"];
+var RepoRegistrySchema = z5.object({
+  repos: z5.array(
+    z5.object({
+      id: RepoIdSchema,
+      rootPath: z5.string().min(1)
+    })
+  ).min(1)
+});
+var ProvenanceSchema = z5.object({
+  repo: RepoIdSchema,
+  path: z5.string(),
+  /** HEAD SHA — null when the served root is not a git clone. */
+  ref: z5.string().nullable()
+});
+var ReadManifestInput = { repo: RepoIdSchema };
+var ListSpecsInput = { repo: RepoIdSchema, status: SpecStatusSchema.optional() };
+var ReadSpecInput = { repo: RepoIdSchema, id: SpecIdSchema };
+var ReadDecisionsInput = { repo: RepoIdSchema, decision: DecisionIdSchema.optional() };
+var ReadGovernanceInput = { repo: RepoIdSchema, file: GovernanceFileSchema };
+var ReadFeatureInput = {
+  repo: RepoIdSchema,
+  feature: FeatureNameSchema2,
+  file: z5.string().optional()
+};
+var RepoInfoSchema = z5.object({
+  id: RepoIdSchema,
+  /** null when the manifest declares none — the framework's own repo does not. */
+  ogygieVersion: z5.string().nullable(),
+  ref: z5.string().nullable()
+});
+var SpecSummarySchema = z5.object({
+  id: SpecIdSchema,
+  status: SpecStatusSchema,
+  priority: z5.enum(["P0", "P1", "P2"]),
+  dependsOn: z5.array(SpecIdSchema),
+  deferred: z5.array(z5.string())
+});
+var SpecListingSchema = z5.object({
+  specs: z5.array(SpecSummarySchema),
+  invalid: z5.array(z5.object({ id: SpecIdSchema, problems: z5.array(z5.string()) }))
+});
+var SpecDocumentSchema = z5.object({
+  frontmatter: SpecFrontmatterSchema.nullable(),
+  frontmatterProblems: z5.array(z5.string()),
+  body: z5.string(),
+  provenance: ProvenanceSchema
+});
+var TextDocumentSchema = z5.object({
+  content: z5.string(),
+  provenance: ProvenanceSchema
+});
+var FeatureListingSchema = z5.object({
+  feature: FeatureNameSchema2,
+  files: z5.array(z5.object({ path: z5.string(), sizeBytes: z5.number().int().nonnegative() })),
+  provenance: ProvenanceSchema
+});
+var McpErrorCodeSchema = z5.enum([
+  "REGISTRY_INVALID",
+  "REPO_NOT_OGYGIE",
+  "REPO_VERSION_UNSUPPORTED",
+  "REPO_UNKNOWN",
+  "MANIFEST_INVALID",
+  "SPEC_NOT_FOUND",
+  "DECISION_NOT_FOUND",
+  "FEATURE_NOT_FOUND",
+  "FILE_TOO_LARGE",
+  "FILE_NOT_TEXT",
+  "PATH_OUTSIDE_REPO",
+  "UNAUTHORIZED",
+  "TOKEN_MISSING"
+]);
+var MAX_FILE_BYTES = 2e5;
+var MIN_TOKEN_LENGTH = 32;
+
+// src/registry.ts
+var MANIFEST_PATH = "ogygie.manifest.json";
+function parseRegistry(raw) {
+  const parsed = RepoRegistrySchema.safeParse(raw);
+  if (!parsed.success) {
+    return throwOgygieError({
+      code: "REGISTRY_INVALID",
+      message: "The MCP repo registry does not match RepoRegistrySchema.",
+      file: null,
+      cause: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(" ; "),
+      suggestedFix: 'Write { "repos": [{ "id": "<kebab-case>", "rootPath": "<path>" }] } with at least one entry.'
+    });
+  }
+  return parsed.data;
+}
+function isNewerThan(candidate, reference) {
+  const toParts = (version) => version.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left = toParts(candidate);
+  const right = toParts(reference);
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const a = left[index] ?? 0;
+    const b = right[index] ?? 0;
+    if (a !== b) return a > b;
+  }
+  return false;
+}
+async function readManifest(repo) {
+  const raw = await repo.adapter.readFile(MANIFEST_PATH);
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(raw);
+  } catch (thrown) {
+    return throwOgygieError({
+      code: "MANIFEST_INVALID",
+      message: `The manifest of repo "${repo.id}" is not valid JSON.`,
+      file: MANIFEST_PATH,
+      cause: thrown instanceof Error ? thrown.message : String(thrown),
+      suggestedFix: "Fix the JSON syntax of ogygie.manifest.json in that repo."
+    });
+  }
+  const parsed = OgygieManifestSchema.safeParse(parsedJson);
+  if (!parsed.success) {
+    return throwOgygieError({
+      code: "MANIFEST_INVALID",
+      message: `The manifest of repo "${repo.id}" does not match OgygieManifestSchema.`,
+      file: MANIFEST_PATH,
+      cause: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(" ; "),
+      suggestedFix: "Run `pnpm ogygie:verify-manifest` in that repo \u2014 a client reading an invalid map would decide on a fiction."
+    });
+  }
+  return parsed.data;
+}
+async function openRepos(registry, deps) {
+  const opened = [];
+  for (const declared of registry.repos) {
+    const adapter = deps.openRepo(declared.rootPath);
+    if (!await adapter.exists(MANIFEST_PATH)) {
+      throwOgygieError({
+        code: "REPO_NOT_OGYGIE",
+        message: `Repo "${declared.id}" has no ${MANIFEST_PATH} at its root.`,
+        file: declared.rootPath,
+        cause: `${declared.rootPath}/${MANIFEST_PATH} does not exist`,
+        suggestedFix: "Point rootPath at the ROOT of an Ogygie repo, or remove the entry from the registry."
+      });
+    }
+    const repo = {
+      id: declared.id,
+      rootPath: declared.rootPath,
+      adapter,
+      ogygieVersion: null
+    };
+    const manifest = await readManifest(repo);
+    repo.ogygieVersion = manifest.ogygieVersion ?? null;
+    if (repo.ogygieVersion !== null && isNewerThan(repo.ogygieVersion, deps.serverVersion)) {
+      throwOgygieError({
+        code: "REPO_VERSION_UNSUPPORTED",
+        message: `Repo "${declared.id}" pins Ogygie ${repo.ogygieVersion}, newer than this server (${deps.serverVersion}).`,
+        file: MANIFEST_PATH,
+        cause: `ogygieVersion=${repo.ogygieVersion} > server=${deps.serverVersion}`,
+        suggestedFix: `Update the server to a version \u2265 ${repo.ogygieVersion}: pnpm update @ogygie/mcp@${repo.ogygieVersion}`
+      });
+    }
+    opened.push(repo);
+  }
+  return opened;
+}
+function repoOf(repos, repoId) {
+  const found = repos.find((candidate) => candidate.id === repoId);
+  if (found === void 0) {
+    return throwOgygieError({
+      code: "REPO_UNKNOWN",
+      message: `No repo "${repoId}" is registered on this server.`,
+      file: null,
+      cause: `known repos: ${repos.map((repo) => repo.id).join(", ") || "<none>"}`,
+      suggestedFix: "Call ogygie_list_repos to see what this server serves."
+    });
+  }
+  return found;
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../ogygie-core/src/decision-refs.ts
+var DECISION_HEADING = /^##\s+D(\d+)\b/;
+function parseKnownDecisionIds(decisionsMarkdown) {
+  const ids = [];
+  for (const line of decisionsMarkdown.split("\n")) {
+    const heading = DECISION_HEADING.exec(line);
+    if (heading !== null) ids.push(`D${heading[1]}`);
+  }
+  return ids;
+}
+function extractDecisionSection(decisionsMarkdown, decisionId) {
+  const lines = decisionsMarkdown.split("\n");
+  const trimTrailingBlanks = (section) => {
+    while (section.length > 0 && (section[section.length - 1] ?? "").trim() === "") section.pop();
+    return section.join("\n");
+  };
+  let start = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    const heading = DECISION_HEADING.exec(lines[index] ?? "");
+    if (heading === null) continue;
+    if (start === -1) {
+      if (`D${heading[1]}` === decisionId) start = index;
+      continue;
+    }
+    return trimTrailingBlanks(lines.slice(start, index));
+  }
+  return start === -1 ? null : trimTrailingBlanks(lines.slice(start));
+}
+
+// ../ogygie-core/src/manifest-owners.ts
+var ADVANCEMENT = ["skeleton", "in-progress", "delivered"];
+function specIdOf(specPath) {
+  return (specPath.split("/").pop() ?? specPath).replace(/\.spec\.md$/, "");
+}
+function findSpecOwner(manifest, specId) {
+  const feature = manifest.features.find((candidate) => candidate.name === specId);
+  if (feature !== void 0) {
+    const owningApp = feature.app === void 0 ? manifest.apps.find((app) => app.type === "api") : manifest.apps.find((app) => app.name === feature.app);
+    return {
+      kind: "feature",
+      name: feature.name,
+      status: feature.status,
+      folder: owningApp === void 0 ? null : `${owningApp.path}/${feature.folder}`
+    };
+  }
+  const productPackage = (manifest.packages ?? []).find(
+    (candidate) => candidate.name === specId
+  );
+  if (productPackage !== void 0) {
+    return {
+      kind: "package",
+      name: productPackage.name,
+      status: productPackage.status,
+      folder: productPackage.path
+    };
+  }
+  const frameworkPackages = (manifest.framework?.packages ?? []).filter(
+    (candidate) => candidate.spec !== null && specIdOf(candidate.spec) === specId
+  );
+  const leastAdvanced = frameworkPackages.slice().sort((a, b) => ADVANCEMENT.indexOf(a.status) - ADVANCEMENT.indexOf(b.status))[0];
+  if (leastAdvanced !== void 0) {
+    return {
+      kind: "framework-package",
+      name: leastAdvanced.name,
+      status: leastAdvanced.status,
+      folder: leastAdvanced.path
+    };
+  }
+  return void 0;
+}
+
+// src/tools.ts
+var SPECS_DIR = "specs";
+async function provenanceOf(repo, path) {
+  return { repo: repo.id, path, ref: await repo.adapter.currentRef() };
+}
+async function readDocument(repo, path) {
+  const slash = path.lastIndexOf("/");
+  const parent = slash === -1 ? "" : path.slice(0, slash);
+  const name = slash === -1 ? path : path.slice(slash + 1);
+  const entry = (await repo.adapter.listDirectory(parent)).find(
+    (candidate) => candidate.path === name
+  );
+  if (entry !== void 0 && entry.sizeBytes > MAX_FILE_BYTES) {
+    throwOgygieError({
+      code: "FILE_TOO_LARGE",
+      message: `"${path}" is ${entry.sizeBytes} bytes, over the ${MAX_FILE_BYTES} the server serves.`,
+      file: path,
+      cause: `sizeBytes=${entry.sizeBytes} > ${MAX_FILE_BYTES}`,
+      suggestedFix: "Ask for a more precise file \u2014 a feature's schemas.ts rather than its whole folder."
+    });
+  }
+  const content = await repo.adapter.readFile(path);
+  if (content.includes("\0") || content.includes("\uFFFD")) {
+    throwOgygieError({
+      code: "FILE_NOT_TEXT",
+      message: `"${path}" is not UTF-8 text.`,
+      file: path,
+      cause: "the decoded content carries NUL or replacement characters",
+      suggestedFix: "Only text files are served \u2014 read the source next to the binary instead."
+    });
+  }
+  return content;
+}
+async function listRepos(repos) {
+  return {
+    repos: await Promise.all(
+      repos.map(async (repo) => ({
+        id: repo.id,
+        ogygieVersion: repo.ogygieVersion,
+        ref: await repo.adapter.currentRef()
+      }))
+    )
+  };
+}
+async function readManifestTool(repo) {
+  const manifest = await readManifest(repo);
+  return { manifest, provenance: await provenanceOf(repo, "ogygie.manifest.json") };
+}
+function specIdOf2(fileName) {
+  return fileName.replace(/\.spec\.md$/, "");
+}
+async function specFileNames(repo) {
+  const entries = await repo.adapter.listDirectory(SPECS_DIR);
+  return entries.map((entry) => entry.path).filter((path) => !path.includes("/") && path.endsWith(".spec.md") && !path.startsWith("_")).sort();
+}
+var FRONTMATTER_BLOCK = /^---\n([\s\S]*?)\n---/;
+function parseSpecFile(content) {
+  const match = FRONTMATTER_BLOCK.exec(content);
+  if (match === null || match[1] === void 0) {
+    return {
+      frontmatter: null,
+      problems: ["file does not start with a --- ... --- frontmatter block"],
+      body: content
+    };
+  }
+  const body = content.slice(match[0].length);
+  const parsed = parseSpecFrontmatter(match[1]);
+  if (parsed.problems.length > 0) {
+    return { frontmatter: null, problems: parsed.problems, body };
+  }
+  const checked = SpecFrontmatterSchema.safeParse(parsed.value);
+  if (!checked.success) {
+    return {
+      frontmatter: null,
+      problems: checked.error.issues.map(
+        (issue) => `${issue.path.join(".")}: ${issue.message}`
+      ),
+      body
+    };
+  }
+  return { frontmatter: checked.data, problems: [], body };
+}
+async function listSpecs(repo, input) {
+  const specs = [];
+  const invalid = [];
+  for (const fileName of await specFileNames(repo)) {
+    const parsed = parseSpecFile(await readDocument(repo, `${SPECS_DIR}/${fileName}`));
+    if (parsed.frontmatter === null) {
+      invalid.push({ id: specIdOf2(fileName), problems: parsed.problems });
+      continue;
+    }
+    if (input.status !== void 0 && parsed.frontmatter.status !== input.status) continue;
+    specs.push({
+      id: parsed.frontmatter.id,
+      status: parsed.frontmatter.status,
+      priority: parsed.frontmatter.priority,
+      dependsOn: parsed.frontmatter.depends_on,
+      deferred: parsed.frontmatter.deferred
+    });
+  }
+  return { specs, invalid };
+}
+async function readSpec(repo, input) {
+  const path = `${SPECS_DIR}/${input.id}.spec.md`;
+  if (!await repo.adapter.exists(path)) {
+    const known = (await specFileNames(repo)).map(specIdOf2);
+    throwOgygieError({
+      code: "SPEC_NOT_FOUND",
+      message: `Repo "${repo.id}" has no spec "${input.id}".`,
+      file: path,
+      cause: `${path} does not exist`,
+      suggestedFix: `Existing specs: ${known.join(", ") || "<none>"}.`
+    });
+  }
+  const parsed = parseSpecFile(await readDocument(repo, path));
+  return {
+    frontmatter: parsed.frontmatter,
+    frontmatterProblems: parsed.problems,
+    body: parsed.body,
+    provenance: await provenanceOf(repo, path)
+  };
+}
+async function readDecisions(repo, input) {
+  const files = [];
+  for (const path of DECISION_FILES) {
+    if (await repo.adapter.exists(path)) {
+      files.push({ path, content: await readDocument(repo, path) });
+    }
+  }
+  if (input.decision === void 0) {
+    return {
+      documents: await Promise.all(
+        files.map(async (file) => ({
+          content: file.content,
+          provenance: await provenanceOf(repo, file.path)
+        }))
+      )
+    };
+  }
+  for (const file of files) {
+    const section = extractDecisionSection(file.content, input.decision);
+    if (section !== null) {
+      return { content: section, provenance: await provenanceOf(repo, file.path) };
+    }
+  }
+  const known = files.flatMap((file) => parseKnownDecisionIds(file.content));
+  return throwOgygieError({
+    code: "DECISION_NOT_FOUND",
+    message: `Decision ${input.decision} is declared in neither decisions file of repo "${repo.id}".`,
+    file: DECISION_FILES.join(" ; "),
+    cause: `declared decisions: ${known.join(", ") || "<none>"}`,
+    suggestedFix: "Cite a decision that exists, or call ogygie_read_decisions without `decision`."
+  });
+}
+async function readGovernance(repo, input) {
+  return {
+    content: await readDocument(repo, input.file),
+    provenance: await provenanceOf(repo, input.file)
+  };
+}
+async function readFeature(repo, input) {
+  const manifest = await readManifest(repo);
+  const owner = findSpecOwner(manifest, input.feature);
+  if (owner === void 0 || owner.folder === null) {
+    throwOgygieError({
+      code: "FEATURE_NOT_FOUND",
+      message: `The manifest of repo "${repo.id}" declares no feature "${input.feature}".`,
+      file: "ogygie.manifest.json",
+      cause: owner === void 0 ? "no feature and no package of that name in the map" : `${owner.kind} "${owner.name}" declares no folder`,
+      suggestedFix: "Call ogygie_read_manifest to see what the repo declares \u2014 a feature absent from the map does not exist."
+    });
+  }
+  const folder = owner.folder;
+  if (input.file !== void 0) {
+    const path = `${folder}/${input.file}`;
+    return {
+      content: await readDocument(repo, path),
+      provenance: await provenanceOf(repo, path)
+    };
+  }
+  return {
+    feature: input.feature,
+    files: await repo.adapter.listDirectory(folder),
+    provenance: await provenanceOf(repo, folder)
+  };
+}
+
+// src/server.ts
+function asText(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function asError(thrown) {
+  const payload = thrown instanceof OgygieFailure ? thrown.error : {
+    ogygie: true,
+    code: "UNEXPECTED",
+    message: thrown instanceof Error ? thrown.message : String(thrown),
+    suggestedFix: "Report this to the Ogygie framework: a tool failed outside its contract."
+  };
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }], isError: true };
+}
+function createOgygieMcpServer(deps) {
+  const server = new McpServer(
+    { name: "ogygie", version: deps.version },
+    { capabilities: { tools: {} } }
+  );
+  const register = (name, description, inputSchema, run) => {
+    server.registerTool(
+      name,
+      // The SDK derives the JSON Schema clients see from this raw shape, so
+      // the contract is written once, in schemas.ts.
+      { description, inputSchema },
+      (async (input) => {
+        const startedAt = Date.now();
+        try {
+          const result = await run(input);
+          deps.log?.(
+            JSON.stringify({
+              tool: name,
+              repo: input["repo"] ?? null,
+              outcome: "ok",
+              durationMs: Date.now() - startedAt
+            })
+          );
+          return asText(result);
+        } catch (thrown) {
+          deps.log?.(
+            JSON.stringify({
+              tool: name,
+              repo: input["repo"] ?? null,
+              outcome: thrown instanceof OgygieFailure ? thrown.error.code : "UNEXPECTED",
+              durationMs: Date.now() - startedAt
+            })
+          );
+          return asError(thrown);
+        }
+      })
+    );
+  };
+  register(
+    "ogygie_list_repos",
+    "Lists the Ogygie repos this server serves, with the Ogygie version each pins and the git ref currently read.",
+    {},
+    async () => listRepos(deps.repos)
+  );
+  register(
+    "ogygie_read_manifest",
+    "Reads the manifest of a repo: features, routes, packages, tenancy. The manifest is the index of an Ogygie repo \u2014 start here.",
+    ReadManifestInput,
+    async (input) => readManifestTool(repoOf(deps.repos, input.repo))
+  );
+  register(
+    "ogygie_list_specs",
+    "Lists the specs of a repo (id, status, priority, dependencies, deferred behaviors), optionally filtered by status. Specs whose frontmatter is broken are listed apart, never dropped.",
+    ListSpecsInput,
+    async (input) => listSpecs(repoOf(deps.repos, input.repo), input)
+  );
+  register(
+    "ogygie_read_spec",
+    "Reads one spec whole: parsed frontmatter and markdown body. A spec is the contract of a feature \u2014 its behaviors are what the code must prove.",
+    ReadSpecInput,
+    async (input) => readSpec(repoOf(deps.repos, input.repo), input)
+  );
+  register(
+    "ogygie_read_decisions",
+    "Reads the structuring decisions of a repo. With `decision` (D<n>), returns that one section; without, both decision files whole. A decision is never reopened, only cited.",
+    ReadDecisionsInput,
+    async (input) => readDecisions(repoOf(deps.repos, input.repo), input)
+  );
+  register(
+    "ogygie_read_governance",
+    "Reads a governance document of a repo: AGENTS.md (the rules of that repo's version), AGENTS.product.md (its product bindings) or FAILURES.md (its journal of failures).",
+    ReadGovernanceInput,
+    async (input) => readGovernance(repoOf(deps.repos, input.repo), input)
+  );
+  register(
+    "ogygie_read_feature",
+    "Lists the files of a feature declared in the manifest, or reads one of them with `file`. The folder comes from the map: a feature the manifest does not declare does not exist.",
+    ReadFeatureInput,
+    async (input) => readFeature(repoOf(deps.repos, input.repo), input)
+  );
+  return server;
+}
+
+// src/transports.ts
+import { createServer } from "node:http";
+import { timingSafeEqual } from "node:crypto";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+async function startStdioTransport(server) {
+  await server.connect(new StdioServerTransport());
+}
+function tokenMatches(expected, provided) {
+  const expectedBytes = Buffer.from(expected, "utf8");
+  const providedBytes = Buffer.from(provided, "utf8");
+  if (expectedBytes.length !== providedBytes.length) return false;
+  return timingSafeEqual(expectedBytes, providedBytes);
+}
+function assertUsableToken(token) {
+  if (token === void 0 || token.trim() === "") {
+    return throwOgygieError({
+      code: "TOKEN_MISSING",
+      message: "The HTTP transport requires OGYGIE_MCP_TOKEN.",
+      file: null,
+      cause: "OGYGIE_MCP_TOKEN is unset or empty",
+      suggestedFix: "Set OGYGIE_MCP_TOKEN to a random secret of at least 32 characters, or run the stdio transport, which needs none."
+    });
+  }
+  if (token.length < MIN_TOKEN_LENGTH) {
+    return throwOgygieError({
+      code: "TOKEN_MISSING",
+      message: "The OGYGIE_MCP_TOKEN is too short to be a secret.",
+      file: null,
+      cause: `length=${token.length} < ${MIN_TOKEN_LENGTH}`,
+      suggestedFix: `Use at least ${MIN_TOKEN_LENGTH} random characters \u2014 e.g. \`openssl rand -hex 32\`.`
+    });
+  }
+  return token;
+}
+function refuse(response, status, error) {
+  response.writeHead(status, { "content-type": "application/json" });
+  response.end(JSON.stringify(error));
+}
+function isAuthorized(authorization, expected) {
+  if (authorization === void 0) return false;
+  const [scheme, value] = authorization.split(" ");
+  if (scheme?.toLowerCase() !== "bearer" || value === void 0) return false;
+  return tokenMatches(expected, value);
+}
+async function startHttpTransport(createServerInstance, options) {
+  const token = assertUsableToken(options.token);
+  const handleWithFreshTransport = async (request, response, body) => {
+    const server = createServerInstance();
+    const transport = new StreamableHTTPServerTransport({});
+    response.on("close", () => {
+      void transport.close();
+      void server.close();
+    });
+    await server.connect(transport);
+    await transport.handleRequest(request, response, body);
+  };
+  const httpServer = createServer((request, response) => {
+    if (!isAuthorized(request.headers.authorization, token)) {
+      refuse(
+        response,
+        401,
+        ogygieError({
+          code: "UNAUTHORIZED",
+          message: "This Ogygie MCP server requires a bearer token.",
+          file: null,
+          cause: "missing or wrong Authorization header",
+          suggestedFix: "Send `Authorization: Bearer <OGYGIE_MCP_TOKEN>`."
+        })
+      );
+      return;
+    }
+    const chunks = [];
+    request.on("data", (chunk) => chunks.push(chunk));
+    request.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      let body;
+      try {
+        body = raw === "" ? void 0 : JSON.parse(raw);
+      } catch {
+        refuse(response, 400, { error: "invalid JSON body" });
+        return;
+      }
+      void handleWithFreshTransport(request, response, body);
+    });
+  });
+  const host = options.host ?? "127.0.0.1";
+  await new Promise((resolve3) => httpServer.listen(options.port, host, resolve3));
+  const address = httpServer.address();
+  return {
+    port: typeof address === "object" && address !== null ? address.port : options.port,
+    close: () => new Promise(
+      (resolve3, reject) => httpServer.close((error) => error === void 0 ? resolve3() : reject(error))
+    )
+  };
+}
+
+// src/main.ts
+function parseArguments(argv) {
+  const options = { configPath: null, http: false, port: 3010, host: void 0 };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--config") options.configPath = argv[++index] ?? null;
+    else if (argument === "--http") options.http = true;
+    else if (argument === "--port") options.port = Number.parseInt(argv[++index] ?? "", 10);
+    else if (argument === "--host") options.host = argv[++index];
+  }
+  return options;
+}
+function loadRegistry(options, cwd, readConfigFile) {
+  if (options.configPath === null) {
+    return { repos: [{ id: "local", rootPath: cwd }] };
+  }
+  const absolute = resolve2(cwd, options.configPath);
+  let raw;
+  try {
+    raw = readConfigFile(absolute);
+  } catch (thrown) {
+    throw new OgygieFailure(
+      ogygieError({
+        code: "REGISTRY_INVALID",
+        message: "The registry file cannot be read.",
+        file: absolute,
+        cause: thrown instanceof Error ? thrown.message : String(thrown),
+        suggestedFix: "Check the --config path, or omit it to serve the current project."
+      })
+    );
+  }
+  try {
+    return parseRegistry(JSON.parse(raw));
+  } catch (thrown) {
+    if (thrown instanceof OgygieFailure) throw thrown;
+    throw new OgygieFailure(
+      ogygieError({
+        code: "REGISTRY_INVALID",
+        message: "The registry file is not valid JSON.",
+        file: absolute,
+        cause: thrown instanceof Error ? thrown.message : String(thrown),
+        suggestedFix: 'Write { "repos": [{ "id": "\u2026", "rootPath": "\u2026" }] }.'
+      })
+    );
+  }
+}
+async function startOgygieMcp(options) {
+  const parsed = parseArguments(options.argv);
+  const registry = loadRegistry(parsed, options.cwd, options.readConfigFile);
+  const repos = await openRepos(registry, {
+    openRepo: (rootPath) => createFilesystemRepoAdapter(resolve2(options.cwd, rootPath)),
+    serverVersion: options.version
+  });
+  const buildServer = () => createOgygieMcpServer({
+    repos,
+    version: options.version,
+    log: (line) => process.stderr.write(`${line}
+`)
+  });
+  if (!parsed.http) {
+    const server = buildServer();
+    await startStdioTransport(server);
+    return { close: async () => server.close() };
+  }
+  const running = await startHttpTransport(buildServer, {
+    port: parsed.port,
+    ...parsed.host === void 0 ? {} : { host: parsed.host },
+    token: options.token
+  });
+  process.stderr.write(
+    `ogygie-mcp \u2014 HTTP sur ${parsed.host ?? "127.0.0.1"}:${running.port}, ${repos.length} repo(s).
+`
+  );
+  return { close: () => running.close() };
+}
+export {
+  loadRegistry,
+  parseArguments,
+  startOgygieMcp
+};