cherry-works 0.1.0 → 0.2.1

package/dist/main.js

@@ -6,7 +6,7 @@ import { pathToFileURL as pathToFileURL2 } from "url";
 // package.json
 var package_default = {
   name: "cherry-works",
-  version: "0.1.0",
+  version: "0.2.1",
   description: "The charter engine: resolves a charter and compiles it into what a coding agent reads.",
   keywords: [
     "claude-code",
@@ -93,6 +93,7 @@ var package_default = {
   dependencies: {
     "@hono/node-server": "^2.1.1",
     "@hono/zod-openapi": "^1.6.3",
+    "@modelcontextprotocol/sdk": "^1.31.0",
     hono: "^4.13.7",
     picomatch: "^4.0.7",
     prompts: "^2.4.2",
@@ -105,8 +106,8 @@ var package_default = {
 // src/driver/cli/Commander.ts
 import yargs from "yargs";
 
-// src/hexagon/domain/models/Fault.ts
-var Fault = class extends Error {
+// src/hexagon/domain/models/DomainFault.ts
+var DomainFault = class extends Error {
   constructor(message, fix, severity = "error") {
     super(message);
     this.fix = fix;
@@ -116,17 +117,17 @@ var Fault = class extends Error {
   fix;
   severity;
 };
-var CharterRootFault = class extends Fault {
+var CharterRootFault = class extends DomainFault {
 };
-var SettingsFault = class extends Fault {
+var SettingsFault = class extends DomainFault {
 };
-var CharterPrimitiveFault = class extends Fault {
+var CharterPrimitiveFault = class extends DomainFault {
 };
-var TestSuiteFault = class extends Fault {
+var TestSuiteFault = class extends DomainFault {
 };
-var TestCaseFault = class extends Fault {
+var TestCaseFault = class extends DomainFault {
 };
-var VendorFault = class extends Fault {
+var VendorFault = class extends DomainFault {
 };
 function throwAggregateError(faults2) {
   throw new AggregateError(faults2, faults2.map((one) => one.message).join(" "));
@@ -197,14 +198,32 @@ function matches(glob, path) {
 }
 
 // src/hexagon/domain/models/charter/primitive/Primitive.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/hexagon/domain/models/charter/primitive/BasePrimitive.ts
 import { z } from "zod";
 
 // src/hexagon/domain/models/helper.ts
 function formatFrontmatterValue(value) {
-  return Array.isArray(value) ? `[${value.map((one) => JSON.stringify(one)).join(", ")}]` : String(value);
+  if (Array.isArray(value)) return `[${value.map((one) => JSON.stringify(one)).join(", ")}]`;
+  const line = String(value);
+  return YAML_READS_OTHERWISE.test(line) ? JSON.stringify(line) : line;
+}
+var YAML_READS_OTHERWISE = /^[-?:,[\]{}#&*!|>'"%@`]|: | #|:$|^\s|\s$|^$|^(true|false|yes|no|on|off|null|~)$|^[-+]?(\d[\d_]*)?\.?\d+([eE][-+]?\d+)?$/i;
+function shortenStringsOf(strings2) {
+  const shortStrings = {};
+  const takenShortStrings = /* @__PURE__ */ new Set();
+  for (const string of [...new Set(strings2)].sort()) {
+    const firstSegment = string.slice(string.indexOf(":") + 1).split("/")[0];
+    let hash = 2166136261;
+    for (const char of string) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+    const hashedString = `${firstSegment}_${(hash >>> 0).toString(16).padStart(8, "0").slice(0, 4)}`;
+    let shortString = hashedString;
+    for (let count = 2; takenShortStrings.has(shortString); count++) shortString = `${hashedString}_${count}`;
+    takenShortStrings.add(shortString);
+    shortStrings[string] = shortString;
+  }
+  return shortStrings;
 }
 
 // src/hexagon/domain/models/charter/primitive/BasePrimitive.ts
@@ -212,7 +231,12 @@ var DELIMITER = "---";
 var goodLine = z.string().regex(/\S/);
 var goodArray = z.array(goodLine).min(1).readonly();
 var CommonHeaders = z.object({
-  id: z.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/),
+  /** Slugs joined by `/`, so identities can be grouped by team or domain
+   *  (FR-141). The `/` puts the file in folders and nothing else: nothing is
+   *  read from where a file sits. At most 40 characters, so every name a host
+   *  is given for it — an mcp's tools among them, `mcp__cw__mcp-<id>__<tool>` —
+   *  stays within what the host takes (FR-157). */
+  id: z.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\/[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/).refine((id) => id.length <= 40, { message: `"id" is at most 40 characters.` }),
   /** All an agent reads of a primitive before opening its body. */
   description: goodLine,
   tags: z.array(goodLine).readonly().optional(),
@@ -256,14 +280,24 @@ var BasePrimitive = class {
    * The kind leads, since it is what decides how the rest is read (FR-003). A
    * list is written the way the parser gives it back, so an author opening the
    * file finds what they declared rather than a second spelling of it.
+   *
+   * Written as its author wrote it unless the compiler says otherwise (FR-139):
+   * `mixins` lend their bodies, before this one's own so it reads as the point
+   * and theirs as the setting — nothing is merged and no header moves (FR-006);
+   * and `idReplacer` rewrites the body as a host reads it, a place named as
+   * `mcp:<id>` as the host calls its tools (FR-147).
    */
-  toMarkdown() {
+  toMarkdown({
+    mixins = [],
+    idReplacer = (body) => body
+  } = {}) {
+    const body = [...mixins.map((mixin) => mixin.body), this.body].filter((one) => one.trim() !== "").join("\n\n");
     return [
       DELIMITER,
       ...Object.entries({ kind: this.kind, ...this.headers }).map(([field, value]) => `${field}: ${formatFrontmatterValue(value)}`),
       DELIMITER,
       "",
-      this.body
+      idReplacer(body)
     ].join("\n").replace(/\n*$/, "\n");
   }
   /**
@@ -284,10 +318,11 @@ function headersOf(sampledKind, headerSchema, record) {
   const parsed = headerSchema.safeParse(record);
   if (parsed.success) return parsed.data;
   const { kind, sample } = sampledKind;
+  const refinementMessages = parsed.error.issues.filter((issue) => issue.code === "custom").map((issue) => issue.message);
   const sampleLines = Object.entries({ kind, ...sample }).map(([field, value]) => `${field}: ${formatFrontmatterValue(value)}`);
   return throwAggregateError([
     new CharterPrimitiveFault(
-      `These headers are not what a ${kind} holds.`,
+      refinementMessages.length > 0 ? refinementMessages.join(" ") : `These headers are not what a ${kind} holds.`,
       `Write them the way this ${kind} does:
 ${sampleLines.join("\n")}`
     )
@@ -312,12 +347,13 @@ var AgentPrimitive = class _AgentPrimitive extends BasePrimitive {
   /** When a reader of this charter is to open this kind at all, said
    *  where the kind's contract is: the neutral surface lists one
    *  line per kind and none of them is written down twice (FR-002). */
-  static activatesWhen = "it is spawned by identity, holding the `tools` it lists and nothing else";
-  /** An agent as an author writes one: what a refused header is fixed with. */
+  static activatesWhen = "it is spawned by identity, holding the `tools` it lists and nothing else \u2014 a place as `mcp:<id>`, or one of its tools as `mcp:<id>:<tool>`";
+  /** An agent as an author writes one: what a refused header is fixed with.
+   *  It holds one tool of a place the way an author writes it (FR-156). */
   static sample = {
     id: "reviewer",
     description: "Review a diff and name what is wrong with it.",
-    tools: ["Read", "Grep"]
+    tools: ["Read", "Grep", "mcp:mfbs/billing:search_code"]
   };
   /** One agent, or every fault its headers have (FR-004). */
   static of(record, body) {
@@ -325,34 +361,6 @@ var AgentPrimitive = class _AgentPrimitive extends BasePrimitive {
   }
 };
 
-// src/hexagon/domain/models/charter/primitive/CommandPrimitive.ts
-var CommandPrimitive = class _CommandPrimitive extends BasePrimitive {
-  static kind = "command";
-  kind = _CommandPrimitive.kind;
-  /** What this kind requires beyond the common headers: nothing. Declared all
-   *  the same, since what a file is scaffolded with is read off this (FR-039). */
-  static requires = {};
-  /** The schema its headers are read by: what `headersOf` refuses a file
-   *  against, and what says the shape of every header this kind takes, required
-   *  or not (FR-004). */
-  static schema = CommonHeaders;
-  /** When a reader of this charter is to open this kind at all, said
-   *  where the kind's contract is: the neutral surface lists one
-   *  line per kind and none of them is written down twice (FR-002). */
-  static activatesWhen = "it is asked for by name, or a request matches what it describes itself as being for";
-  /** A command as an author writes one: what a refused header is fixed with. */
-  static sample = {
-    id: "release",
-    description: "Cut a release from the main branch."
-  };
-  /** One command, or every fault its headers have. Nothing beyond what every
-   *  primitive declares: a command is asked for by name, and the one line it
-   *  describes itself with is what decides that it is the one being asked for. */
-  static of(record, body) {
-    return new _CommandPrimitive(headersOf(_CommandPrimitive, CommonHeaders, record), body);
-  }
-};
-
 // src/hexagon/domain/models/charter/primitive/CorpusPrimitive.ts
 var CorpusHeaders = CommonHeaders.extend({});
 var CorpusPrimitive = class _CorpusPrimitive extends BasePrimitive {
@@ -410,11 +418,109 @@ var GuidePrimitive = class _GuidePrimitive extends BasePrimitive {
   }
 };
 
-// src/hexagon/domain/models/charter/primitive/MixinPrimitive.ts
+// src/hexagon/domain/models/charter/primitive/McpPrimitive.ts
 import { z as z2 } from "zod";
+var MCP_AUTHS = ["oauth", "token"];
+function isSecureEndpoint(endpoint) {
+  if (!URL.canParse(endpoint)) return false;
+  const endpointURL = new URL(endpoint);
+  return endpointURL.protocol === "https:" || endpointURL.protocol === "http:" && ["127.0.0.1", "localhost"].includes(endpointURL.hostname);
+}
+var MCP_MENTION = /\bmcp:([a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\/[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*)/g;
+var MCP_TOOL_REFERENCE = /^(mcp:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\/[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*)(?::([^:\s]+))?$/;
+var McpHeaders = CommonHeaders.extend({
+  /** Reached over HTTP. Plain `http` only to this machine, for a server under
+   *  test: anything else would send a developer's credential in the clear. */
+  endpoint: goodLine.refine(isSecureEndpoint, {
+    message: `"endpoint" is an https:// URL, or http:// to 127.0.0.1 or localhost for a server under test.`
+  }).optional(),
+  /** Started as a local process, spoken to over its standard input and output. */
+  command: goodLine.optional(),
+  args: z2.array(goodLine).readonly().optional(),
+  auth: z2.array(z2.enum(MCP_AUTHS)).min(1).readonly().optional(),
+  /** The environment variable a command reads its token from. */
+  tokenEnv: z2.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).optional(),
+  /** The place inside that server: a repository, a database, a channel. */
+  path: goodLine.optional(),
+  /** The server's tools the agent may use there, by the server's own names. */
+  tools: goodArray
+}).superRefine((headers, context) => {
+  const addFault = (message) => context.addIssue({ code: "custom", message });
+  const { endpoint, command, args, auth: auth2, tokenEnv } = headers;
+  if (endpoint !== void 0 && command !== void 0)
+    return addFault(`This declares both "endpoint" and "command"; an mcp is one server, reached one way.`);
+  if (endpoint === void 0 && command === void 0)
+    return addFault(`This declares neither "endpoint" nor "command", so there is no server to reach.`);
+  if (endpoint !== void 0) {
+    if (auth2 === void 0) addFault(`An endpoint says how a developer signs in to it: "auth" of oauth, token or both.`);
+    if (args !== void 0) addFault(`"args" are a command's; an endpoint takes none.`);
+    if (tokenEnv !== void 0) addFault(`"tokenEnv" is where a command reads its token; an endpoint takes none.`);
+    return;
+  }
+  const takesToken = auth2 !== void 0;
+  if (takesToken && (auth2.length !== 1 || auth2[0] !== "token"))
+    addFault(`A command signs in by token alone: "auth: [token]", or no "auth" for one that takes none.`);
+  if (takesToken && tokenEnv === void 0) addFault(`A command taking a token names where it reads it: "tokenEnv".`);
+  if (!takesToken && tokenEnv !== void 0) addFault(`"tokenEnv" is read only by a command taking a token: add "auth: [token]", or drop it.`);
+});
+var McpPrimitive = class _McpPrimitive extends BasePrimitive {
+  static kind = "mcp";
+  kind = _McpPrimitive.kind;
+  /** What this kind requires beyond the common headers. `endpoint` or
+   *  `command` is required too, but which depends on the shape, so the schema's
+   *  refinement says it rather than this (FR-004, FR-039). */
+  static requires = { tools: "list" };
+  /** The schema its headers are read by: what `headersOf` refuses a file
+   *  against, and what says the shape of every header this kind takes, required
+   *  or not (FR-004). */
+  static schema = McpHeaders;
+  /** When a reader of this charter is to open this kind at all, said
+   *  where the kind's contract is: the neutral surface lists one
+   *  line per kind and none of them is written down twice (FR-002). */
+  static activatesWhen = "a primitive's body names it as `mcp:<id>` \u2014 a place outside the repository, reached through `cw mcp serve`";
+  /** An mcp reached at an endpoint, as an author writes one: what a refused
+   *  header is fixed with. */
+  static sample = {
+    id: "mfbs/billing",
+    description: "Billing service code and pull requests.",
+    endpoint: "https://api.githubcopilot.com/mcp/",
+    path: "moneyforward/billing-service",
+    auth: ["oauth", "token"],
+    tools: ["get_file_contents", "search_code", "list_pull_requests"]
+  };
+  /** The same place started as a local process: what a refused file declaring
+   *  `command` is held up against, since that is the shape it was nearer. */
+  static commandSample = {
+    id: "mfbs/billing",
+    description: "Billing service code and pull requests.",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-github"],
+    tokenEnv: "GITHUB_PERSONAL_ACCESS_TOKEN",
+    auth: ["token"],
+    path: "moneyforward/billing-service",
+    tools: ["get_file_contents", "search_code", "list_pull_requests"]
+  };
+  /** What a developer signs in to, and what places are told apart by beside
+   *  their `path`: the endpoint, or the command followed by each of its
+   *  arguments. The refinement has already held that one of the two is here
+   *  (FR-142). */
+  get address() {
+    const { endpoint, command, args = [] } = this.headers;
+    return endpoint ?? [command, ...args].join(" ");
+  }
+  /** One mcp, or every fault its headers have, shown the sample of the shape
+   *  it declared (FR-004, FR-142). */
+  static of(record, body) {
+    const nearerSample = record.command === void 0 ? _McpPrimitive.sample : _McpPrimitive.commandSample;
+    return new _McpPrimitive(headersOf({ kind: _McpPrimitive.kind, sample: nearerSample }, McpHeaders, record), body);
+  }
+};
+
+// src/hexagon/domain/models/charter/primitive/MixinPrimitive.ts
+import { z as z3 } from "zod";
 var MixinHeaders = CommonHeaders.extend({
   /** Never: reading refuses a mixin that declares one. */
-  mixins: z2.undefined().optional()
+  mixins: z3.undefined().optional()
 });
 var MixinPrimitive = class _MixinPrimitive extends BasePrimitive {
   static kind = "mixin";
@@ -460,7 +566,7 @@ var PlaybookPrimitive = class _PlaybookPrimitive extends BasePrimitive {
   /** When a reader of this charter is to open this kind at all, said
    *  where the kind's contract is: the neutral surface lists one
    *  line per kind and none of them is written down twice (FR-002). */
-  static activatesWhen = "one of its `triggers` matches; the body is a sequence of commands";
+  static activatesWhen = "one of its `triggers` matches; the body is a sequence of skills";
   /** A playbook as an author writes one: what a refused header is fixed with. */
   static sample = {
     id: "ship-a-feature",
@@ -512,7 +618,7 @@ var PosturePrimitive = class _PosturePrimitive extends BasePrimitive {
 };
 
 // src/hexagon/domain/models/charter/primitive/SensorPrimitive.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var SIGNALS = [
   "PreToolUse",
   "PostToolUse",
@@ -526,7 +632,7 @@ var SIGNALS = [
 ];
 var SensorHeaders = CommonHeaders.extend({
   /** What raises it: one of the events every host of this engine speaks in. */
-  signal: z3.enum(SIGNALS),
+  signal: z4.enum(SIGNALS),
   /** What is run when it does. A sensor that names no command is a sensor
    *  nothing can fire, so this is required. */
   run: goodLine
@@ -599,16 +705,16 @@ var SkillPrimitive = class _SkillPrimitive extends BasePrimitive {
 var PRIMITIVE_CLASSES = [
   GuidePrimitive,
   SensorPrimitive,
-  CommandPrimitive,
   SkillPrimitive,
   PlaybookPrimitive,
   AgentPrimitive,
   PosturePrimitive,
   CorpusPrimitive,
-  MixinPrimitive
+  MixinPrimitive,
+  McpPrimitive
 ];
 var KINDS = Object.freeze(PRIMITIVE_CLASSES.map((one) => one.kind));
-var PRIMITIVE_IDENTITY_SCHEMA = z4.string().regex(/^[a-z0-9-]+:[a-z0-9-]+$/).transform((identity) => identity);
+var PRIMITIVE_IDENTITY_SCHEMA = z5.string().regex(/^[a-z0-9-]+:[a-z0-9-]+(\/[a-z0-9-]+)*$/).transform((identity) => identity);
 function identityOf(kindAndId) {
   if (typeof kindAndId !== "string") return `${kindAndId.kind}:${kindAndId.id}`;
   const parsed = PRIMITIVE_IDENTITY_SCHEMA.safeParse(kindAndId);
@@ -650,13 +756,13 @@ function primitiveHeadersOf(kind) {
   const required = { ...BasePrimitive.requires, ...kindClass.requires };
   return Object.entries(kindClass.schema.shape).filter(([field]) => field !== "id").map(([field, type]) => {
     let heldType = type;
-    while (!(heldType instanceof z4.ZodArray) && typeof heldType?.unwrap === "function")
+    while (!(heldType instanceof z5.ZodArray) && typeof heldType?.unwrap === "function")
       heldType = heldType.unwrap();
     return new PrimitiveHeader(
       field,
-      heldType instanceof z4.ZodArray ? "list" : "line",
+      heldType instanceof z5.ZodArray ? "list" : "line",
       field in required,
-      heldType instanceof z4.ZodEnum ? heldType.options : void 0
+      heldType instanceof z5.ZodEnum ? heldType.options : void 0
     );
   });
 }
@@ -731,11 +837,16 @@ var ScopedPrimitive = class {
     this.scope = scope;
     this.file = file;
     this.primitive = primitive;
+    this.normIdentity = identity.replace(/[:/]/g, "-");
   }
   identity;
   scope;
   file;
   primitive;
+  /** The identity as every name given to a host writes it, `:` and `/` as `-`:
+   *  `guide-mfbs-no-any` for `guide:mfbs/no-any` (FR-141). Made here, once, so
+   *  nothing that names a host's file or a place's tools spells it again. */
+  normIdentity;
   /** Whether a word someone searched for is anywhere a reader would look for
    *  it: the identity, the kind, what it is for, when its kind comes up, its
    *  file, or any header it declared — ignoring case, since whoever typed it
@@ -772,26 +883,6 @@ var CharterRoot = class {
       this.primitives.filter(({ primitive }) => primitive.kind === "mixin").map((one) => [one.primitive.headers.id, one.primitive])
     );
   }
-  /**
-   * What one primitive says once its mixins are in it: the body of every mixin
-   * it pulls in, in the order it named them, and then its own (FR-006).
-   *
-   * The one place a mixin is applied at all. Nothing is merged and no header
-   * moves — a mixin lends text, so what comes back is text, and the host's own
-   * words come last so they read as the point and the lent ones as the setting.
-   *
-   * Asked of the charter because the charter is what already read the mixins
-   * and knows which identity a name means across layers. A mixin nothing
-   * answers to is left out rather than raised: `allFaultsByFiles` already names
-   * that file, and a build refused for it never reaches here (FR-009).
-   */
-  bodyOf(one) {
-    const mixins = this.mixins;
-    return [
-      ...(one.primitive.headers.mixins ?? []).map((named) => mixins.get(named)?.body),
-      one.primitive.body
-    ].filter((body) => body !== void 0 && body.trim() !== "").join("\n\n");
-  }
   /**
    * Every primitive under the identity the whole charter names it by (FR-017).
    *
@@ -864,20 +955,36 @@ var CharterRoot = class {
    * rationale no corpus answers to, which is a warning rather than an error:
    * the rule holds without its reasoning, and the author is told the reasoning
    * is gone (FR-005). A corpus nobody cites and a mixin nobody pulls in are
-   * warnings too: nothing breaks, and nothing reads them either (FR-014).
+   * warnings too: nothing breaks, and nothing reads them either (FR-014). So
+   * are a body naming an mcp nothing holds (FR-143) and an mcp no body names
+   * (FR-144). An agent holding an mcp nothing holds, or a tool it does not
+   * declare, is an error: the role would be promised a tool it cannot have
+   * (FR-156).
    */
   get compositeFaultsByFiles() {
     const everyPrimitive = this.primitives;
     const mixinsByIdentity = this.mixins;
     const corpusIdentities = this.corpora;
+    const toolsByMcpIdentity = new Map(
+      everyPrimitive.flatMap(({ identity, primitive }) => primitive instanceof McpPrimitive ? [[identity, primitive.headers.tools]] : [])
+    );
+    const mcpIdentities = new Set(toolsByMcpIdentity.keys());
+    const mcpsNamedBy = (one) => [...one.primitive.body.matchAll(MCP_MENTION)].map(([, id]) => `mcp:${id}`);
+    const namedMcps = new Set(
+      everyPrimitive.flatMap((one) => [
+        ...mcpsNamedBy(one),
+        ...one.primitive instanceof AgentPrimitive ? one.primitive.headers.tools.flatMap((tool) => tool.match(MCP_TOOL_REFERENCE)?.[1] ?? []) : []
+      ])
+    );
     const fileByIdentity = /* @__PURE__ */ new Map();
+    const identityByNormalizedIdentity = /* @__PURE__ */ new Map();
     const faultsByFiles = {};
     const addFault = (file, found) => {
       faultsByFiles[file] = [...faultsByFiles[file] ?? [], found];
     };
     for (const one of everyPrimitive) {
       const { file, primitive } = one;
-      const { identity } = one;
+      const { identity, normIdentity } = one;
       const declaredIn = fileByIdentity.get(identity);
       if (declaredIn === void 0) fileByIdentity.set(identity, file);
       else
@@ -888,6 +995,16 @@ var CharterRoot = class {
             `Give this one an id of its own, or delete it if the other says the same thing. A vendor claiming an id you authored is one to raise with whoever publishes it. An id ${BUILTIN_PATH_PREFIX} claims is the engine's own and nobody can change it, so the one to rename is yours.`
           )
         );
+      const normalizedIdentityClaimedBy = identityByNormalizedIdentity.get(normIdentity);
+      if (normalizedIdentityClaimedBy === void 0) identityByNormalizedIdentity.set(normIdentity, identity);
+      else if (normalizedIdentityClaimedBy !== identity)
+        addFault(
+          file,
+          new CharterRootFault(
+            `"${identity}" and "${normalizedIdentityClaimedBy}" are both named "${normIdentity}" in an agent's files, where "/" is written as "-". Only one of them would be written there.`,
+            `Give this one an id that stays its own once "/" is written as "-".`
+          )
+        );
       for (const namedMixin of primitive.headers.mixins ?? []) {
         const mixin = mixinsByIdentity.get(namedMixin);
         if (mixin === void 0) {
@@ -921,6 +1038,45 @@ var CharterRoot = class {
           )
         );
       }
+      for (const namedMcp of new Set(mcpsNamedBy(one)))
+        if (!mcpIdentities.has(namedMcp))
+          addFault(
+            file,
+            new CharterRootFault(
+              `This names "${namedMcp}", and this charter holds no mcp of that identity. The agent would be told of a place it cannot reach.`,
+              `Author that mcp, or correct the name. An mcp is named as "mcp:<id>", whichever layer authored it.`,
+              "warn"
+            )
+          );
+      if (primitive instanceof AgentPrimitive)
+        for (const tool of primitive.headers.tools.filter((one2) => one2.startsWith("mcp:"))) {
+          const [, mcpIdentity, mcpTool] = tool.match(MCP_TOOL_REFERENCE) ?? [];
+          const declaredTools = mcpIdentity === void 0 ? void 0 : toolsByMcpIdentity.get(mcpIdentity);
+          if (mcpIdentity === void 0)
+            addFault(
+              file,
+              new CharterRootFault(
+                `"${tool}" under "tools" is not a place this role can hold.`,
+                `Write a place as "mcp:<id>" for every tool it declares, or "mcp:<id>:<tool>" for one.`
+              )
+            );
+          else if (declaredTools === void 0)
+            addFault(
+              file,
+              new CharterRootFault(
+                `"${tool}" under "tools" names "${mcpIdentity}", and this charter holds no mcp of that identity.`,
+                `Author that mcp, or correct the name. An mcp is named as "mcp:<id>", whichever layer authored it.`
+              )
+            );
+          else if (mcpTool !== void 0 && !declaredTools.includes(mcpTool))
+            addFault(
+              file,
+              new CharterRootFault(
+                `"${tool}" under "tools" names a tool "${mcpIdentity}" does not declare; it declares ${declaredTools.join(", ")}.`,
+                `Name one of those, or add "${mcpTool}" to the tools of "${mcpIdentity}".`
+              )
+            );
+        }
       if (primitive.kind === "corpus" && this.citersOf(one).length === 0)
         addFault(
           file,
@@ -939,6 +1095,32 @@ var CharterRoot = class {
             "warn"
           )
         );
+      if (primitive.kind === "mcp" && !namedMcps.has(identity))
+        addFault(
+          file,
+          new CharterRootFault(
+            `No primitive names "${identity}" in its body, so nothing an agent reads leads to it.`,
+            `Name it where it is used, as "${identity}", or delete it.`,
+            "warn"
+          )
+        );
+    }
+    const mcpPrimitives = everyPrimitive.flatMap(
+      ({ identity, file, primitive }) => primitive.kind === McpPrimitive.kind ? [{ identity, file, primitive }] : []
+    ).sort((one, another) => one.identity < another.identity ? -1 : 1);
+    for (const { file, primitive } of mcpPrimitives) {
+      const { tokenEnv } = primitive.headers;
+      const conflictingMcp = mcpPrimitives.find(
+        (other) => other.primitive.address === primitive.address && other.primitive.headers.tokenEnv !== void 0 && other.primitive.headers.tokenEnv !== tokenEnv
+      );
+      if (tokenEnv !== void 0 && conflictingMcp !== void 0)
+        addFault(
+          file,
+          new CharterRootFault(
+            `This hands "${primitive.address}" its token in "${tokenEnv}", and "${conflictingMcp.identity}" in "${conflictingMcp.primitive.headers.tokenEnv}". One process reads its token from one variable.`,
+            `Name the variable that command reads in both, or drop "tokenEnv" and "auth" from one of them.`
+          )
+        );
     }
     return new FaultsByFile(faultsByFiles);
   }
@@ -970,7 +1152,7 @@ function charterRootOf({
 function folderURL(at) {
   const url = new URL(at);
   if (!url.pathname.endsWith("/"))
-    throw new Fault(
+    throw new DomainFault(
       `"${url.href}" names a file, and a folder is what is wanted here.`,
       `Write it with the separator a folder ends in, as in "${url.href}/".`
     );
@@ -990,6 +1172,7 @@ function outFolderIn(repo) {
 }
 var CLAUDE_DIRECTORY = ".claude";
 var CLAUDE_ENTRY_FILE = "CLAUDE.md";
+var CLAUDE_MCP_CONFIG_FILE = ".mcp.json";
 function agentProviderFolderIn(repo, provider) {
   switch (provider) {
     case "claude":
@@ -1025,7 +1208,7 @@ function parseKVParams(typed, paramName) {
   for (const one of typed) {
     const at = one.indexOf("=");
     if (at <= 0)
-      throw new Fault(
+      throw new DomainFault(
         `"--${paramName} ${one}" names nothing to put a value under.`,
         `Type each one as --${paramName} name=value, once per name.`
       );
@@ -1042,7 +1225,7 @@ function lines({ data: { severity, message, fix } }) {
 async function editInEditor(cwd, file) {
   const editorCommand = process.env.VISUAL || process.env.EDITOR;
   if (!editorCommand)
-    throw new Fault("Neither $VISUAL nor $EDITOR is set, so there is no editor to open it in.", 'Set one, as in "export EDITOR=vim".');
+    throw new DomainFault("Neither $VISUAL nor $EDITOR is set, so there is no editor to open it in.", 'Set one, as in "export EDITOR=vim".');
   const exitCode = await new Promise(
     (resolve, reject) => spawn("sh", ["-c", `${editorCommand} "$1"`, editorCommand, `${cwd}/${file}`], { stdio: "inherit" }).once("error", reject).once("exit", resolve)
   );
@@ -1077,7 +1260,7 @@ var AddCommand = class {
       Object.entries(parseKVParams(header, "header")).map(([field, values]) => {
         if (lists.has(field)) return [field, values];
         if (values.length > 1)
-          throw new Fault(
+          throw new DomainFault(
             `"${field}" holds one line, and was typed ${values.length} times.`,
             `Type "--header ${field}=..." once.`
           );
@@ -1114,7 +1297,7 @@ var AddCommand = class {
    */
   async #answered(required, kind) {
     if (!process.stdin.isTTY)
-      throw new Fault(
+      throw new DomainFault(
         `A ${kind} requires ${required.map((one) => `"${one.field}"`).join(", ")}, and nobody is at the terminal to answer.`,
         `Run "cw add" where you can answer, or author the file under the charter yourself.`
       );
@@ -1130,7 +1313,7 @@ var AddCommand = class {
       )
     );
     if (required.some((one) => answers[one.field] === void 0))
-      throw new Fault("This was stopped before it had its answers, so nothing was written.", 'Run "cw add" again.');
+      throw new DomainFault("This was stopped before it had its answers, so nothing was written.", 'Run "cw add" again.');
     return answers;
   }
 };
@@ -1249,7 +1432,7 @@ var EditCommand = class {
   async run({ cwd, charterAuthoringApp: charterAuthoringApp2 }, { identity }) {
     const { scopedPrimitive: scopedPrimitive2 } = (await charterAuthoringApp2.open(identity ?? "")).data;
     if (scopedPrimitive2.data.scope === BUILTIN_SCOPE)
-      throw new Fault(
+      throw new DomainFault(
         `${scopedPrimitive2.data.identity} is built into cw, and there is no file of it in this repository to edit.`,
         `To differ from it, run "cw add" for a primitive of your own under an identity of its own.`
       );
@@ -1330,13 +1513,26 @@ var InitCommand = class {
   options = OPTIONS4;
   async run({ charterAuthoringApp: charterAuthoringApp2 }, { agent }) {
     const agents = await whichAgents(charterAuthoringApp2, agent);
-    await charterAuthoringApp2.init({ agents });
+    const planSummaryDTO2 = await charterAuthoringApp2.init({ agents });
+    const setUp = ["Set up this repository under a charter.", `Compiling for: ${agents.join(", ")}.`];
+    if (planSummaryDTO2.type === "FaultsByFile") {
+      const noOfFiles = Object.keys(planSummaryDTO2.data.files).length;
+      return {
+        code: EXIT_FAILURE,
+        result: [...setUp, ""].join("\n"),
+        problem: `Nothing was built: ${noOfFiles} file${noOfFiles === 1 ? " has" : "s have"} errors.
+Run "cw doctor" to see what is wrong with them.
+`
+      };
+    }
+    const { added, edited } = planSummaryDTO2.data;
+    const wrote = added.length + edited.length;
     return {
       code: EXIT_OK,
       result: [
-        "Set up this repository under a charter.",
-        `Compiling for: ${agents.join(", ")}.`,
-        'Author your first rule under .cw/charter/guide/, then run "cw build".',
+        ...setUp,
+        `Built ${wrote} file${wrote === 1 ? "" : "s"}: ${added.length} added, ${edited.length} changed.`,
+        'Author your first rule under .cw/charter/guide/, or ask your agent to write one, then run "cw build".',
         ""
       ].join("\n")
     };
@@ -1345,20 +1541,21 @@ var InitCommand = class {
 async function whichAgents(charterAuthoringApp2, typed) {
   if (typed !== void 0) {
     if (!isAgentProvider(typed))
-      throw new Fault(
+      throw new DomainFault(
         `This engine compiles for no agent called "${typed}".`,
         `Name any of: ${AGENT_PROVIDERS.join(", ")}.`
       );
     return [typed];
   }
   const agentsInSettings = (await charterAuthoringApp2.settings()).data.agents.filter(isAgentProvider);
+  const defaultAgents = agentsInSettings.length > 0 ? agentsInSettings : AGENT_PROVIDERS.length === 1 ? AGENT_PROVIDERS : [];
   if (!process.stdin.isTTY) {
-    if (agentsInSettings.length === 0)
-      throw new Fault(
+    if (defaultAgents.length === 0)
+      throw new DomainFault(
         "Nobody is at the terminal to choose an agent, and this repository has none chosen yet.",
         `Run "cw init --agent <name>", naming one of: ${AGENT_PROVIDERS.join(", ")}.`
       );
-    return agentsInSettings;
+    return defaultAgents;
   }
   const { chosen } = await prompts2({
     type: "multiselect",
@@ -1367,14 +1564,15 @@ async function whichAgents(charterAuthoringApp2, typed) {
     // What the settings already name arrives ticked, so a return keeps what this
     // repository is already running under and a second run is rechoosing rather
     // than starting over (FR-038). Nothing named yet — a repository being set up
-    // for the first time — arrives with nothing ticked.
-    choices: AGENT_PROVIDERS.map((one) => ({ title: one, value: one, selected: agentsInSettings.includes(one) })),
+    // for the first time — arrives with the one agent ticked where this engine
+    // compiles for one, and with nothing ticked otherwise (FR-055).
+    choices: AGENT_PROVIDERS.map((one) => ({ title: one, value: one, selected: defaultAgents.includes(one) })),
     // Ticking none of them is not an answer: a charter compiles for at least one
     // agent, so the prompt holds the submit until one is ticked (FR-033).
     min: 1
   });
   if (chosen === void 0)
-    throw new Fault("Setup was stopped before it had its answers.", 'Run "cw init" again.');
+    throw new DomainFault("Setup was stopped before it had its answers.", 'Run "cw init" again.');
   return chosen;
 }
 
@@ -1472,6 +1670,133 @@ function inFull(entry) {
   return [surveyed(entry), `  ${file}`, ...declared.length === 0 ? [] : [`  ${declared.join(", ")}`]].join("\n");
 }
 
+// src/driver/cli/commands/McpAuthCommand.ts
+import prompts3 from "prompts";
+var OPTIONS6 = {
+  identity: {
+    type: "string",
+    describe: 'One mcp whose address to sign in to again, whatever you were signed in as: "mcp:github/billing"'
+  },
+  status: {
+    type: "boolean",
+    default: false,
+    describe: "List each address, the mcps at it and whether you are signed in there, and change nothing"
+  }
+};
+var McpAuthCommand = class {
+  name = "mcp auth [identity]";
+  summary = "Sign in, as yourself, to every place the charter reaches";
+  options = OPTIONS6;
+  async run({ mcpConnectingApp: mcpConnectingApp2 }, { identity, status }) {
+    const signInStatuses = (await mcpConnectingApp2.signInStatus()).map((one) => one.data);
+    if (status)
+      return {
+        code: EXIT_OK,
+        result: signInStatuses.length === 0 ? "No place the last build listed takes a sign-in.\n" : signInStatuses.map(
+          ({ address, identities, signedIn, method }) => [address, `  ${identities.join(", ")}`, `  ${signedIn ? `signed in by ${method}` : "not signed in"}`, ""].join("\n")
+        ).join("")
+      };
+    let unsignedStatuses;
+    if (identity === void 0) unsignedStatuses = signInStatuses.filter((one) => !one.signedIn);
+    else {
+      const identityStatus = signInStatuses.find((one) => one.identities.includes(identity));
+      if (identityStatus === void 0)
+        throw new DomainFault(
+          `No place the last build listed is declared by ${identity}.`,
+          'Run "cw mcp auth --status" to see every mcp, or "cw build" if the charter changed.'
+        );
+      unsignedStatuses = [identityStatus];
+    }
+    if (unsignedStatuses.length === 0)
+      return {
+        code: EXIT_OK,
+        result: signInStatuses.length === 0 ? "No place the last build listed takes a sign-in.\n" : `You are signed in at every address: ${signInStatuses.length}.
+`
+      };
+    if (!process.stdin.isTTY)
+      return {
+        code: EXIT_FAILURE,
+        problem: [
+          "Not signed in at:",
+          ...unsignedStatuses.map(({ address }) => `  ${address}`),
+          '  Run "cw mcp auth" at a terminal to sign in; nothing is asked without one.',
+          ""
+        ].join("\n")
+      };
+    for (const { address, identities, auth: auth2 } of unsignedStatuses) {
+      process.stderr.write(`${address}
+  ${identities.join(", ")}
+`);
+      const { method } = auth2.length > 1 ? await prompts3({
+        type: "select",
+        name: "method",
+        message: "Sign in how?",
+        choices: auth2.map((one) => ({ title: one === "oauth" ? "in the browser (OAuth)" : "with a token", value: one }))
+      }) : { method: auth2[0] };
+      if (method === "oauth")
+        await mcpConnectingApp2.signInWithOAuth(
+          address,
+          (authorizationUrl) => process.stderr.write(`  Open this address to sign in, then come back here:
+  ${authorizationUrl}
+`)
+        );
+      else if (method === "token") {
+        const { token } = await prompts3({ type: "invisible", name: "token", message: "Token?" });
+        if (token === void 0) throwInterruptFault(address);
+        await mcpConnectingApp2.signInWithToken(address, token);
+      } else throwInterruptFault(address);
+    }
+    return {
+      code: EXIT_OK,
+      result: `Signed in at ${unsignedStatuses.map(({ address }) => address).join(", ")}.
+`
+    };
+  }
+};
+function throwInterruptFault(address) {
+  throw new DomainFault(`This was stopped before signing in at ${address}; what was signed in before it is kept.`, 'Run "cw mcp auth" again.');
+}
+
+// src/driver/cli/commands/McpServeCommand.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/driver/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+async function startMcpServer(mcpConnectingApp2, transport, version = "0.0.0") {
+  const server = new Server({ name: "cw", version }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: (await mcpConnectingApp2.served()).data.tools.map(({ data }) => data)
+  }));
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    async ({ params }) => (await mcpConnectingApp2.call(params.name, params.arguments ?? {})).data
+  );
+  const serverClosed = new Promise((resolve) => server.onclose = resolve);
+  await server.connect(transport);
+  return { serverClosed };
+}
+
+// src/driver/cli/commands/McpServeCommand.ts
+var McpServeCommand = class {
+  name = "mcp serve";
+  summary = "Serve every place the charter reaches to your agent, over stdio";
+  async run({ mcpConnectingApp: mcpConnectingApp2, version }) {
+    const servedTools2 = await mcpConnectingApp2.served();
+    for (const problem of servedTools2.data.problems) process.stderr.write(`${problem}
+`);
+    const transport = new StdioServerTransport();
+    const { serverClosed } = await startMcpServer(mcpConnectingApp2, transport, version);
+    const closeTransport = () => void transport.close();
+    process.stdin.once("end", closeTransport);
+    process.once("SIGTERM", closeTransport);
+    process.once("SIGINT", closeTransport);
+    await serverClosed;
+    await mcpConnectingApp2.stopServing();
+    return { code: EXIT_OK };
+  }
+};
+
 // src/driver/portal/server.ts
 import { randomBytes } from "crypto";
 import { access } from "fs/promises";
@@ -1484,87 +1809,87 @@ import { serveStatic } from "@hono/node-server/serve-static";
 // src/driver/portal/routes.ts
 import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
 import { HTTPException } from "hono/http-exception";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/hexagon/port/driver/dtos/dto.ts
-import { z as z5 } from "zod";
-var strings = z5.array(z5.string()).readonly();
-var dto = (type, data) => z5.object({ type: z5.literal(type), data });
+import { z as z6 } from "zod";
+var strings = z6.array(z6.string()).readonly();
+var dto = (type, data) => z6.object({ type: z6.literal(type), data });
 function byType(...schemas) {
   return Object.fromEntries(schemas.map((one) => [one.shape.type.value, one]));
 }
 
 // src/hexagon/port/driver/dtos/data.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var fault = dto(
   "Fault",
-  z6.object({
-    message: z6.string(),
-    fix: z6.string(),
-    severity: z6.enum(["error", "warn"])
+  z7.object({
+    message: z7.string(),
+    fix: z7.string(),
+    severity: z7.enum(["error", "warn"])
   })
 );
 var faultsByFile = dto(
   "FaultsByFile",
-  z6.object({
-    files: z6.record(z6.string(), z6.array(fault).readonly())
+  z7.object({
+    files: z7.record(z7.string(), z7.array(fault).readonly())
   })
 );
 var faults = dto(
   "Faults",
-  z6.object({
-    faults: z6.array(fault).readonly()
+  z7.object({
+    faults: z7.array(fault).readonly()
   })
 );
-var primitiveKinds = dto("PrimitiveKinds", z6.record(z6.string(), z6.string()));
+var primitiveKinds = dto("PrimitiveKinds", z7.record(z7.string(), z7.string()));
 var catalogueEntry = dto(
   "CatalogueEntry",
-  z6.object({
-    identity: z6.string(),
-    kind: z6.string(),
-    id: z6.string(),
-    description: z6.string(),
-    file: z6.string(),
+  z7.object({
+    identity: z7.string(),
+    kind: z7.string(),
+    id: z7.string(),
+    description: z7.string(),
+    file: z7.string(),
     tags: strings.optional(),
     globs: strings.optional(),
-    rationale: z6.string().optional(),
+    rationale: z7.string().optional(),
     mixins: strings.optional()
   })
 );
 var catalogue = dto(
   "Catalogue",
-  z6.object({
-    entries: z6.array(catalogueEntry).readonly()
+  z7.object({
+    entries: z7.array(catalogueEntry).readonly()
   })
 );
 var scopedPrimitive = dto(
   "ScopedPrimitive",
-  z6.object({
-    identity: z6.string(),
-    kind: z6.string(),
-    description: z6.string(),
-    file: z6.string(),
-    scope: z6.enum(["repo", "vendor", "builtin"]),
-    headers: z6.record(z6.string(), z6.union([z6.string(), strings]))
+  z7.object({
+    identity: z7.string(),
+    kind: z7.string(),
+    description: z7.string(),
+    file: z7.string(),
+    scope: z7.enum(["repo", "vendor", "builtin"]),
+    headers: z7.record(z7.string(), z7.union([z7.string(), strings]))
   })
 );
 var scopedPrimitives = dto(
   "ScopedPrimitives",
-  z6.object({
-    primitives: z6.array(scopedPrimitive).readonly()
+  z7.object({
+    primitives: z7.array(scopedPrimitive).readonly()
   })
 );
 var primitiveSnapshot = dto(
   "PrimitiveSnapshot",
-  z6.object({
+  z7.object({
     scopedPrimitive,
-    body: z6.string(),
-    revision: z6.string()
+    body: z7.string(),
+    revision: z7.string()
   })
 );
 var planSummary = dto(
   "PlanSummary",
-  z6.object({
+  z7.object({
     added: strings,
     edited: strings,
     deleted: strings,
@@ -1573,63 +1898,89 @@ var planSummary = dto(
 );
 var primitiveHeader = dto(
   "PrimitiveHeader",
-  z6.object({
-    field: z6.string(),
-    shape: z6.enum(["line", "list"]),
-    required: z6.boolean(),
+  z7.object({
+    field: z7.string(),
+    shape: z7.enum(["line", "list"]),
+    required: z7.boolean(),
     allowedValues: strings.optional()
   })
 );
 var primitiveRequirements = dto(
   "PrimitiveRequirements",
-  z6.object({
-    headers: z6.array(primitiveHeader).readonly(),
-    sample: z6.string()
+  z7.object({
+    headers: z7.array(primitiveHeader).readonly(),
+    sample: z7.string()
   })
 );
-var testCasesByFile = dto("TestCasesByFile", z6.record(z6.string(), strings));
+var testCasesByFile = dto("TestCasesByFile", z7.record(z7.string(), strings));
 var testCaseReport = dto(
   "TestCaseReport",
-  z6.object({
-    suiteName: z6.string(),
-    situation: z6.string(),
-    passed: z6.boolean(),
+  z7.object({
+    suiteName: z7.string(),
+    situation: z7.string(),
+    passed: z7.boolean(),
     unmet: fault.optional()
   })
 );
 var testRunReport = dto(
   "TestRunReport",
-  z6.object({
-    testCaseReports: z6.array(testCaseReport).readonly()
+  z7.object({
+    testCaseReports: z7.array(testCaseReport).readonly()
   })
 );
 var testCase = dto(
   "TestCase",
-  z6.object({
-    situation: z6.string(),
-    expectation: z6.string(),
-    identity: z6.string().optional()
+  z7.object({
+    situation: z7.string(),
+    expectation: z7.string(),
+    identity: z7.string().optional()
   })
 );
 var testSuite = dto(
   "TestSuite",
-  z6.object({
-    name: z6.string(),
-    text: z6.string().optional(),
-    description: z6.string().optional(),
-    cases: z6.array(testCase).readonly(),
+  z7.object({
+    name: z7.string(),
+    text: z7.string().optional(),
+    description: z7.string().optional(),
+    cases: z7.array(testCase).readonly(),
     fault: fault.optional()
   })
 );
 var testSuites = dto(
   "TestSuites",
-  z6.object({
-    testSuites: z6.array(testSuite).readonly()
+  z7.object({
+    testSuites: z7.array(testSuite).readonly()
+  })
+);
+var signInStatus = dto(
+  "SignInStatus",
+  z7.object({
+    address: z7.string(),
+    identities: strings,
+    auth: z7.array(z7.enum(["oauth", "token"])).readonly(),
+    signedIn: z7.boolean(),
+    method: z7.enum(["oauth", "token"]).optional()
+  })
+);
+var servedTool = dto(
+  "ServedTool",
+  z7.object({
+    name: z7.string(),
+    description: z7.string(),
+    inputSchema: z7.record(z7.string(), z7.unknown())
+  })
+);
+var servedTools = dto(
+  "ServedTools",
+  z7.object({
+    tools: z7.array(servedTool).readonly(),
+    problems: strings
   })
 );
+var toolAnswer = dto("ToolAnswer", z7.record(z7.string(), z7.unknown()));
 var workspaceSettings = dto(
   "WorkspaceSettings",
-  z6.object({
+  z7.object({
     agents: strings
   })
 );
@@ -1646,59 +1997,63 @@ var DataDTOs = byType(
   primitiveSnapshot,
   scopedPrimitive,
   scopedPrimitives,
+  servedTool,
+  servedTools,
+  signInStatus,
   testCase,
   testCaseReport,
   testCasesByFile,
   testRunReport,
   testSuite,
   testSuites,
+  toolAnswer,
   workspaceSettings
 );
 
 // src/hexagon/port/driver/dtos/outcome.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var doctorOutcome = dto(
   "DoctorOutcome",
-  z7.object({
+  z8.object({
     agents: strings,
-    errorCount: z7.number(),
-    warnCount: z7.number(),
-    pendingCount: z7.number().nullable(),
+    errorCount: z8.number(),
+    warnCount: z8.number(),
+    pendingCount: z8.number().nullable(),
     faultsByFile: DataDTOs.FaultsByFile,
     driftedVendors: strings,
-    problemCount: z7.number()
+    problemCount: z8.number()
   })
 );
 var explanationOutcome = dto(
   "ExplanationOutcome",
-  z7.object({
+  z8.object({
     scopedPrimitive: DataDTOs.ScopedPrimitive,
-    activatesWhen: z7.string(),
-    useMixins: z7.array(DataDTOs.ScopedPrimitive).readonly(),
+    activatesWhen: z8.string(),
+    useMixins: z8.array(DataDTOs.ScopedPrimitive).readonly(),
     rationale: DataDTOs.ScopedPrimitive.optional(),
-    hosts: z7.array(DataDTOs.ScopedPrimitive).readonly(),
-    citers: z7.array(DataDTOs.ScopedPrimitive).readonly(),
+    hosts: z8.array(DataDTOs.ScopedPrimitive).readonly(),
+    citers: z8.array(DataDTOs.ScopedPrimitive).readonly(),
     testCasesByFile: DataDTOs.TestCasesByFile
   })
 );
 var OutcomeDTOs = byType(doctorOutcome, explanationOutcome);
 
 // src/hexagon/domain/models/test/TestSuite.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/hexagon/domain/models/test/TestCase.ts
-import { z as z8 } from "zod";
-var TEST_CASE_SCHEMA = z8.union([
-  z8.strictObject({
-    do: z8.strictObject({ touchFile: z8.string().min(1) }),
-    expect: z8.union([
-      z8.strictObject({ activate: PRIMITIVE_IDENTITY_SCHEMA }),
-      z8.strictObject({ allow: z8.boolean() })
+import { z as z9 } from "zod";
+var TEST_CASE_SCHEMA = z9.union([
+  z9.strictObject({
+    do: z9.strictObject({ touchFile: z9.string().min(1) }),
+    expect: z9.union([
+      z9.strictObject({ activate: PRIMITIVE_IDENTITY_SCHEMA }),
+      z9.strictObject({ allow: z9.boolean() })
     ])
   }),
-  z8.strictObject({
-    when: z8.enum(SIGNALS),
-    expect: z8.strictObject({ run: PRIMITIVE_IDENTITY_SCHEMA })
+  z9.strictObject({
+    when: z9.enum(SIGNALS),
+    expect: z9.strictObject({ run: PRIMITIVE_IDENTITY_SCHEMA })
   })
 ]);
 var TestCase = class {
@@ -1740,9 +2095,9 @@ var TestCase = class {
 };
 
 // src/hexagon/domain/models/test/TestSuite.ts
-var TEST_SUITE_SCHEMA = z9.strictObject({
-  description: z9.string().min(1).optional(),
-  cases: z9.array(TEST_CASE_SCHEMA.transform((written) => new TestCase(written))).min(1)
+var TEST_SUITE_SCHEMA = z10.strictObject({
+  description: z10.string().min(1).optional(),
+  cases: z10.array(TEST_CASE_SCHEMA.transform((written) => new TestCase(written))).min(1)
 });
 var TestSuite = class {
   constructor(description, cases, body) {
@@ -1809,7 +2164,7 @@ function testRootOf(testSuiteFiles) {
     try {
       suitesByFile[path] = testSuiteOf(contents);
     } catch (raised) {
-      if (!(raised instanceof Fault)) throw raised;
+      if (!(raised instanceof DomainFault)) throw raised;
       faultsByFiles[path] = [raised];
     }
   }
@@ -1962,7 +2317,7 @@ var json = (schema, description) => ({
 function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
   const app = new OpenAPIHono();
   app.onError((raised, c) => {
-    if (raised instanceof Fault) return c.json(faultDTO(raised), 422);
+    if (raised instanceof DomainFault) return c.json(faultDTO(raised), 422);
     if (raised instanceof HTTPException) return raised.getResponse();
     console.error(raised);
     return c.text(raised.message, 500);
@@ -1978,10 +2333,10 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
     createRoute({
       method: "get",
       path: "/charter/root/primitives",
-      request: { query: z10.object({ matching: z10.string().optional() }) },
+      request: { query: z11.object({ matching: z11.string().optional() }) },
       responses: {
         200: json(DataDTOs.ScopedPrimitives, "Every primitive of every layer, or those mentioning the word"),
-        422: json(z10.union([DataDTOs.FaultsByFile, DataDTOs.Fault]), "The charter does not hold")
+        422: json(z11.union([DataDTOs.FaultsByFile, DataDTOs.Fault]), "The charter does not hold")
       }
     }),
     async (c) => {
@@ -1992,10 +2347,10 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
     createRoute({
       method: "get",
       path: "/charter/root/primitives/{identity}/explanation",
-      request: { params: z10.object({ identity: z10.string() }) },
+      request: { params: z11.object({ identity: z11.string() }) },
       responses: {
         200: json(OutcomeDTOs.ExplanationOutcome, "What the engine says of one primitive"),
-        422: json(z10.union([DataDTOs.FaultsByFile, DataDTOs.Fault]), "The charter does not hold, or holds nothing of it")
+        422: json(z11.union([DataDTOs.FaultsByFile, DataDTOs.Fault]), "The charter does not hold, or holds nothing of it")
       }
     }),
     async (c) => {
@@ -2009,11 +2364,11 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
       path: "/charter/root/primitives",
       request: {
         body: json(
-          z10.object({
-            kind: z10.string(),
-            id: z10.string(),
-            headers: z10.record(z10.string(), z10.union([z10.string(), z10.array(z10.string())])),
-            body: z10.string()
+          z11.object({
+            kind: z11.string(),
+            id: z11.string(),
+            headers: z11.record(z11.string(), z11.union([z11.string(), z11.array(z11.string())])),
+            body: z11.string()
           }),
           "A new primitive: its kind and id, a line or a list under each header, and its body"
         )
@@ -2021,26 +2376,26 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
       responses: {
         201: {
           ...json(DataDTOs.ScopedPrimitive, "The primitive written"),
-          headers: z10.object({ Location: z10.string() })
+          headers: z11.object({ Location: z11.string() })
         },
-        422: json(z10.union([DataDTOs.Faults, DataDTOs.Fault]), "The answers the kind refused, or an identity already claimed")
+        422: json(z11.union([DataDTOs.Faults, DataDTOs.Fault]), "The answers the kind refused, or an identity already claimed")
       }
     }),
     async (c) => {
       const { kind, id, headers, body } = c.req.valid("json");
       const scopedPrimitiveDTO2 = await charterAuthoringApp2.add(kind, id, headers, body);
       if (scopedPrimitiveDTO2.type === "Faults") return c.json(scopedPrimitiveDTO2, 422);
-      return c.json(scopedPrimitiveDTO2, 201, { Location: `/api/charter/root/primitives/${scopedPrimitiveDTO2.data.identity}` });
+      return c.json(scopedPrimitiveDTO2, 201, { Location: `/api/charter/root/primitives/${encodeURIComponent(scopedPrimitiveDTO2.data.identity)}` });
     }
   ).openapi(
     createRoute({
       method: "get",
       path: "/charter/root/primitives/{identity}",
-      request: { params: z10.object({ identity: z10.string() }) },
+      request: { params: z11.object({ identity: z11.string() }) },
       responses: {
         200: {
           ...json(DataDTOs.PrimitiveSnapshot, "One primitive as the charter read it"),
-          headers: z10.object({ ETag: z10.string() })
+          headers: z11.object({ ETag: z11.string() })
         },
         422: json(DataDTOs.Fault, "The charter holds nothing of it")
       }
@@ -2055,12 +2410,12 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
       method: "put",
       path: "/charter/root/primitives/{identity}",
       request: {
-        params: z10.object({ identity: z10.string() }),
-        headers: z10.object({ "if-match": z10.string().optional() }),
+        params: z11.object({ identity: z11.string() }),
+        headers: z11.object({ "if-match": z11.string().optional() }),
         body: json(
-          z10.object({
-            headers: z10.record(z10.string(), z10.union([z10.string(), z10.array(z10.string())])),
-            body: z10.string()
+          z11.object({
+            headers: z11.record(z11.string(), z11.union([z11.string(), z11.array(z11.string())])),
+            body: z11.string()
           }),
           "A line or a list under each header, and the body, written over the primitive's own"
         )
@@ -2068,7 +2423,7 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
       responses: {
         200: json(DataDTOs.ScopedPrimitive, "The primitive written"),
         412: json(DataDTOs.Fault, "The file changed on disk after it was opened"),
-        422: json(z10.union([DataDTOs.Faults, DataDTOs.Fault]), "The answers the kind refused, or a primitive this repository did not author")
+        422: json(z11.union([DataDTOs.Faults, DataDTOs.Fault]), "The answers the kind refused, or a primitive this repository did not author")
       }
     }),
     async (c) => {
@@ -2077,7 +2432,7 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
       if (c.req.valid("header")["if-match"] !== `"${revision}"`)
         return c.json(
           faultDTO(
-            new Fault(
+            new DomainFault(
               `${scopedPrimitive2.data.file} changed on disk after it was opened, and saving would write over that change.`,
               "Open it again to see what changed, then make your edit there."
             )
@@ -2092,7 +2447,7 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
     createRoute({
       method: "delete",
       path: "/charter/root/primitives/{identity}",
-      request: { params: z10.object({ identity: z10.string() }) },
+      request: { params: z11.object({ identity: z11.string() }) },
       responses: {
         204: { description: "The file is gone" },
         422: json(DataDTOs.Fault, "A primitive this repository did not author, or none at all")
@@ -2114,7 +2469,7 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
     createRoute({
       method: "get",
       path: "/definitions/kinds/{kind}/requirements",
-      request: { params: z10.object({ kind: z10.string() }) },
+      request: { params: z11.object({ kind: z11.string() }) },
       responses: {
         200: json(DataDTOs.PrimitiveRequirements, "Every header the kind takes, and its sample"),
         422: json(DataDTOs.Fault, "A word that is no kind")
@@ -2167,8 +2522,8 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
       path: "/test-suites",
       responses: {
         201: {
-          ...json(z10.string(), "The name of the test file written"),
-          headers: z10.object({ Location: z10.string() })
+          ...json(z11.string(), "The name of the test file written"),
+          headers: z11.object({ Location: z11.string() })
         }
       }
     }),
@@ -2181,11 +2536,11 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
       method: "put",
       path: "/test-suites/{name}",
       request: {
-        params: z10.object({ name: z10.string() }),
-        body: json(z10.object({ text: z10.string() }), "The whole text the test file is written over with")
+        params: z11.object({ name: z11.string() }),
+        body: json(z11.object({ text: z11.string() }), "The whole text the test file is written over with")
       },
       responses: {
-        200: json(z10.string(), "The name of the test file written"),
+        200: json(z11.string(), "The name of the test file written"),
         422: json(DataDTOs.Fault, "Text that is not a suite, with its sample, or a name that is no test file")
       }
     }),
@@ -2194,7 +2549,7 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
     createRoute({
       method: "delete",
       path: "/test-suites/{name}",
-      request: { params: z10.object({ name: z10.string() }) },
+      request: { params: z11.object({ name: z11.string() }) },
       responses: {
         204: { description: "The test file is gone" },
         422: json(DataDTOs.Fault, "A name that is no test file")
@@ -2221,7 +2576,7 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
     createRoute({
       method: "get",
       path: "/vendors",
-      responses: { 200: json(z10.array(z10.string()).readonly(), "Every folder a vendor source was installed as") }
+      responses: { 200: json(z11.array(z11.string()).readonly(), "Every folder a vendor source was installed as") }
     }),
     async (c) => c.json(await charterVendoringApp2.installed(), 200)
   ).openapi(
@@ -2230,7 +2585,7 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
       path: "/vendors",
       request: {
         body: json(
-          z10.object({ source: z10.string(), version: z10.string().optional() }),
+          z11.object({ source: z11.string(), version: z11.string().optional() }),
           "A source as git fetches it, and the version to pin it to where one is named"
         )
       },
@@ -2248,7 +2603,7 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
     createRoute({
       method: "delete",
       path: "/vendors/{name}",
-      request: { params: z10.object({ name: z10.string() }) },
+      request: { params: z11.object({ name: z11.string() }) },
       responses: {
         204: { description: "The folder is gone, and that it is gone is committed" },
         422: json(DataDTOs.Fault, "No repository, work in hand, or what git refused")
@@ -2265,7 +2620,7 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
 var DEFAULT_PORT = 9927;
 async function startPortal(page, charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2, port = DEFAULT_PORT) {
   await access(new URL("index.html", page)).catch(() => {
-    throw new Fault("The portal's page is not built.", 'Run "pnpm build", then start the portal again.');
+    throw new DomainFault("The portal's page is not built.", 'Run "pnpm build", then start the portal again.');
   });
   const token = randomBytes(32).toString("base64url");
   for (let next = port; ; next++) {
@@ -2300,7 +2655,7 @@ function listen(app, port) {
 }
 
 // src/driver/cli/commands/PortalCommand.ts
-var OPTIONS6 = {
+var OPTIONS7 = {
   port: {
     type: "number",
     describe: "Which port to serve on, the next free one when it is taken",
@@ -2310,7 +2665,7 @@ var OPTIONS6 = {
 var PortalCommand = class {
   name = "portal";
   summary = "Serve this repository's charter to a browser on this machine";
-  options = OPTIONS6;
+  options = OPTIONS7;
   async run({ charterAuthoringApp: charterAuthoringApp2, charterVendoringApp: charterVendoringApp2, testAuthoringApp: testAuthoringApp2 }, { port }) {
     await charterAuthoringApp2.ensureRepoReady();
     const { address } = await startPortal(
@@ -2327,8 +2682,8 @@ Press Ctrl+C to stop it.
 };
 
 // src/driver/cli/commands/RemoveCommand.ts
-import prompts3 from "prompts";
-var OPTIONS7 = {
+import prompts4 from "prompts";
+var OPTIONS8 = {
   identity: {
     type: "string",
     describe: 'What the primitive is named by across the whole charter: "guide:no-any"'
@@ -2343,16 +2698,16 @@ var OPTIONS7 = {
 var RemoveCommand = class {
   name = "remove <identity>";
   summary = "Delete the file of one primitive this repository authored";
-  options = OPTIONS7;
+  options = OPTIONS8;
   async run({ charterAuthoringApp: charterAuthoringApp2 }, { identity, yes }) {
     const { scopedPrimitive: scopedPrimitive2 } = (await charterAuthoringApp2.open(identity ?? "")).data;
     if (!yes && scopedPrimitive2.data.scope === REPO_SCOPE) {
       if (!process.stdin.isTTY)
-        throw new Fault(
+        throw new DomainFault(
           `Removing ${scopedPrimitive2.data.file} is asked first, and nobody is at the terminal to answer.`,
           `Run "cw remove ${scopedPrimitive2.data.identity} --yes" to remove it without asking.`
         );
-      const { confirmed } = await prompts3({
+      const { confirmed } = await prompts4({
         type: "confirm",
         name: "confirmed",
         message: `Remove ${scopedPrimitive2.data.file}?`,
@@ -2386,7 +2741,7 @@ var SuiteAddCommand = class {
 };
 
 // src/driver/cli/commands/SuiteEditCommand.ts
-var OPTIONS8 = {
+var OPTIONS9 = {
   name: {
     type: "string",
     describe: `The test file's name under ${TEST_DIRECTORY}/: "untitled-1.json"`
@@ -2395,11 +2750,11 @@ var OPTIONS8 = {
 var SuiteEditCommand = class {
   name = "suite edit <name>";
   summary = "Open one test file in your editor";
-  options = OPTIONS8;
+  options = OPTIONS9;
   async run({ cwd, testAuthoringApp: testAuthoringApp2 }, { name }) {
     const { testSuites: testSuites2 } = (await testAuthoringApp2.suites()).data;
     if (!testSuites2.some((one) => one.data.name === name))
-      throw new Fault(`${TEST_DIRECTORY}/ holds no test file called "${name ?? ""}".`, 'Run "cw suite add" to write a new one.');
+      throw new DomainFault(`${TEST_DIRECTORY}/ holds no test file called "${name ?? ""}".`, 'Run "cw suite add" to write a new one.');
     const file = `${TEST_DIRECTORY}/${name}`;
     const problem = await editInEditor(cwd, file);
     if (problem !== void 0) return { code: EXIT_FAILURE, problem };
@@ -2408,7 +2763,7 @@ var SuiteEditCommand = class {
 };
 
 // src/driver/cli/commands/SuiteRemoveCommand.ts
-var OPTIONS9 = {
+var OPTIONS10 = {
   name: {
     type: "string",
     describe: `The test file's name under ${TEST_DIRECTORY}/: "untitled-1.json"`
@@ -2417,7 +2772,7 @@ var OPTIONS9 = {
 var SuiteRemoveCommand = class {
   name = "suite remove <name>";
   summary = "Delete one test file";
-  options = OPTIONS9;
+  options = OPTIONS10;
   async run({ testAuthoringApp: testAuthoringApp2 }, { name }) {
     const removedName = await testAuthoringApp2.removeSuite(name ?? "");
     return { code: EXIT_OK, result: `Removed ${TEST_DIRECTORY}/${removedName}.
@@ -2464,7 +2819,7 @@ function lines2(one) {
 }
 
 // src/driver/cli/commands/VendorAddCommand.ts
-var OPTIONS10 = {
+var OPTIONS11 = {
   source: {
     type: "string",
     describe: "What git clones the charter from: an address over any transport, or a path on disk"
@@ -2477,7 +2832,7 @@ var OPTIONS10 = {
 var VendorAddCommand = class {
   name = "vendor add <source>";
   summary = "Install a charter from a git source, or bring an installed one up to date";
-  options = OPTIONS10;
+  options = OPTIONS11;
   async run({ charterVendoringApp: charterVendoringApp2 }, { source, ref }) {
     const folder = await charterVendoringApp2.add(source ?? "", ref);
     return {
@@ -2505,7 +2860,7 @@ var VendorListCommand = class {
 };
 
 // src/driver/cli/commands/VendorRemoveCommand.ts
-var OPTIONS11 = {
+var OPTIONS12 = {
   name: {
     type: "string",
     describe: "The folder this charter was installed as, as it reads under .cw/vendor/"
@@ -2514,7 +2869,7 @@ var OPTIONS11 = {
 var VendorRemoveCommand = class {
   name = "vendor remove <name>";
   summary = "Take an installed charter away";
-  options = OPTIONS11;
+  options = OPTIONS12;
   async run({ charterVendoringApp: charterVendoringApp2 }, { name }) {
     const folder = await charterVendoringApp2.remove(name ?? "");
     return {
@@ -2546,7 +2901,9 @@ var COMMANDS = [
   new VendorAddCommand(),
   new VendorRemoveCommand(),
   new VendorListCommand(),
-  new PortalCommand()
+  new PortalCommand(),
+  new McpAuthCommand(),
+  new McpServeCommand()
 ];
 
 // src/driver/cli/Commander.ts
@@ -2603,7 +2960,7 @@ var Commander = class {
         try {
           collect(await command.run(this.#context, options));
         } catch (raised) {
-          if (!(raised instanceof Fault)) throw raised;
+          if (!(raised instanceof DomainFault)) throw raised;
           collect({ code: EXIT_FAILURE, problem: `${raised.message}
   ${raised.fix}
 ` });
@@ -2642,7 +2999,6 @@ var CwAuthorSkill = class extends SkillPrimitive {
           "write a rule",
           "add a standard",
           "write a skill",
-          "add a command",
           "author a primitive of the charter"
         ]
       },
@@ -2707,7 +3063,7 @@ async function writeCharter(repo, primitive, fileReader2, fileWriter2) {
   const path = `${CHARTER_DIRECTORY}/${under2}`;
   const file = new URL(under2, charterFolderIn(repo));
   if (await fileReader2.readIfThere(file) !== void 0)
-    throw new Fault(
+    throw new DomainFault(
       `${path} is already there, and writing this one would write over what it holds.`,
       `Open it, or run this again with an identity this charter has not got.`
     );
@@ -2716,9 +3072,9 @@ async function writeCharter(repo, primitive, fileReader2, fileWriter2) {
 }
 
 // src/hexagon/domain/models/Settings.ts
-import { z as z11 } from "zod";
-var SETTINGS = z11.object({
-  agents: z11.array(z11.enum(AGENT_PROVIDERS))
+import { z as z12 } from "zod";
+var SETTINGS = z12.object({
+  agents: z12.array(z12.enum(AGENT_PROVIDERS))
 });
 var WorkspaceSettings = class {
   constructor(agents) {
@@ -2811,12 +3167,12 @@ async function loadVendorNames(repo, fileReaders) {
 }
 async function ensureVCSReady(repo, vcs2, because) {
   if (!await vcs2.isInstalled(repo))
-    throw new Fault(
+    throw new DomainFault(
       "This folder is not inside a git repository, and a vendor lives in one.",
       'Run "git init" here, or run this again where your repository is.'
     );
   if (!await vcs2.isClean(repo))
-    throw new Fault(
+    throw new DomainFault(
       `This repository has work in hand, and ${because}.`,
       "Commit or stash what you are holding, then run this again."
     );
@@ -2966,19 +3322,7 @@ async function contentHashOf(content) {
   return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 
-// src/hexagon/domain/models/output/StampedDocument.ts
-var GENERATED_STAMP = "Generated by cherry-works";
-function stamp(document) {
-  return `${document.replace(/\n+$/, "")}
-
-<!-- ${GENERATED_STAMP}. Do not edit; edit the charter and build again. -->
-`;
-}
-function isStamped(contents) {
-  return contents.includes(GENERATED_STAMP);
-}
-
-// src/hexagon/domain/models/output/CharterOutput.ts
+// src/hexagon/domain/models/output/common/Catalogue.ts
 var Catalogue = class _Catalogue {
   constructor(entries) {
     this.entries = entries;
@@ -3020,6 +3364,20 @@ var Catalogue = class _Catalogue {
     return this.entries.map(({ identity, kind, id, description }) => ({ identity, kind, id, description }));
   }
 };
+
+// src/hexagon/domain/models/output/StampedDocument.ts
+var GENERATED_STAMP = "Generated by cherry-works";
+function stamp(document) {
+  return `${document.replace(/\n+$/, "")}
+
+<!-- ${GENERATED_STAMP}. Do not edit; edit the charter and build again. -->
+`;
+}
+function isStamped(contents) {
+  return contents.includes(GENERATED_STAMP);
+}
+
+// src/hexagon/domain/models/output/common/CharterMd.ts
 var CharterMd = class _CharterMd {
   constructor(body) {
     this.body = body;
@@ -3050,34 +3408,26 @@ var CharterMd = class _CharterMd {
   }
 };
 
-// src/hexagon/domain/models/output/providers/claude/ClaudeSettingsComponent.ts
-var CLAUDE_HOOK_EVENTS = [
-  "PreToolUse",
-  "PostToolUse",
-  "UserPromptSubmit",
-  "Notification",
-  "Stop",
-  "SubagentStop",
-  "PreCompact",
-  "SessionStart",
-  "SessionEnd"
-];
-function isClaudeHookEvent(name) {
-  return CLAUDE_HOOK_EVENTS.includes(name);
-}
-var ClaudeSettingsComponent = class _ClaudeSettingsComponent {
-  constructor(settings) {
-    this.settings = settings;
+// src/hexagon/domain/models/output/common/CompiledPrimitive.ts
+var CompiledPrimitive = class _CompiledPrimitive {
+  constructor(identity, file, document) {
+    this.identity = identity;
+    this.file = file;
+    this.document = document;
   }
-  settings;
-  static kind = "settings";
-  kind = _ClaudeSettingsComponent.kind;
-  /** The settings file this host reads is shared with whatever the repository set
-   *  for itself, so what is put down there is written into what is there rather
-   *  than in place of it (FR-018). */
-  projection = "mergeJSON";
-  static of(settings) {
-    return new _ClaudeSettingsComponent(settings);
+  identity;
+  file;
+  document;
+  static of(one, document) {
+    return new _CompiledPrimitive(one.identity, `${OUT_DIRECTORY}/${one.primitive.kind}/${one.primitive.headers.id}.md`, document);
+  }
+  /** Generated, and the charter's alone: written whole over whatever is there,
+   *  and gone with the primitive it was compiled from. */
+  projection = "replace";
+  /** This document as a reader opens it, with the stamp saying where to change
+   *  it instead. */
+  toStampedDocument() {
+    return stamp(this.document);
   }
 };
 
@@ -3128,15 +3478,6 @@ var ClaudeAgentComponent = class _ClaudeAgentComponent extends DocumentBasedComp
   }
 };
 
-// src/hexagon/domain/models/output/providers/claude/document-based-components/ClaudeCommandComponent.ts
-var ClaudeCommandComponent = class _ClaudeCommandComponent extends DocumentBasedComponent {
-  static kind = "command";
-  kind = _ClaudeCommandComponent.kind;
-  static of(name, headers, body) {
-    return new _ClaudeCommandComponent(name, headers, body);
-  }
-};
-
 // src/hexagon/domain/models/output/providers/claude/document-based-components/ClaudeRuleComponent.ts
 var ClaudeRuleComponent = class _ClaudeRuleComponent extends DocumentBasedComponent {
   static kind = "rule";
@@ -3146,6 +3487,57 @@ var ClaudeRuleComponent = class _ClaudeRuleComponent extends DocumentBasedCompon
   }
 };
 
+// src/hexagon/domain/models/output/providers/claude/ClaudeMcpConfigComponent.ts
+var ClaudeMcpConfigComponent = class _ClaudeMcpConfigComponent {
+  static kind = "mcp-config";
+  kind = _ClaudeMcpConfigComponent.kind;
+  /** What this host names the server, and so what it puts before each tool it
+   *  serves: `mcp__cw__<tool>`. */
+  static cwMcpName = "cw";
+  /** That file is the repository's too — every server it wrote itself is
+   *  there — so the charter's one entry is written into it, and it is never
+   *  taken away, as the settings are not (FR-146). */
+  projection = "mergeJSON";
+  /** The one entry the charter speaks for, under `mcpServers`. */
+  mcpServers = { [_ClaudeMcpConfigComponent.cwMcpName]: { command: "cw", args: ["mcp", "serve"] } };
+  static of() {
+    return new _ClaudeMcpConfigComponent();
+  }
+  constructor() {
+  }
+};
+
+// src/hexagon/domain/models/output/providers/claude/ClaudeSettingsComponent.ts
+var CLAUDE_HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "UserPromptSubmit",
+  "Notification",
+  "Stop",
+  "SubagentStop",
+  "PreCompact",
+  "SessionStart",
+  "SessionEnd"
+];
+function isClaudeHookEvent(name) {
+  return CLAUDE_HOOK_EVENTS.includes(name);
+}
+var ClaudeSettingsComponent = class _ClaudeSettingsComponent {
+  constructor(settings) {
+    this.settings = settings;
+  }
+  settings;
+  static kind = "settings";
+  kind = _ClaudeSettingsComponent.kind;
+  /** The settings file this host reads is shared with whatever the repository set
+   *  for itself, so what is put down there is written into what is there rather
+   *  than in place of it (FR-018). */
+  projection = "mergeJSON";
+  static of(settings) {
+    return new _ClaudeSettingsComponent(settings);
+  }
+};
+
 // src/hexagon/domain/models/output/providers/claude/document-based-components/ClaudeSkillComponent.ts
 var ClaudeSkillComponent = class _ClaudeSkillComponent extends DocumentBasedComponent {
   static kind = "skill";
@@ -3155,50 +3547,74 @@ var ClaudeSkillComponent = class _ClaudeSkillComponent extends DocumentBasedComp
   }
 };
 
-// src/hexagon/domain/services/compileService.ts
-function compile(charter, agents) {
-  return {
-    // A header nobody wrote is left out rather than listed as nothing: a
-    // listing says what the author declared. `file` is where the body sits
-    // inside the workspace — a vendored primitive reads as
-    // `.cw/vendor/<name>/...`, which is where it is.
-    catalogue: Catalogue.of(
-      charter.primitives.map((one) => {
-        const { id, description, tags, globs, rationale, mixins } = one.primitive.headers;
-        return {
-          identity: one.identity,
-          kind: one.primitive.kind,
-          id,
-          description,
-          file: one.file,
-          ...tags === void 0 ? {} : { tags },
-          ...globs === void 0 ? {} : { globs },
-          ...rationale === void 0 ? {} : { rationale },
-          ...mixins === void 0 ? {} : { mixins }
-        };
-      })
-    ),
-    charterMd: CharterMd.of(PRIMITIVE_CLASSES),
-    providerComponents: agents.flatMap((agent) => forAgent(agent, charter))
-  };
-}
-function forAgent(agent, charter) {
-  switch (agent) {
-    case "claude":
-      return compileClaude(charter);
+// src/hexagon/domain/models/output/providers/claude/ClaudeComponent.ts
+var CLAUDE_COMPONENT_CLASSES = [
+  ClaudeAgentComponent,
+  ClaudeSkillComponent,
+  ClaudeSettingsComponent,
+  ClaudeMcpConfigComponent,
+  ClaudeRuleComponent
+];
+var CLAUDE_COMPONENT_KINDS = Object.freeze(CLAUDE_COMPONENT_CLASSES.map((one) => one.kind));
+function claudeDocumentComponentOf(sc, compiledFile, agentTools) {
+  const name = sc.normIdentity;
+  const compiledFromClaudeFolder = `../../${compiledFile}`;
+  const pointerTo = (path) => `Read and follow @${path}.
+`;
+  switch (sc.primitive.kind) {
+    // A guide is a rule this host loads into context whole: when a file it names
+    // is touched, which is what `paths` on a rule does, and at the start of every
+    // session where it names none (FR-013). Under the identity it is changed by,
+    // so a reader who wants it changed is sent to the primitive rather than
+    // editing what the next build overwrites (FR-017, FR-020).
+    case GuidePrimitive.kind: {
+      const { globs = [] } = sc.primitive.headers;
+      return ClaudeRuleComponent.of(name, globs.length === 0 ? {} : { paths: globs }, `@${compiledFromClaudeFolder}
+`);
+    }
+    case AgentPrimitive.kind: {
+      const { tools } = sc.primitive.headers;
+      return ClaudeAgentComponent.of(name, { description: sc.primitive.description(), tools: (agentTools ?? tools).join(", ") }, pointerTo(compiledFromClaudeFolder));
+    }
+    // One kind of this host for the two the charter loads when the request calls
+    // for them: what decides that the body is worth opening is the description,
+    // because that line is all this host reads before deciding (FR-013), and
+    // composing it is the primitive's.
+    case SkillPrimitive.kind:
+    case PlaybookPrimitive.kind:
+      return ClaudeSkillComponent.of(name, { description: sc.primitive.description() }, pointerTo(`../${compiledFromClaudeFolder}`));
+    default:
+      return void 0;
   }
 }
-function compileClaude(charter) {
+
+// src/hexagon/domain/services/providers/claude.ts
+function compileForClaude(charter, compiledPrimitives, shortStrings) {
+  const isSettingComponent = (one) => one.primitive.kind === PosturePrimitive.kind || one.primitive.kind === SensorPrimitive.kind;
   const asSettings = charter.primitives.filter(isSettingComponent);
   const asDocuments = charter.primitives.filter((one) => !isSettingComponent(one));
+  const toolsByMcpIdentity = new Map(
+    charter.primitives.flatMap(({ identity, primitive }) => primitive instanceof McpPrimitive ? [[identity, primitive.headers.tools]] : [])
+  );
+  const agentToolsOf = (agent) => agent.headers.tools.flatMap((tool) => {
+    const [, mcpIdentity, mcpTool] = tool.match(MCP_TOOL_REFERENCE) ?? [];
+    if (mcpIdentity === void 0) return [tool];
+    return (mcpTool === void 0 ? toolsByMcpIdentity.get(mcpIdentity) ?? [] : [mcpTool]).map(
+      (oneTool) => `mcp__${ClaudeMcpConfigComponent.cwMcpName}__${shortStrings[mcpIdentity]}__${oneTool}`
+    );
+  });
   return [
     ...asSettings.length === 0 ? [] : [ClaudeSettingsComponent.of(claudeSettingsOf(asSettings))],
-    ...asDocuments.flatMap((one) => claudeDocumentComponentOf(charter, one) ?? [])
+    ClaudeMcpConfigComponent.of(),
+    ...asDocuments.flatMap(
+      (one) => claudeDocumentComponentOf(
+        one,
+        compiledPrimitives.find((compiled) => compiled.identity === one.identity).file,
+        one.primitive instanceof AgentPrimitive ? agentToolsOf(one.primitive) : void 0
+      ) ?? []
+    )
   ];
 }
-function isSettingComponent(one) {
-  return one.primitive.kind === PosturePrimitive.kind || one.primitive.kind === SensorPrimitive.kind;
-}
 function claudeSettingsOf(ones) {
   const allow = /* @__PURE__ */ new Set();
   const deny = /* @__PURE__ */ new Set();
@@ -3220,46 +3636,126 @@ function claudeSettingsOf(ones) {
     ...Object.keys(hooks).length === 0 ? {} : { hooks }
   };
 }
-function claudeDocumentComponentOf(charter, sc) {
-  const name = claudeNameOf(sc);
-  const body = charter.bodyOf(sc);
-  switch (sc.primitive.kind) {
-    // A guide is a rule this host loads into context whole: when a file it names
-    // is touched, which is what `paths` on a rule does, and at the start of every
-    // session where it names none (FR-013). Under the identity it is changed by,
-    // so a reader who wants it changed is sent to the primitive rather than
-    // editing what the next build overwrites (FR-017, FR-020).
-    case GuidePrimitive.kind: {
-      const { globs = [] } = sc.primitive.headers;
-      return ClaudeRuleComponent.of(
-        name,
-        globs.length === 0 ? {} : { paths: globs },
-        `${[`## ${sc.identity}`, body].join("\n\n")}
-`
-      );
-    }
-    // Named by the identifier alone, because the filename is what someone types
-    // after the slash: this host keeps commands in a directory of their own, so
-    // no other kind can land beside one and the kind would only be typed twice.
-    case CommandPrimitive.kind:
-      return ClaudeCommandComponent.of(sc.primitive.headers.id, { description: sc.primitive.description() }, body);
-    case AgentPrimitive.kind: {
-      const { tools } = sc.primitive.headers;
-      return ClaudeAgentComponent.of(name, { description: sc.primitive.description(), tools: tools.join(", ") }, body);
-    }
-    // One kind of this host for the two the charter loads when the request calls
-    // for them: what decides that the body is worth opening is the description,
-    // because that line is all this host reads before deciding (FR-013), and
-    // composing it is the primitive's.
-    case SkillPrimitive.kind:
-    case PlaybookPrimitive.kind:
-      return ClaudeSkillComponent.of(name, { description: sc.primitive.description() }, body);
-    default:
-      return void 0;
+function claudeComponentProjection(one) {
+  const projectionPolicy = one.projection;
+  switch (one.kind) {
+    case ClaudeAgentComponent.kind:
+      return { path: `${CLAUDE_DIRECTORY}/agents/${one.name}.md`, contents: one.toStampedDocument(), projectionPolicy };
+    // A skill is a directory holding one file of that name, which is where this
+    // host looks for it.
+    case ClaudeSkillComponent.kind:
+      return {
+        path: `${CLAUDE_DIRECTORY}/skills/${one.name}/SKILL.md`,
+        contents: one.toStampedDocument(),
+        projectionPolicy
+      };
+    // A rule of its own file, under the directory this host loads every one of:
+    // at the start of a session where it declares no `paths`, and when one of
+    // them is touched where it does.
+    case ClaudeRuleComponent.kind:
+      return { path: `${CLAUDE_DIRECTORY}/rules/${one.name}.md`, contents: one.toStampedDocument(), projectionPolicy };
+    // Every posture and every sensor of the charter lands in the one file this
+    // host reads its settings from.
+    case ClaudeSettingsComponent.kind:
+      return {
+        path: `${CLAUDE_DIRECTORY}/settings.json`,
+        contents: `${JSON.stringify(one.settings, void 0, 2)}
+`,
+        projectionPolicy
+      };
+    // The one server reaching every place, in the file this host starts a
+    // project's servers from (FR-146).
+    case ClaudeMcpConfigComponent.kind:
+      return {
+        path: CLAUDE_MCP_CONFIG_FILE,
+        contents: `${JSON.stringify({ mcpServers: one.mcpServers }, void 0, 2)}
+`,
+        projectionPolicy
+      };
   }
 }
-function claudeNameOf(one) {
-  return one.identity.replace(/[:/]/g, "-");
+
+// src/hexagon/domain/services/compileService.ts
+function compile(charter, agents) {
+  const shortStrings = shortenStringsOf(
+    charter.primitives.filter(({ primitive }) => primitive.kind === McpPrimitive.kind).map((one) => one.identity)
+  );
+  const compiledPrimitives = charter.primitives.map(
+    (one) => CompiledPrimitive.of(
+      one,
+      one.primitive.toMarkdown({
+        // A mixin nothing answers to is left out: the charter already names
+        // that file as an error, and a build refused for it never reaches
+        // here (FR-009).
+        mixins: charter.mixinsOf(one).flatMap(({ primitive }) => primitive.kind === MixinPrimitive.kind ? [primitive] : []),
+        // Each place the body names as `mcp:<id>` written as the name its
+        // tools are served under, `<name>__<tool>`, which every host's name for
+        // them holds whatever it puts before it (FR-147). A name no mcp
+        // answers to has none and is left as written; the charter has warned
+        // about it (FR-143).
+        idReplacer: (body) => body.replace(MCP_MENTION, (identity) => shortStrings[identity] ?? identity)
+      })
+    )
+  );
+  return {
+    // What an agent opens from the catalogue is the primitive as it compiled,
+    // not the file its author wrote: the whole body in one place, under the
+    // output folder whichever layer brought it (FR-140). The catalogue is where
+    // this path is said; the projection reads it from there.
+    catalogue: catalogueOf(charter, (one) => compiledPrimitives.find((compiled) => compiled.identity === one.identity).file),
+    charterMd: CharterMd.of(PRIMITIVE_CLASSES),
+    compiledPrimitives,
+    mcpOrigins: mcpOriginsOf(charter, shortStrings),
+    providerComponents: agents.flatMap((agent) => compileForAgent(agent, charter, compiledPrimitives, shortStrings))
+  };
+}
+function catalogueOf(charter, fileOf) {
+  return Catalogue.of(
+    charter.primitives.map((one) => {
+      const { id, description, tags, globs, rationale, mixins } = one.primitive.headers;
+      return {
+        identity: one.identity,
+        kind: one.primitive.kind,
+        id,
+        description,
+        file: fileOf(one),
+        ...tags === void 0 ? {} : { tags },
+        ...globs === void 0 ? {} : { globs },
+        ...rationale === void 0 ? {} : { rationale },
+        ...mixins === void 0 ? {} : { mixins }
+      };
+    })
+  );
+}
+function mcpOriginsOf(charter, shortStrings) {
+  const mcpsByKey = /* @__PURE__ */ new Map();
+  for (const { identity, primitive } of [...charter.primitives].sort((one, another) => one.identity < another.identity ? -1 : 1)) {
+    if (primitive.kind !== McpPrimitive.kind) continue;
+    const key = `${primitive.address}
+${primitive.headers.path ?? ""}`;
+    mcpsByKey.set(key, [...mcpsByKey.get(key) ?? [], { identity, primitive }]);
+  }
+  return [...mcpsByKey.entries()].sort(([oneKey], [anotherKey]) => oneKey < anotherKey ? -1 : 1).map(([, mcpsAtOrigin]) => {
+    const [firstMcp] = mcpsAtOrigin;
+    const { endpoint, command, args = [], path } = firstMcp.primitive.headers;
+    const tokenEnv = mcpsAtOrigin.find((one) => one.primitive.headers.tokenEnv !== void 0)?.primitive.headers.tokenEnv;
+    const auths = new Set(mcpsAtOrigin.flatMap((one) => one.primitive.headers.auth ?? []));
+    return {
+      identities: mcpsAtOrigin.map((one) => one.identity),
+      names: Object.fromEntries(mcpsAtOrigin.map((one) => [one.identity, shortStrings[one.identity]])),
+      address: firstMcp.primitive.address,
+      ...endpoint === void 0 ? {} : { endpoint },
+      ...command === void 0 ? {} : { command: { command, args, ...tokenEnv === void 0 ? {} : { tokenEnv } } },
+      ...path === void 0 ? {} : { path },
+      auth: MCP_AUTHS.filter((auth2) => auths.has(auth2))
+    };
+  });
+}
+function compileForAgent(agent, charter, compiledPrimitives, shortStrings) {
+  switch (agent) {
+    case "claude":
+      return compileForClaude(charter, compiledPrimitives, shortStrings);
+  }
 }
 
 // src/hexagon/domain/services/projectionService.ts
@@ -3282,13 +3778,27 @@ function charterOutputProjection(output, agentProviders) {
 `,
       projectionPolicy: output.catalogue.projection
     },
+    // Indented for the reason the full listing is: committed, and read in
+    // diffs when a place moves (SC-038).
+    {
+      path: `${OUT_DIRECTORY}/mcp-origins.json`,
+      contents: `${JSON.stringify({ origins: output.mcpOrigins }, void 0, 2)}
+`,
+      projectionPolicy: "replace"
+    },
     {
       path: `${OUT_DIRECTORY}/CHARTER.md`,
       contents: output.charterMd.toStampedDocument(),
       projectionPolicy: output.charterMd.projection
     },
+    // Each primitive lands where the catalogue sends an agent for it, so the
+    // file named and the file written are one (FR-140).
+    ...output.catalogue.full.flatMap(({ identity, file }) => {
+      const compiledPrimitive = output.compiledPrimitives.find((one) => one.identity === identity);
+      return compiledPrimitive === void 0 ? [] : [{ path: file, contents: compiledPrimitive.toStampedDocument(), projectionPolicy: compiledPrimitive.projection }];
+    }),
     ...agentProviders.map(entryFileProjection),
-    ...output.providerComponents.map(componentProjection)
+    ...output.providerComponents.map(claudeComponentProjection)
   ];
 }
 function entryFileProjection(provider) {
@@ -3308,37 +3818,6 @@ ${[
   }
   return { path, contents, projectionPolicy: "upsertWithMarker" };
 }
-function componentProjection(one) {
-  const projectionPolicy = one.projection;
-  switch (one.kind) {
-    case ClaudeCommandComponent.kind:
-      return { path: `${CLAUDE_DIRECTORY}/commands/${one.name}.md`, contents: one.toStampedDocument(), projectionPolicy };
-    case ClaudeAgentComponent.kind:
-      return { path: `${CLAUDE_DIRECTORY}/agents/${one.name}.md`, contents: one.toStampedDocument(), projectionPolicy };
-    // A skill is a directory holding one file of that name, which is where this
-    // host looks for it.
-    case ClaudeSkillComponent.kind:
-      return {
-        path: `${CLAUDE_DIRECTORY}/skills/${one.name}/SKILL.md`,
-        contents: one.toStampedDocument(),
-        projectionPolicy
-      };
-    // A rule of its own file, under the directory this host loads every one of:
-    // at the start of a session where it declares no `paths`, and when one of
-    // them is touched where it does.
-    case ClaudeRuleComponent.kind:
-      return { path: `${CLAUDE_DIRECTORY}/rules/${one.name}.md`, contents: one.toStampedDocument(), projectionPolicy };
-    // Every posture and every sensor of the charter lands in the one file this
-    // host reads its settings from.
-    case ClaudeSettingsComponent.kind:
-      return {
-        path: `${CLAUDE_DIRECTORY}/settings.json`,
-        contents: `${JSON.stringify(one.settings, void 0, 2)}
-`,
-        projectionPolicy
-      };
-  }
-}
 
 // src/hexagon/service/buildService.ts
 async function plan(repo, charter, agentProviders, fileReaders) {
@@ -3360,10 +3839,19 @@ async function planForProjection(repo, output, agentProviders, fileReaders) {
         break;
       // What the repository set for itself is read and written back: the fields
       // this charter speaks for are put over the top of it, and every other one
-      // is theirs and comes through untouched (FR-018).
+      // is theirs and comes through untouched (FR-018). Field by field at every
+      // depth, so an entry of the repository's beside the charter's under one
+      // key — a server of its own under `mcpServers` — stays (FR-146); a list
+      // or a value is the charter's whole, so what it no longer asks for goes.
       case "mergeJSON": {
-        const already = JSON.parse(held?.trim() || "{}");
-        contents = `${JSON.stringify({ ...already, ...JSON.parse(one.contents) }, void 0, 2)}
+        const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+        const mergedJSON = (already, written) => isPlainObject(already) && isPlainObject(written) ? Object.fromEntries(
+          [.../* @__PURE__ */ new Set([...Object.keys(already), ...Object.keys(written)])].map((field) => [
+            field,
+            field in written ? mergedJSON(already[field], written[field]) : already[field]
+          ])
+        ) : written;
+        contents = `${JSON.stringify(mergedJSON(JSON.parse(held?.trim() || "{}"), JSON.parse(one.contents)), void 0, 2)}
 `;
         break;
       }
@@ -3426,7 +3914,7 @@ async function executePlan(cleanupPlan, projectionPlan, fileWriter2) {
     await Promise.all(cleanupPlan.map((one) => fileWriter2.delete(one.file)));
     for (const one of projectionPlan) await fileWriter2.write(one.file, one.contents ?? "");
   } catch (raised) {
-    throw new Fault(
+    throw new DomainFault(
       `This build could not be written: ${raised instanceof Error ? raised.message : String(raised)}`,
       "Check that the files this build writes can be written, then build again."
     );
@@ -3499,11 +3987,10 @@ var CharterAuthoring = class {
    * What the charter holds, listed, narrowed to one kind where one is named
    * (FR-011, FR-012).
    *
-   * The listing is the one the charter compiles to, asked for the way everything
-   * else is: `compile` hands back everything one reading produces, and this
-   * takes the listing out of it (SC-004). No agent is named, since what an agent
-   * reads is not what is being asked for here — a repository that compiles for
-   * none still lists what it holds.
+   * Read off the charter, not off what it compiles to: a person is shown the
+   * file each primitive was authored in, which is the one they would edit and
+   * what says which layer it came from, where the catalogue a build writes sends
+   * an agent to the compiled one (FR-140).
    *
    * Whether the word narrowing it is a kind at all is asked here, of the
    * domain that holds the set. A caller passes on what was typed and knows
@@ -3514,10 +4001,10 @@ var CharterAuthoring = class {
    */
   async list(kind) {
     if (kind !== void 0 && !isKind(kind))
-      throw new Fault(`"${kind}" is not a kind the charter knows.`, `Ask for one the charter knows: ${KINDS.join(", ")}.`);
+      throw new DomainFault(`"${kind}" is not a kind the charter knows.`, `Ask for one the charter knows: ${KINDS.join(", ")}.`);
     const [charter, , faultsByFiles] = await this.#read();
     if (charter === void 0) return faultsByFileDTO(faultsByFiles.errors(), this.#repoPath);
-    const { catalogue: catalogue2 } = compile(charter, []);
+    const catalogue2 = catalogueOf(charter, (one) => one.file);
     return catalogueDTO(kind === void 0 ? catalogue2 : catalogue2.filterByKind(kind));
   }
   /** Every primitive the charter read, or those mentioning a word, each as the
@@ -3552,7 +4039,7 @@ var CharterAuthoring = class {
     if (charter === void 0) return faultsByFileDTO(faultsByFiles.errors(), this.#repoPath);
     const declared = charter.primitiveById.get(primitiveIdentity);
     if (declared === void 0)
-      throw new Fault(
+      throw new DomainFault(
         `This charter holds no "${identity}".`,
         'Run "cw list --min" to see every identity it does hold.'
       );
@@ -3692,7 +4179,7 @@ var CharterAuthoring = class {
     const charter = await loadCharterRoot(this.#repoPath, this.#fileReader, this.#yamlParser);
     const claimingPrimitive = charter.primitiveById.get(identityOf({ kind, id }));
     if (claimingPrimitive !== void 0)
-      throw new Fault(
+      throw new DomainFault(
         `"${identityOf({ kind, id })}" is already there, declared by ${claimingPrimitive.file}, and one identity names one primitive in the whole charter.`,
         `Open ${claimingPrimitive.file}, or run this again with an id this charter has not got.`
       );
@@ -3729,12 +4216,12 @@ var CharterAuthoring = class {
   async rewrite(identity, headers, body, revision) {
     const scopedPrimitive2 = await this.#scopedPrimitiveOf(identity);
     if (!RepoScopedPrimitive.isSatisfiedBy(scopedPrimitive2))
-      throw new Fault(
+      throw new DomainFault(
         `${identity} was not authored in this repository, and ${scopedPrimitive2.file} is read-only here.`,
         `To differ from it, author a primitive of your own under an identity of its own.`
       );
     if (await contentHashOf(scopedPrimitive2.primitive.toMarkdown()) !== revision)
-      throw new Fault(
+      throw new DomainFault(
         `${scopedPrimitive2.file} changed on disk after it was opened, and saving would write over that change.`,
         `Open it again to see what changed, then make your edit there.`
       );
@@ -3762,7 +4249,7 @@ var CharterAuthoring = class {
   async remove(identity) {
     const scopedPrimitive2 = await this.#scopedPrimitiveOf(identity);
     if (!RepoScopedPrimitive.isSatisfiedBy(scopedPrimitive2))
-      throw new Fault(
+      throw new DomainFault(
         `${identity} was not authored in this repository, and ${scopedPrimitive2.file} is read-only here.`,
         `To differ from it, author a primitive of your own under an identity of its own.`
       );
@@ -3777,7 +4264,7 @@ var CharterAuthoring = class {
     const charter = await loadCharterRoot(this.#repoPath, this.#fileReader, this.#yamlParser);
     const scopedPrimitive2 = charter.primitiveById.get(primitiveIdentity);
     if (scopedPrimitive2 === void 0)
-      throw new Fault(
+      throw new DomainFault(
         `This charter holds no "${identity}".`,
         'Run "cw list --min" to see every identity it does hold.'
       );
@@ -3788,7 +4275,7 @@ var CharterAuthoring = class {
    *  every kind there is. */
   #kindOf(kind) {
     if (!isKind(kind))
-      throw new Fault(`"${kind}" is not a kind the charter knows.`, `Ask for one the charter knows: ${KINDS.join(", ")}.`);
+      throw new DomainFault(`"${kind}" is not a kind the charter knows.`, `Ask for one the charter knows: ${KINDS.join(", ")}.`);
     return kind;
   }
   /** What this repository configured itself with, read the one way settings are
@@ -3804,12 +4291,12 @@ var CharterAuthoring = class {
    */
   async ensureRepoReady() {
     if (!await this.#vcs.isInstalled(this.#repoPath))
-      throw new Fault(
+      throw new DomainFault(
         "This folder is not inside a git repository, and a charter is authored inside one.",
         'Run "git init" here, then "cw init", or run this again where your repository is.'
       );
     if (await this.#fileReader.readIfThere(settingsFileIn(this.#repoPath)) === void 0)
-      throw new Fault("This repository was never set up under a charter.", 'Run "cw init" first.');
+      throw new DomainFault("This repository was never set up under a charter.", 'Run "cw init" first.');
   }
   /**
    * One repository, set up under a charter (FR-032, FR-037).
@@ -3823,10 +4310,10 @@ var CharterAuthoring = class {
    * agent it runs reads (FR-033).
    *
    * Then the two things setup owns — what the repository configured itself
-   * with, and a directory per kind for a charter to be authored in — and
-   * nothing more: compiling is `build`'s, run once there is a charter to
-   * compile (FR-037). What comes back is that it is set up; what stops it is
-   * raised.
+   * with, and a directory per kind for a charter to be authored in — and a
+   * build over them, so the skill the engine brings is in the agent's hands
+   * before anything is authored (FR-057, FR-096). What comes back is what that
+   * build did, or what refused it; what stops setup itself is raised.
    *
    * Nothing is written into an ignore file: everything under the workspace is
    * committed, what a vendor installed included, so a checkout of this
@@ -3839,12 +4326,12 @@ var CharterAuthoring = class {
    */
   async init({ agents }) {
     if (!await this.#vcs.isInstalled(this.#repoPath))
-      throw new Fault(
+      throw new DomainFault(
         "This folder is not inside a git repository, and a charter is authored inside one.",
         'Run "git init" here, or run this again where your repository is.'
       );
     if (agents.length === 0)
-      throw new Fault(
+      throw new DomainFault(
         "Setup was given no agent to compile for, and a charter compiles for at least one.",
         `Choose at least one of: ${AGENT_PROVIDERS.join(", ")}.`
       );
@@ -3852,7 +4339,7 @@ var CharterAuthoring = class {
 `);
     const kindFolders = KINDS.map((kind) => `${CHARTER_DIRECTORY}/${kind}/.gitkeep`);
     for (const path of kindFolders) await this.#fileWriter.write(new URL(path, this.#repoPath), "");
-    return true;
+    return this.build();
   }
 };
 
@@ -3903,6 +4390,275 @@ var TestAuthoring = class {
   }
 };
 
+// src/hexagon/service/credentialRepo.ts
+async function readCredential(secrets2, address) {
+  const secret = await secrets2.readSecret(address);
+  if (secret === void 0) return void 0;
+  try {
+    const credential = JSON.parse(secret);
+    return typeof credential?.accessToken === "string" ? credential : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function writeCredential(secrets2, credential) {
+  await secrets2.writeSecret(credential.address, JSON.stringify(credential));
+}
+async function credentialFor(secrets2, authorizing2, origin, { refused = false } = {}) {
+  if (origin.endpoint !== void 0 && !isSecureEndpoint(origin.endpoint))
+    throw new DomainFault(`${origin.address} is plain http to another machine, so no credential is sent there.`, 'Declare its endpoint as https://, then run "cw build".');
+  const signInAgain = `Run "cw mcp auth ${origin.identities[0] ?? ""}" at a terminal to sign in there.`;
+  const credential = await readCredential(secrets2, origin.address);
+  if (credential === void 0) throw new DomainFault(`You are not signed in to ${origin.address}.`, signInAgain);
+  const expired = refused || credential.expiresAt !== void 0 && Date.parse(credential.expiresAt) <= Date.now();
+  if (!expired) return credential.accessToken;
+  const { address, method, client, ...tokens } = credential;
+  const renewedGrant = origin.endpoint !== void 0 && client !== void 0 && tokens.refreshToken !== void 0 ? await authorizing2.renew(origin.endpoint, { ...tokens, client }) : void 0;
+  if (renewedGrant === void 0)
+    throw new DomainFault(`Your sign-in to ${address} has expired and could not be renewed.`, signInAgain);
+  await writeCredential(secrets2, { address, method, ...renewedGrant });
+  return renewedGrant.accessToken;
+}
+
+// src/hexagon/service/mcpOriginsRepo.ts
+async function loadMcpOrigins(repo, fileReader2) {
+  const file = `${OUT_DIRECTORY}/mcp-origins.json`;
+  const contents = await fileReader2.readIfThere(new URL("mcp-origins.json", outFolderIn(repo)));
+  if (contents === void 0)
+    throw new DomainFault(`There is no ${file}, so no place has been listed yet.`, 'Run "cw build" first.');
+  try {
+    const mcpOriginsJson = JSON.parse(contents);
+    const origins = mcpOriginsJson.origins;
+    if (Array.isArray(origins)) return origins;
+  } catch {
+  }
+  throw new DomainFault(`${file} does not hold a list of places.`, 'Run "cw build" to write it again.');
+}
+async function loadMcpTools(repo, fileReader2, yamlParser2) {
+  const contents = await fileReader2.readIfThere(new URL("catalog.json", outFolderIn(repo)));
+  let catalogEntries = [];
+  try {
+    const catalogJson = JSON.parse(contents ?? "[]");
+    if (Array.isArray(catalogJson)) catalogEntries = catalogJson;
+  } catch {
+  }
+  const toolsByIdentity = /* @__PURE__ */ new Map();
+  for (const { identity, kind, file } of catalogEntries) {
+    if (kind !== McpPrimitive.kind || typeof identity !== "string" || typeof file !== "string") continue;
+    const compiledDocument = await fileReader2.readIfThere(new URL(file, repo));
+    if (compiledDocument === void 0) continue;
+    try {
+      const primitive = primitiveOf(compiledDocument, yamlParser2);
+      if (primitive instanceof McpPrimitive) toolsByIdentity.set(identity, primitive.headers.tools);
+    } catch {
+    }
+  }
+  return toolsByIdentity;
+}
+
+// src/hexagon/port/zdriven/DrivenFault.ts
+var DrivenFault = class extends DomainFault {
+};
+
+// src/hexagon/port/zdriven/ForCallingMcpServers.ts
+var UnauthorizedMcpFault = class extends DrivenFault {
+};
+
+// src/hexagon/application/McpConnecting.ts
+var CONNECT_TIMEOUT_MS = 1e4;
+var errorAnswerOf = (text) => ({
+  type: "ToolAnswer",
+  data: { content: [{ type: "text", text }], isError: true }
+});
+var McpConnecting = class {
+  #repoPath;
+  #fileReader;
+  #secrets;
+  #authorizing;
+  #yamlParser;
+  #mcpServers;
+  #mcpServing;
+  constructor(repoPath2, fileReader2, secrets2, authorizing2, yamlParser2, mcpServers2) {
+    this.#repoPath = repoPath2;
+    this.#fileReader = fileReader2;
+    this.#secrets = secrets2;
+    this.#authorizing = authorizing2;
+    this.#yamlParser = yamlParser2;
+    this.#mcpServers = mcpServers2;
+  }
+  async signInStatus() {
+    return Promise.all(
+      (await this.#signInAddresses()).map(async ({ address, identities, auth: auth2 }) => {
+        const credential = await readCredential(this.#secrets, address);
+        return {
+          type: "SignInStatus",
+          data: { address, identities, auth: auth2, signedIn: credential !== void 0, ...credential && { method: credential.method } }
+        };
+      })
+    );
+  }
+  async signInWithToken(address, token) {
+    await this.#addressTaking(address, "token");
+    if (token.trim() === "") throw new DomainFault(`No token was given for ${address}, so nothing was kept.`, 'Run "cw mcp auth" again and paste the token.');
+    await writeCredential(this.#secrets, { address, method: "token", accessToken: token });
+  }
+  async signInWithOAuth(address, showAuthorizationUrl) {
+    await this.#addressTaking(address, "oauth");
+    const oauthGrant = await this.#authorizing.authorize(address, showAuthorizationUrl);
+    await writeCredential(this.#secrets, { address, method: "oauth", ...oauthGrant });
+  }
+  async served() {
+    return (await this.#serving()).servedTools;
+  }
+  async call(name, args) {
+    const { toolRoutes, unreachableTools } = await this.#serving();
+    const toolRoute = toolRoutes.get(name);
+    if (toolRoute === void 0)
+      return errorAnswerOf(unreachableTools.get(name) ?? `"${name}" is not a tool this server serves; call one it listed.`);
+    const { origin, identity, upstream, connection } = toolRoute;
+    const signInAgain = `${origin.address} refused your credential. Run "cw mcp auth ${identity}" at a terminal to sign in there again.`;
+    const accessTokenOf = (refused) => origin.endpoint === void 0 ? Promise.resolve(void 0) : credentialFor(this.#secrets, this.#authorizing, origin, { refused });
+    try {
+      try {
+        return { type: "ToolAnswer", data: await connection.callTool(upstream, args, await accessTokenOf(false)) };
+      } catch (raised) {
+        if (!(raised instanceof UnauthorizedMcpFault)) throw raised;
+        const renewedToken = await accessTokenOf(true).catch(() => void 0);
+        if (renewedToken === void 0) return errorAnswerOf(signInAgain);
+        return { type: "ToolAnswer", data: await connection.callTool(upstream, args, renewedToken) };
+      }
+    } catch (raised) {
+      if (raised instanceof UnauthorizedMcpFault) return errorAnswerOf(signInAgain);
+      if (raised instanceof DomainFault) return errorAnswerOf(`${raised.message} ${raised.fix}`);
+      throw raised;
+    }
+  }
+  async stopServing() {
+    if (this.#mcpServing === void 0) return;
+    const { connections } = await this.#mcpServing;
+    await Promise.all(connections.map((connection) => connection.close()));
+  }
+  /**
+   * Every place the last build listed, reached at once and once per run
+   * (FR-152). What each lists is kept where one of its identities
+   * declares it, renamed `<prefix>__<tool>`; a place down or not signed in to,
+   * and a declared tool its place lacks, is said and left out, and the rest
+   * are served (FR-153, FR-154, SC-039).
+   */
+  #serving() {
+    this.#mcpServing ??= (async () => {
+      const origins = await loadMcpOrigins(this.#repoPath, this.#fileReader);
+      const toolsByIdentity = await loadMcpTools(this.#repoPath, this.#fileReader, this.#yamlParser);
+      const problems = [];
+      const servedTools2 = [];
+      const toolRoutes = /* @__PURE__ */ new Map();
+      const unreachableTools = /* @__PURE__ */ new Map();
+      const connections = [];
+      const reachedPlaces = await Promise.all(
+        origins.map(async (origin) => {
+          try {
+            const accessToken = origin.auth.length > 0 ? await credentialFor(this.#secrets, this.#authorizing, origin) : void 0;
+            return { origin, connection: await this.#mcpServers.connect(origin, accessToken, CONNECT_TIMEOUT_MS) };
+          } catch (raised) {
+            if (!(raised instanceof DomainFault)) throw raised;
+            return { origin, reason: `${raised.message} ${raised.fix}` };
+          }
+        })
+      );
+      for (const { origin, connection, reason } of reachedPlaces) {
+        if (connection !== void 0) connections.push(connection);
+        else problems.push(`${origin.identities.join(", ")}: ${reason}`);
+        for (const identity of origin.identities) {
+          const declaredTools = toolsByIdentity.get(identity);
+          if (declaredTools === void 0) {
+            problems.push(`${identity} has no compiled document under .cw/out/, so none of its tools is served. Run "cw build".`);
+            continue;
+          }
+          const identityName = origin.names?.[identity];
+          if (identityName === void 0) {
+            problems.push(`${identity} has no served name in .cw/out/mcp-origins.json, so none of its tools is served. Run "cw build" again.`);
+            continue;
+          }
+          for (const tool of declaredTools) {
+            const servedName = `${identityName}__${tool}`;
+            if (connection === void 0) {
+              unreachableTools.set(servedName, reason ?? "");
+              continue;
+            }
+            const upstreamTool = connection.tools.find(({ name }) => name === tool);
+            if (upstreamTool === void 0) {
+              problems.push(`${identity} declares "${tool}", which ${origin.address} does not have; it is not served.`);
+              continue;
+            }
+            const placeName = origin.path === void 0 ? identity : `${identity} \u2014 ${origin.path}`;
+            servedTools2.push({
+              type: "ServedTool",
+              data: {
+                name: servedName,
+                description: `[${placeName}] ${upstreamTool.description ?? ""}`.trimEnd(),
+                inputSchema: upstreamTool.inputSchema
+              }
+            });
+            toolRoutes.set(servedName, { origin, identity, upstream: tool, connection });
+          }
+        }
+      }
+      return {
+        servedTools: {
+          type: "ServedTools",
+          data: { tools: servedTools2.sort((one, other) => one.data.name.localeCompare(other.data.name)), problems }
+        },
+        toolRoutes,
+        unreachableTools,
+        connections
+      };
+    })();
+    return this.#mcpServing;
+  }
+  /**
+   * Every address a developer signs in to, once, ordered by address (plan
+   * §19.5): one address is one account at one service, whatever path each
+   * place there names. A local command taking no token signs in to nothing and
+   * is left out.
+   */
+  async #signInAddresses() {
+    const origins = await loadMcpOrigins(this.#repoPath, this.#fileReader);
+    const addresses = /* @__PURE__ */ new Map();
+    for (const { address, endpoint, identities, auth: auth2 } of origins.filter((one) => one.auth.length > 0)) {
+      const signInAddress = addresses.get(address) ?? { ...endpoint !== void 0 && { endpoint }, identities: /* @__PURE__ */ new Set(), auth: /* @__PURE__ */ new Set() };
+      identities.forEach((identity) => signInAddress.identities.add(identity));
+      auth2.forEach((method) => signInAddress.auth.add(method));
+      addresses.set(address, signInAddress);
+    }
+    return [...addresses].sort(([one], [other]) => one.localeCompare(other)).map(([address, { endpoint, identities, auth: auth2 }]) => ({
+      address,
+      ...endpoint !== void 0 && { endpoint },
+      identities: [...identities].sort(),
+      auth: ["oauth", "token"].filter((method) => auth2.has(method))
+    }));
+  }
+  /** Refused where no place is at this address, or none there allows signing
+   *  in this way: a credential nothing would use is not kept. Refused too where
+   *  the address is plain `http` to another machine, whatever the build said:
+   *  the list is a committed file, and a credential sent there travels in the
+   *  clear. */
+  async #addressTaking(address, method) {
+    const signInAddress = (await this.#signInAddresses()).find((one) => one.address === address);
+    if (signInAddress === void 0)
+      throw new DomainFault(`No place the last build listed is at ${address}.`, 'Run "cw mcp auth --status" to see every address, or "cw build" if the charter changed.');
+    if (signInAddress.endpoint !== void 0 && !isSecureEndpoint(signInAddress.endpoint))
+      throw new DomainFault(
+        `${address} is plain http to another machine, so no credential is sent there.`,
+        'Declare its endpoint as https://, then run "cw build".'
+      );
+    if (!signInAddress.auth.includes(method))
+      throw new DomainFault(
+        `${address} is not signed in to by ${method}; it allows ${signInAddress.auth.join(" or ")}.`,
+        `Sign in there by ${signInAddress.auth.join(" or ")}.`
+      );
+  }
+};
+
 // src/zdriven/FileReaders.ts
 import { readdir, readFile } from "fs/promises";
 var FileReaders = class {
@@ -4053,7 +4809,7 @@ var Git = class {
         { cwd }
       );
     } catch (raised) {
-      throw new Fault(
+      throw new DrivenFault(
         `${raised}`,
         version === void 0 ? "Check the address, and that you can reach it from here." : `Check the address, and that "${version}" is a tag or branch it has.`
       );
@@ -4068,19 +4824,286 @@ var Git = class {
       await run("git", ["rm", "-r", "--quiet", "--", subFolder], { cwd });
       await run("git", ["commit", "-qm", `Remove ${subFolder}`], { cwd });
     } catch (raised) {
-      throw new Fault(`${raised}`, `Check that "${subFolder}" is a folder this repository holds.`);
+      throw new DrivenFault(`${raised}`, `Check that "${subFolder}" is a folder this repository holds.`);
     }
   }
 };
 
+// src/zdriven/OsSecrets.ts
+import { spawn as spawn2 } from "child_process";
+var SERVICE = "cherry-works";
+var MACOS_NOT_FOUND = 44;
+function commandOutput(command, args, stdin = "") {
+  return new Promise((resolve) => {
+    const child = spawn2(command, args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => stdout += chunk);
+    child.stderr.on("data", (chunk) => stderr += chunk);
+    child.on("error", (raised) => resolve({ code: -1, stdout, stderr: `${raised.message}` }));
+    child.on("close", (code) => resolve({ code: code ?? -1, stdout, stderr }));
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(stdin);
+  });
+}
+var OsSecrets = class {
+  /** Which system's store to use: this process's, unless a test names
+   *  another. */
+  constructor(platform = process.platform) {
+    this.platform = platform;
+  }
+  platform;
+  async readSecret(key) {
+    this.refuseUnsupportedPlatform();
+    const commandOutputOfRead = this.platform === "darwin" ? await commandOutput("security", ["find-generic-password", "-s", SERVICE, "-a", key, "-w"]) : await commandOutput("secret-tool", ["lookup", "service", SERVICE, "account", key]);
+    if (commandOutputOfRead.code === 0) return commandOutputOfRead.stdout.replace(/\n$/, "");
+    const nothingThere = this.platform === "darwin" ? commandOutputOfRead.code === MACOS_NOT_FOUND : commandOutputOfRead.stderr.trim() === "";
+    if (nothingThere) return void 0;
+    this.throwFault("read", key, commandOutputOfRead.stderr);
+  }
+  async writeSecret(key, secret) {
+    this.refuseUnsupportedPlatform();
+    if (this.platform === "darwin" && /["\\\n]/.test(key)) {
+      throw new DrivenFault(`The key "${key}" cannot be kept in the keychain.`, "Name the place by an address without quotes, backslashes or line breaks.");
+    }
+    const commandOutputOfWrite = this.platform === "darwin" ? await commandOutput(
+      "security",
+      ["-i"],
+      `add-generic-password -U -s ${SERVICE} -a "${key}" -X ${Buffer.from(secret).toString("hex")}
+`
+    ) : await commandOutput(
+      "secret-tool",
+      ["store", `--label=${SERVICE} ${key}`, "service", SERVICE, "account", key],
+      secret
+    );
+    if (commandOutputOfWrite.code !== 0) this.throwFault("write", key);
+  }
+  async removeSecret(key) {
+    this.refuseUnsupportedPlatform();
+    const commandOutputOfRemove = this.platform === "darwin" ? await commandOutput("security", ["delete-generic-password", "-s", SERVICE, "-a", key]) : await commandOutput("secret-tool", ["clear", "service", SERVICE, "account", key]);
+    if (commandOutputOfRemove.code === 0) return;
+    const nothingThere = this.platform === "darwin" ? commandOutputOfRemove.code === MACOS_NOT_FOUND : commandOutputOfRemove.stderr.trim() === "";
+    if (!nothingThere) this.throwFault("remove", key, commandOutputOfRemove.stderr);
+  }
+  /** macOS and Linux have a store this knows; anything else is refused
+   *  before a command runs. */
+  refuseUnsupportedPlatform() {
+    if (this.platform !== "darwin" && this.platform !== "linux") {
+      throw new DrivenFault(
+        `Keeping a secret is not supported on "${this.platform}".`,
+        "Sign in from macOS or Linux, whose credential stores cw uses."
+      );
+    }
+  }
+  throwFault(operation, key, stderr = "") {
+    const storeName = this.platform === "darwin" ? "The keychain" : "The secret service";
+    throw new DrivenFault(
+      `${storeName} refused to ${operation} the secret for "${key}".${stderr.trim() === "" ? "" : ` It said: ${stderr.trim()}`}`,
+      this.platform === "darwin" ? "Check that the login keychain is unlocked." : "Check that secret-tool is installed and a secret service is running."
+    );
+  }
+};
+
+// src/zdriven/OAuth.ts
+import { randomUUID } from "crypto";
+import { createServer } from "http";
+import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
+import { OAuthError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
+var CALLBACK_TIMEOUT_MS = 5 * 6e4;
+var OAuth = class {
+  #callbackTimeoutMs;
+  constructor(callbackTimeoutMs = CALLBACK_TIMEOUT_MS) {
+    this.#callbackTimeoutMs = callbackTimeoutMs;
+  }
+  async authorize(endpoint, showAuthorizationUrl) {
+    const state = randomUUID();
+    const callbackServer = createServer();
+    await new Promise((resolve, reject) => callbackServer.once("error", reject).listen(0, "127.0.0.1", resolve));
+    const redirectUrl = `http://127.0.0.1:${callbackServer.address().port}/callback`;
+    let callbackTimeout;
+    const authorizationCode = new Promise((resolve, reject) => {
+      callbackTimeout = setTimeout(
+        () => reject(new DrivenFault(`Nobody came back from signing in to ${endpoint} in time.`, 'Run "cw mcp auth" again, and open the address it prints.')),
+        this.#callbackTimeoutMs
+      );
+      callbackServer.on("request", (request, response) => {
+        const callbackUrl = new URL(request.url ?? "/", redirectUrl);
+        if (callbackUrl.pathname !== "/callback") return void response.writeHead(404).end();
+        const callbackCode = callbackUrl.searchParams.get("code");
+        const signedIn = callbackCode !== null && callbackUrl.searchParams.get("state") === state;
+        response.writeHead(200, { "content-type": "text/plain; charset=utf-8" }).end(signedIn ? "Signed in. Go back to the terminal.\n" : "Not signed in. Go back to the terminal.\n");
+        if (signedIn) return resolve(callbackCode);
+        const callbackError = callbackUrl.searchParams.get("error");
+        reject(new DrivenFault(`Signing in to ${endpoint} came back without an authorization${callbackError ? `: ${callbackError}` : ""}.`, 'Run "cw mcp auth" again.'));
+      });
+    });
+    authorizationCode.catch(() => void 0);
+    try {
+      const oauthSession = {};
+      const provider = this.#providerOver(oauthSession, redirectUrl, (authorizationUrl) => showAuthorizationUrl(authorizationUrl.href), state);
+      if (await auth(provider, { serverUrl: endpoint }) === "REDIRECT")
+        await auth(provider, { serverUrl: endpoint, authorizationCode: await authorizationCode });
+      return oauthGrantOf(endpoint, oauthSession);
+    } catch (raised) {
+      if (raised instanceof DrivenFault) throw raised;
+      throw new DrivenFault(
+        `Signing in to ${endpoint} failed: ${raised instanceof Error ? raised.message : String(raised)}`,
+        'Check the address is reachable and offers an OAuth sign-in, then run "cw mcp auth" again.'
+      );
+    } finally {
+      clearTimeout(callbackTimeout);
+      callbackServer.closeAllConnections();
+      callbackServer.close();
+    }
+  }
+  async renew(endpoint, oauthGrant) {
+    const { clientId, clientSecret, issuer } = oauthGrant.client;
+    const oauthSession = {
+      clientInformation: { client_id: clientId, ...clientSecret !== void 0 && { client_secret: clientSecret }, issuer },
+      tokens: {
+        access_token: oauthGrant.accessToken,
+        token_type: "Bearer",
+        ...oauthGrant.refreshToken !== void 0 && { refresh_token: oauthGrant.refreshToken },
+        issuer
+      }
+    };
+    const provider = this.#providerOver(oauthSession, "http://127.0.0.1/callback", () => void 0);
+    try {
+      if (await auth(provider, { serverUrl: endpoint }) === "REDIRECT") return void 0;
+    } catch (raised) {
+      if (raised instanceof OAuthError) return void 0;
+      throw new DrivenFault(
+        `Renewing the sign-in to ${endpoint} failed: ${raised instanceof Error ? raised.message : String(raised)}`,
+        "Check the address is reachable, then try again."
+      );
+    }
+    const renewedGrant = oauthGrantOf(endpoint, oauthSession);
+    return renewedGrant.refreshToken !== void 0 || oauthGrant.refreshToken === void 0 ? renewedGrant : { ...renewedGrant, refreshToken: oauthGrant.refreshToken };
+  }
+  /**
+   * What the SDK's flow is run with: `cw` described as a public client that
+   * signs in at `redirectUrl`, and everything the flow saves kept in this
+   * session. Registering is offered to a sign-in only, where a `state` is
+   * checked on the way back; a renewal presents what the grant was issued to.
+   */
+  #providerOver(oauthSession, redirectUrl, redirectToAuthorization, state) {
+    return {
+      redirectUrl,
+      clientMetadata: {
+        client_name: "cherry-works",
+        redirect_uris: [redirectUrl],
+        grant_types: ["authorization_code", "refresh_token"],
+        response_types: ["code"],
+        token_endpoint_auth_method: "none"
+      },
+      ...state !== void 0 && {
+        state: () => state,
+        saveClientInformation: (clientInformation) => {
+          oauthSession.clientInformation = clientInformation;
+        }
+      },
+      clientInformation: () => oauthSession.clientInformation,
+      tokens: () => oauthSession.tokens,
+      saveTokens: (tokens) => {
+        oauthSession.tokens = tokens;
+      },
+      redirectToAuthorization,
+      saveCodeVerifier: (codeVerifier) => {
+        oauthSession.codeVerifier = codeVerifier;
+      },
+      codeVerifier: () => oauthSession.codeVerifier ?? ""
+    };
+  }
+};
+function oauthGrantOf(endpoint, { clientInformation, tokens }) {
+  if (clientInformation === void 0 || tokens === void 0)
+    throw new DrivenFault(`Signing in to ${endpoint} ended without a token.`, 'Run "cw mcp auth" again.');
+  return {
+    accessToken: tokens.access_token,
+    ...tokens.refresh_token !== void 0 && { refreshToken: tokens.refresh_token },
+    ...tokens.expires_in !== void 0 && { expiresAt: new Date(Date.now() + tokens.expires_in * 1e3).toISOString() },
+    client: {
+      clientId: clientInformation.client_id,
+      ...clientInformation.client_secret !== void 0 && { clientSecret: clientInformation.client_secret },
+      issuer: clientInformation.issuer ?? tokens.issuer ?? endpoint
+    }
+  };
+}
+
+// src/zdriven/McpClients.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport, StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var McpClients = class {
+  async connect({ address, endpoint, command }, accessToken, timeoutMs) {
+    let bearerToken = accessToken;
+    const transport = endpoint !== void 0 ? new StreamableHTTPClientTransport(new URL(endpoint), {
+      fetch: (url, init) => {
+        const headers = new Headers(init?.headers);
+        if (bearerToken !== void 0) headers.set("authorization", `Bearer ${bearerToken}`);
+        return fetch(url, { ...init, headers });
+      }
+    }) : new StdioClientTransport({
+      command: command?.command ?? "",
+      args: [...command?.args ?? []],
+      env: {
+        ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0)),
+        ...command?.tokenEnv !== void 0 && accessToken !== void 0 && { [command.tokenEnv]: accessToken }
+      },
+      stderr: "inherit"
+    });
+    const client = new Client({ name: "cherry-works", version: "1" });
+    let connectTimeout;
+    try {
+      const { tools } = await Promise.race([
+        client.connect(transport).then(() => client.listTools()),
+        new Promise((_resolve, reject) => {
+          connectTimeout = setTimeout(
+            () => reject(new DrivenFault(`${address} did not answer within ${timeoutMs / 1e3} seconds.`, "Check the place is up, then start the server again.")),
+            timeoutMs
+          );
+        })
+      ]);
+      return {
+        tools: tools.map(({ name, description, inputSchema }) => ({ name, ...description !== void 0 && { description }, inputSchema })),
+        callTool: async (name, args, callToken) => {
+          if (endpoint !== void 0) bearerToken = callToken;
+          try {
+            return await client.callTool({ name, arguments: { ...args } });
+          } catch (raised) {
+            throw faultOf(raised, `Calling "${name}" at ${address} failed`, "Check the place is up, then try again.");
+          }
+        },
+        close: () => client.close()
+      };
+    } catch (raised) {
+      await client.close().catch(() => void 0);
+      throw faultOf(raised, `${address} could not be reached`, "Check the place is up, or its command installed, then start the server again.");
+    } finally {
+      clearTimeout(connectTimeout);
+    }
+  }
+};
+function faultOf(raised, failed, fix) {
+  if (raised instanceof DrivenFault) return raised;
+  if (raised instanceof StreamableHTTPError && raised.code === 401)
+    return new UnauthorizedMcpFault(`${failed}: the place refused your credential.`, 'Run "cw mcp auth" at a terminal to sign in there again.');
+  return new DrivenFault(`${failed}: ${raised instanceof Error ? raised.message : String(raised)}`, fix);
+}
+
 // main.ts
 var fileReader = new FileReaders();
 var yamlParser = new YamlParser();
 var fileWriter = new FileOutput();
 var vcs = new Git(fileReader);
+var secrets = new OsSecrets();
+var authorizing = new OAuth();
+var mcpServers = new McpClients();
 var repoPath = pathToFileURL2(`${process.cwd()}/`);
 var charterAuthoringApp = new CharterAuthoring(repoPath, fileReader, yamlParser, fileWriter, vcs);
 var charterVendoringApp = new CharterVendoring(repoPath, fileReader, vcs);
 var testAuthoringApp = new TestAuthoring(repoPath, fileReader, fileWriter);
-var cli = new Commander({ cwd: process.cwd(), version: package_default.version, charterAuthoringApp, charterVendoringApp, testAuthoringApp });
+var mcpConnectingApp = new McpConnecting(repoPath, fileReader, secrets, authorizing, yamlParser, mcpServers);
+var cli = new Commander({ cwd: process.cwd(), version: package_default.version, charterAuthoringApp, charterVendoringApp, testAuthoringApp, mcpConnectingApp });
 process.exitCode = await cli.run(process.argv.slice(2));