@documentation-robotics/cli 0.3.0 → 0.4.0

package/dist/integrations/github_copilot/skills/dr_change_planning/SKILL.md

@@ -23,19 +23,28 @@ graph checks the plan for you. The full design is `docs/CHANGE_MODELING.md` in t
 
 ## Before you start
 
-- You need the `dr` MCP server (`dr mcp`, registered in Copilot's MCP configuration with the
-  `DR_MCP_API_KEY` it prints on start; see `integrations/claude_code/docs/MCP_SERVER.md`). The
+- You need the `dr` MCP server (`dr mcp`, registered in Copilot's MCP configuration; see
+  `integrations/claude_code/docs/MCP_SERVER.md`). The
   tool names below are the server's own; Copilot may show them with a server prefix. If the tools
   are missing, tell the user to register the server and stop. Don't fall back to prose.
 - Staging writes files under `documentation-robotics/changesets/`.
-- You never commit, apply or discard the plan. Those are the human's steps, and commit and apply are
-  not MCP tools.
+- If the project has no model yet, propose a name and confirm it with the human before
+  `project_init`. Then ask whether to bootstrap the model from the code now or let it grow with
+  each change, and wait for their answer.
+- When `codebase_extract` returns cards (in a bootstrap, or when you verify), ask the developer about
+  the ones you can't place with confidence: whether a card is a model element at all, which type it
+  is, or whether to reject it. Don't guess. Collect them and ask once, in one short list (the card,
+  your best guess, the question), then stage or reject from the answers.
+- You never land or discard the plan on your own. Commit it (`changeset_commit`) only when the
+  human asks you to land it; they confirm it in a dialog. Apply is not an MCP tool. Discard only when
+  they agree.
 
 ## The loop
 
 1. **Frame.** `changeset_list` first: if a changeset for this change exists, `changeset_activate` it
-   and continue. Otherwise `changeset_create` with a short kebab-case `name` and a `description`
-   that states the intent: what the change is for and what done looks like. Find the goal,
+   and continue. Otherwise propose a short kebab-case `name` and a `description` that states the
+   intent (what the change is for and what done looks like), and confirm both with the human before
+   you call `changeset_create` with them. Wait for their answer. Find the goal,
    requirement or feature it serves (`model_search` in motivation, business, product). If there is
    none, stage one, or ask the human what the change is for.
 2. **Orient.** `model_search` / `model_show` / `model_trace` for the elements the change touches.
@@ -46,19 +55,29 @@ graph checks the plan for you. The full design is `docs/CHANGE_MODELING.md` in t
    element the change adds or alters.
 3. **Draft.** Stage the change in every layer it reaches: `model_add`, `model_update`,
    `model_delete`, `relationship_add`, `relationship_delete`. Relationships may join elements that
-   exist only in the changeset. Pass `sourceFile`, `sourceProvenance` (`manual` for a planned location) and `sourceSymbol` when you know where the code goes.
+   exist only in the changeset. When you wire several, use the lists: `model_add` with
+   `elements: [...]` (plus `relationships` that may name elements added in the same call), and
+   `relationship_add` with `relationships: [{source, predicate, target, properties?}]`. Each list is
+   staged in one write; an invalid item is skipped and reported, so read the per-item results. For
+   a planned element with no code yet, send no source fields. Pass `sourceFile` and `sourceSymbol`
+   (with `sourceProvenance: "manual"`) only when you know where the code goes.
    Change one attribute with `model_update` `attributePatch`, not by repeating every attribute. Fix a
    mistake with `changeset_unstage` (one element, one relationship, or `source` or `target` alone for
-   every staged connection at that end), not by staging the reverse.
+   every staged connection at that end), not by staging the reverse. To drop several, send them as
+   `changes: [...]`: one call, one write, a result per item.
 4. **Pressure-test.** `changeset_brief`, then `changeset_impact` for anything the brief questions.
+   The brief is compact by default; pass `detail: "full"` only when you need every section in full.
    Steps 3 and 4 are a loop: a plan comes into focus over many passes. Each pass, stage a little,
    then:
    - Pass the last brief's `revisionToken` as `since`; read the `delta` first. It covers unstages
      too (`unstaged`). If it warns (a hand-edited `changes.yaml`, or a reach back past the last 200
      unstages), read the brief itself.
-   - Work through `unwired` for each element you added or changed. Where `existingCount` is above
-     0, link an existing element; otherwise decide whether the change needs a new one. Use
-     `unwiredLayers` to see one layer in full, and `unwired: "none"` when you only need the gaps.
+   - Work through `unwired` for each element you added or changed. The default brief only counts
+     it per layer, and `sections` returns only the sections it names, so list the entries with
+     `sections: ["unwired"], unwiredLayers: [<the layers the change reaches>]`, narrowed further with
+     `layers` or `ids` if you like. Always pass a filter: unfiltered it runs to hundreds of KB on a
+     large model. Where `existingCount` is above 0, link an existing element; otherwise decide
+     whether the change needs a new one.
    - Walk `changeset_impact` with `from` set to what you just added, not the whole changeset.
    - Read the plan with `changeset_show` `detail: "summary"`, not the full snapshots.
 
@@ -77,29 +96,63 @@ graph checks the plan for you. The full design is `docs/CHANGE_MODELING.md` in t
    (`changeset_update`). `model_validate` should pass on the projected model.
 
 5. **Review.** Stop and show the human the brief: changes by layer, gaps fixed and gaps accepted,
-   impact, code touched. Ask them to look at it in `dr visualize` and comment on elements there.
-   Read their comments with `annotation_list`, answer with `annotation_reply`, revise, and run the
-   brief again. Don't start building until they agree.
-6. **Build.** Build from the brief. Its "code touched" list is what you will edit or must not
+   impact, code touched. Call `review_open` and give them its `url`: it opens the plan on the graph
+   in the viewer, reusing the viewer already running for the project or starting one. The human
+   comments on elements there, including ones the plan adds. Read their comments with
+   `annotation_list`, answer with `annotation_reply`, revise, and run the brief again. Don't start building until they agree.
+6. **Build.** Build from the brief. At the start of the build, read it with
+   `sections: ["changes"]`: each changed element's attributes and changed fields, and its
+   connections as `predicate → id` lines. For a large plan, read one layer at a time with
+   `sections: ["changes"], layers: ["<layer>"]`, taking the layers from the default brief's
+   `byLayer`. The default brief's "code touched" list is what you will edit or must not
    break. Keep the changeset staged and commit only the plan's own directory
    (`documentation-robotics/changesets/<id>/`, with the id `changeset_show` reports) on the branch
    with the code. Don't add the whole `changesets/` directory: the `.active` marker and any
    `<name>-as-built` changeset stay out of the commit. If the build has to differ from the plan,
-   change the plan to match and say why.
-7. **Verify.** Write down what was built, separately from the plan: `changeset_create`
-   `<name>-as-built`, stage what the diff actually contains (read the code, not the plan), then
-   `changeset_verify` with `planned: <name>` and `against: {"changesetId": "<name>-as-built"}`.
-   Fix each missing, unplanned or divergent item in the code or in the plan. Look for missing
-   connections in the as-built too: for each element, compare what the spec models for its type
-   with what was staged, and look for evidence of each absent one in the code (and the analyzer's
-   graph, `dr analyzer callers` / `callees`, when it is indexed). Confirm or reject
-   every `probable` match. `changeset_activate` the plan again afterwards. Tell the human the
-   as-built changeset can be discarded; discard it (`changeset_discard`, `confirm: true`) only when
-   they agree. Until then it stays out of git: when you commit fixes, add only the plan's
-   directory again. If the as-built changes are committed to the model instead of kept as a changeset,
-   `against: {"base": true}` compares the plan with the model.
-8. **Land.** Hand over: the PR carries the code and the staged changeset. The human commits it,
-   in the viewer or with `dr changeset commit`.
+   change the plan to match and say why. Don't verify during the build: no `codebase_extract`, no
+   as-built changeset and no `changeset_verify` until the build is committed. Verify is the next
+   step, on its own.
+7. **Verify.** Verify as its own step, after the build (the code and the plan's directory) is
+   committed, not in the turn that builds it. Extract what was built, separately from the plan. The
+   as-built changeset comes from `codebase_extract` and the code. Never hand-write it, and never copy
+   plan elements into it: name each element after its card (the code's symbol), not after the plan's
+   element, and don't add planned elements extraction can't see (tests, intent) to make the verdict
+   match. Re-index the code once the build is committed: `codebase_index` with `wait: 30` (it re-indexes when source files changed since the last
+   index, committed or not), then `status: true` and `wait: 30` until the job is done; don't call it
+   in a quick loop. If the result reports `ignoreFile` (the `.cbmignore` it wrote so DR's own folders
+   aren't indexed), tell the developer to commit that file. Then `codebase_extract`
+   with `since` set to the branch the work started from (e.g. `main`) and
+   `changeset: "<name>-as-built"`. It stages what the rules decide in the changed files and leaves
+   `<name>-as-built` active. If it staged nothing, it makes no changeset: `changeset_create` with the
+   name it gives before you `model_add` its cards. For each card it returns that is a model element, stage it with
+   `model_add` (`sourceFile` and `sourceSymbol` from the card, `sourceProvenance: "extracted"`),
+   reading the code, not the plan, and ask the developer about the cards you can't place, in one short
+   list;
+   then call `codebase_extract` again to stage their relationships, and `model_delete` the
+   `candidateDeletes` that are really gone. Then `changeset_verify` with `planned: <name>` and
+   `against: {"changesetId": "<name>-as-built"}`. Fix each missing, unplanned or divergent item in
+   the code or in the plan. `unverifiable` items are planned parts extraction can't see (motivation,
+   re-exports, TypeScript tests), and `notes` are description-only differences: neither needs a
+   plan edit. Never edit the plan to match extracted placeholder text. A verdict of `unverifiable`
+   means the plan has nothing extraction can check; say so rather than call it a failure. Look for missing connections in the as-built too: for each element,
+   compare what the spec models for its type with what was staged, and look for evidence of each
+   absent one in the code (and the analyzer's graph, `dr analyzer callers` / `callees`). Confirm or
+   reject every `probable` match. `changeset_activate` the plan again afterwards (the extract
+   result's `previousActive`). After verify, the plan is what lands (step 8), not the as-built
+   changeset. Ask the human whether to discard the as-built changeset (`changeset_discard`,
+   `confirm: true`) or keep it as a record, and discard it only when they agree. Don't land it:
+   landing it first changes the plan's base, so the plan then needs `force`, and the plan's
+   descriptions don't apply to elements already in the base. It stays out of git: when you commit
+   fixes, add only the plan's directory again. If the as-built changes were landed anyway,
+   `against: {"base": true, "extracted": true}` compares the plan with the model, with extraction's blind spots applied.
+8. **Land.** The PR carries the code and the staged plan, and the human commits the plan in it, not
+   the as-built changeset. When they ask you to land it, call `changeset_commit` with its name. The server asks them
+   to confirm in a dialog that shows the name, intent, counts by operation, layers and drift, and
+   commits only if they confirm; if they decline, leave it staged. If it is refused for drift, show
+   them what drifted (`changeset_brief`) and pass `force: true` only if they still want it. Then add
+   the model's changed files and the changeset's directory to the branch. If it is refused, they land
+   it in the viewer (`review_open`, then Apply on the changeset), or you call it again from an
+   interactive session. Never point them to the `dr` CLI.
 
 ## Tolerance
 
@@ -109,9 +162,14 @@ Tools report odd input and carry on instead of failing. Read the report each tim
 - `changeset_unstage` reports `not-staged` when there was nothing to drop.
 - In a changeset-only session (DrBot with `--with-changesets`), a write with no active changeset is
   refused. Call `changeset_create` or `changeset_activate` and retry.
+- `changeset_commit` is refused when the human declines or cancels the dialog, when the client
+  can't show one (no MCP elicitation), and in DrBot, which doesn't have it. Nothing is written; the
+  human lands it in the viewer (`review_open`, then Apply), or from an interactive session.
 - DrBot cannot write annotations (`annotation_create` and `annotation_reply` are not among its
   tools). There, record accepted gaps in the description with `changeset_update` and answer the
   human's comments in the chat.
+- DrBot has no `review_open`: it runs in the viewer, so the human already has the plan in front
+  of them. Point them to the changeset in the viewer's Changesets view instead.
 
 ## Keep it short
 

package/dist/mcp/changeset-only.js

@@ -8,7 +8,12 @@ const BASE_MODEL_WRITE_TOOLS = /* @__PURE__ */ new Set([
   "model_delete",
   "relationship_add",
   "relationship_delete"
-]);
+]), OUTSIDE_CHANGESET_TOOLS = /* @__PURE__ */ new Set(["project_init", "project_upgrade"]);
+function outsideChangesetError(toolName) {
+  return new CLIError(`This session can only change the model through a changeset, and "${toolName}" writes outside one.`, ErrorCategory.USER, [
+    toolName === "project_init" ? "Ask the user to create the model themselves (dr init, or project_init in a session without changeset-only mode)" : "Ask the user to upgrade the model themselves (dr upgrade, or project_upgrade in a session without changeset-only mode)"
+  ], { operation: toolName, context: `${CHANGESET_ONLY_ENV}=${process.env[CHANGESET_ONLY_ENV] ?? "true"}` });
+}
 function changesetOnlyError(toolName) {
   const retry = toolName ? `Then call "${toolName}" again` : "Then retry the call";
   return new CLIError("This session can only change the model through a changeset, and no changeset is active.", ErrorCategory.USER, [
@@ -17,7 +22,11 @@ function changesetOnlyError(toolName) {
   ], { operation: toolName ?? "save model", context: `${CHANGESET_ONLY_ENV}=${process.env[CHANGESET_ONLY_ENV] ?? "true"}` });
 }
 async function changesetOnlyRefusal(toolName, rootPath, loadModel, env = process.env) {
-  if (!isChangesetOnly(env) || !BASE_MODEL_WRITE_TOOLS.has(toolName))
+  if (!isChangesetOnly(env))
+    return null;
+  if (OUTSIDE_CHANGESET_TOOLS.has(toolName))
+    return outsideChangesetError(toolName);
+  if (!BASE_MODEL_WRITE_TOOLS.has(toolName))
     return null;
   try {
     const model = await loadModel(rootPath);
@@ -28,7 +37,9 @@ async function changesetOnlyRefusal(toolName, rootPath, loadModel, env = process
 }
 export {
   BASE_MODEL_WRITE_TOOLS,
+  OUTSIDE_CHANGESET_TOOLS,
   changesetOnlyError,
-  changesetOnlyRefusal
+  changesetOnlyRefusal,
+  outsideChangesetError
 };
 //# sourceMappingURL=changeset-only.js.map

package/dist/mcp/changeset-only.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/mcp/changeset-only.ts"],
-  "sourcesContent": ["/**\n * Changeset-only mode on the MCP server.\n *\n * When `dr mcp` runs with DR_CHANGESET_ONLY=true (DrBot under `dr visualize --with-changesets`\n * starts it that way), an agent may change the model only by staging into an active changeset.\n * The tools below write the base model when no changeset is active, so the tool registry asks\n * `changesetOnlyRefusal()` before running them and returns its refusal instead: the agent is told\n * to call changeset_create (or changeset_activate) and retry.\n *\n * This check runs before the handler so a refused call never touches the cached in-memory model.\n * Any other base-model save still hits the core guard (core/changeset-only-guard.ts), whose\n * ChangesetOnlyError runTool turns into the same refusal, after dropping the model cache so a\n * half-applied in-memory edit can't linger.\n */\n\nimport type { Model } from \"../core/model.js\";\nimport { isChangesetOnly, CHANGESET_ONLY_ENV } from \"../core/changeset-only-guard.js\";\nimport { StagingAreaManager } from \"../core/staging-area.js\";\nimport { CLIError, ErrorCategory, getErrorMessage } from \"../utils/errors.js\";\nimport { activeStagedChangeset } from \"./tools/changeset-shared.js\";\n\n/** Tools that write the base model when no changeset is active. */\nexport const BASE_MODEL_WRITE_TOOLS: ReadonlySet<string> = new Set([\n  \"model_add\",\n  \"model_update\",\n  \"model_delete\",\n  \"relationship_add\",\n  \"relationship_delete\",\n]);\n\n/** The error an agent gets for a base-model write in changeset-only mode. */\nexport function changesetOnlyError(toolName?: string): CLIError {\n  const retry = toolName ? `Then call \"${toolName}\" again` : \"Then retry the call\";\n  return new CLIError(\n    \"This session can only change the model through a changeset, and no changeset is active.\",\n    ErrorCategory.USER,\n    [\n      'Call \"changeset_create\" with a name for the change (it activates the new changeset), or ' +\n        '\"changeset_activate\" to resume one from \"changeset_list\"',\n      `${retry}: it will be staged in the changeset for the user to review and commit`,\n    ],\n    { operation: toolName ?? \"save model\", context: `${CHANGESET_ONLY_ENV}=${process.env[CHANGESET_ONLY_ENV] ?? \"true\"}` }\n  );\n}\n\n/**\n * The refusal for this call, or null when it may run: always null outside changeset-only mode,\n * for tools that don't write the base model, and when a staged changeset is active.\n *\n * If the model or the active changeset can't be read, the check steps aside (null, logged) and\n * the tool reports that failure itself; the core guard still stops any base-model save.\n */\nexport async function changesetOnlyRefusal(\n  toolName: string,\n  rootPath: string | undefined,\n  loadModel: (rootPath?: string) => Promise<Model>,\n  env: NodeJS.ProcessEnv = process.env\n): Promise<CLIError | null> {\n  if (!isChangesetOnly(env) || !BASE_MODEL_WRITE_TOOLS.has(toolName)) {\n    return null;\n  }\n  try {\n    const model = await loadModel(rootPath);\n    const active = await activeStagedChangeset(new StagingAreaManager(model.rootPath, model));\n    return active ? null : changesetOnlyError(toolName);\n  } catch (error) {\n    console.error(`[mcp] changeset-only check for ${toolName} skipped: ${getErrorMessage(error)}`);\n    return null;\n  }\n}\n"],
-  "mappings": "AAgBA,SAAS,iBAAiB,0BAA0B;AACpD,SAAS,0BAA0B;AACnC,SAAS,UAAU,eAAe,uBAAuB;AACzD,SAAS,6BAA6B;AAG/B,MAAM,yBAA8C,oBAAI,IAAI;EACjE;EACA;EACA;EACA;EACA;CACD;AAGK,SAAU,mBAAmB,UAAiB;AAClD,QAAM,QAAQ,WAAW,cAAc,QAAQ,YAAY;AAC3D,SAAO,IAAI,SACT,2FACA,cAAc,MACd;IACE;IAEA,GAAG,KAAK;KAEV,EAAE,WAAW,YAAY,cAAc,SAAS,GAAG,kBAAkB,IAAI,QAAQ,IAAI,kBAAkB,KAAK,MAAM,GAAE,CAAE;AAE1H;AASA,eAAsB,qBACpB,UACA,UACA,WACA,MAAyB,QAAQ,KAAG;AAEpC,MAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,uBAAuB,IAAI,QAAQ;AAC/D,WAAO;AAET,MAAI;AACF,UAAM,QAAQ,MAAM,UAAU,QAAQ;AAEtC,WADe,MAAM,sBAAsB,IAAI,mBAAmB,MAAM,UAAU,KAAK,CAAC,IACxE,OAAO,mBAAmB,QAAQ;EACpD,SAAS,OAAO;AACd,mBAAQ,MAAM,kCAAkC,QAAQ,aAAa,gBAAgB,KAAK,CAAC,EAAE,GACtF;EACT;AACF;",
+  "sourcesContent": ["/**\n * Changeset-only mode on the MCP server.\n *\n * When `dr mcp` runs with DR_CHANGESET_ONLY=true (DrBot under `dr visualize --with-changesets`\n * starts it that way), an agent may change the model only by staging into an active changeset.\n * The tools below write the base model when no changeset is active, so the tool registry asks\n * `changesetOnlyRefusal()` before running them and returns its refusal instead: the agent is told\n * to call changeset_create (or changeset_activate) and retry.\n *\n * This check runs before the handler so a refused call never touches the cached in-memory model.\n * Any other base-model save still hits the core guard (core/changeset-only-guard.ts), whose\n * ChangesetOnlyError runTool turns into the same refusal, after dropping the model cache so a\n * half-applied in-memory edit can't linger.\n */\n\nimport type { Model } from \"../core/model.js\";\nimport { isChangesetOnly, CHANGESET_ONLY_ENV } from \"../core/changeset-only-guard.js\";\nimport { StagingAreaManager } from \"../core/staging-area.js\";\nimport { CLIError, ErrorCategory, getErrorMessage } from \"../utils/errors.js\";\nimport { activeStagedChangeset } from \"./tools/changeset-shared.js\";\n\n/** Tools that write the base model when no changeset is active. */\nexport const BASE_MODEL_WRITE_TOOLS: ReadonlySet<string> = new Set([\n  \"model_add\",\n  \"model_update\",\n  \"model_delete\",\n  \"relationship_add\",\n  \"relationship_delete\",\n]);\n\n/**\n * Tools that write outside any changeset (they create or migrate the model itself), refused in\n * changeset-only mode whether or not a changeset is active.\n */\nexport const OUTSIDE_CHANGESET_TOOLS: ReadonlySet<string> = new Set([\"project_init\", \"project_upgrade\"]);\n\n/** The error an agent gets for a tool that writes outside a changeset in changeset-only mode. */\nexport function outsideChangesetError(toolName: string): CLIError {\n  return new CLIError(\n    `This session can only change the model through a changeset, and \"${toolName}\" writes outside one.`,\n    ErrorCategory.USER,\n    [\n      toolName === \"project_init\"\n        ? \"Ask the user to create the model themselves (dr init, or project_init in a session without changeset-only mode)\"\n        : \"Ask the user to upgrade the model themselves (dr upgrade, or project_upgrade in a session without changeset-only mode)\",\n    ],\n    { operation: toolName, context: `${CHANGESET_ONLY_ENV}=${process.env[CHANGESET_ONLY_ENV] ?? \"true\"}` }\n  );\n}\n\n/** The error an agent gets for a base-model write in changeset-only mode. */\nexport function changesetOnlyError(toolName?: string): CLIError {\n  const retry = toolName ? `Then call \"${toolName}\" again` : \"Then retry the call\";\n  return new CLIError(\n    \"This session can only change the model through a changeset, and no changeset is active.\",\n    ErrorCategory.USER,\n    [\n      'Call \"changeset_create\" with a name for the change (it activates the new changeset), or ' +\n        '\"changeset_activate\" to resume one from \"changeset_list\"',\n      `${retry}: it will be staged in the changeset for the user to review and commit`,\n    ],\n    { operation: toolName ?? \"save model\", context: `${CHANGESET_ONLY_ENV}=${process.env[CHANGESET_ONLY_ENV] ?? \"true\"}` }\n  );\n}\n\n/**\n * The refusal for this call, or null when it may run: always null outside changeset-only mode,\n * for tools that don't write the base model, and when a staged changeset is active. Tools that\n * write outside any changeset (project_init, project_upgrade) are always refused in the mode.\n *\n * If the model or the active changeset can't be read, the check steps aside (null, logged) and\n * the tool reports that failure itself; the core guard still stops any base-model save.\n */\nexport async function changesetOnlyRefusal(\n  toolName: string,\n  rootPath: string | undefined,\n  loadModel: (rootPath?: string) => Promise<Model>,\n  env: NodeJS.ProcessEnv = process.env\n): Promise<CLIError | null> {\n  if (!isChangesetOnly(env)) {\n    return null;\n  }\n  if (OUTSIDE_CHANGESET_TOOLS.has(toolName)) {\n    return outsideChangesetError(toolName);\n  }\n  if (!BASE_MODEL_WRITE_TOOLS.has(toolName)) {\n    return null;\n  }\n  try {\n    const model = await loadModel(rootPath);\n    const active = await activeStagedChangeset(new StagingAreaManager(model.rootPath, model));\n    return active ? null : changesetOnlyError(toolName);\n  } catch (error) {\n    console.error(`[mcp] changeset-only check for ${toolName} skipped: ${getErrorMessage(error)}`);\n    return null;\n  }\n}\n"],
+  "mappings": "AAgBA,SAAS,iBAAiB,0BAA0B;AACpD,SAAS,0BAA0B;AACnC,SAAS,UAAU,eAAe,uBAAuB;AACzD,SAAS,6BAA6B;AAG/B,MAAM,yBAA8C,oBAAI,IAAI;EACjE;EACA;EACA;EACA;EACA;CACD,GAMY,0BAA+C,oBAAI,IAAI,CAAC,gBAAgB,iBAAiB,CAAC;AAGjG,SAAU,sBAAsB,UAAgB;AACpD,SAAO,IAAI,SACT,oEAAoE,QAAQ,yBAC5E,cAAc,MACd;IACE,aAAa,iBACT,oHACA;KAEN,EAAE,WAAW,UAAU,SAAS,GAAG,kBAAkB,IAAI,QAAQ,IAAI,kBAAkB,KAAK,MAAM,GAAE,CAAE;AAE1G;AAGM,SAAU,mBAAmB,UAAiB;AAClD,QAAM,QAAQ,WAAW,cAAc,QAAQ,YAAY;AAC3D,SAAO,IAAI,SACT,2FACA,cAAc,MACd;IACE;IAEA,GAAG,KAAK;KAEV,EAAE,WAAW,YAAY,cAAc,SAAS,GAAG,kBAAkB,IAAI,QAAQ,IAAI,kBAAkB,KAAK,MAAM,GAAE,CAAE;AAE1H;AAUA,eAAsB,qBACpB,UACA,UACA,WACA,MAAyB,QAAQ,KAAG;AAEpC,MAAI,CAAC,gBAAgB,GAAG;AACtB,WAAO;AAET,MAAI,wBAAwB,IAAI,QAAQ;AACtC,WAAO,sBAAsB,QAAQ;AAEvC,MAAI,CAAC,uBAAuB,IAAI,QAAQ;AACtC,WAAO;AAET,MAAI;AACF,UAAM,QAAQ,MAAM,UAAU,QAAQ;AAEtC,WADe,MAAM,sBAAsB,IAAI,mBAAmB,MAAM,UAAU,KAAK,CAAC,IACxE,OAAO,mBAAmB,QAAQ;EACpD,SAAS,OAAO;AACd,mBAAQ,MAAM,kCAAkC,QAAQ,aAAa,gBAAgB,KAAK,CAAC,EAAE,GACtF;EACT;AACF;",
   "names": []
 }

package/dist/mcp/project-root.js

@@ -0,0 +1,85 @@
+import { fileURLToPath } from "node:url";
+import { findProjectRoot } from "../utils/project-paths.js";
+import { getErrorMessage } from "../utils/errors.js";
+let current = { root: process.cwd(), source: "cwd" }, settled = Promise.resolve();
+function currentProjectRoot() {
+  return { ...current };
+}
+function whenProjectRootSettled() {
+  return settled;
+}
+function markEnvProjectRoot(root) {
+  current = { root, source: "env" };
+}
+function resetProjectRoot(root = process.cwd()) {
+  current = { root, source: "cwd" }, settled = Promise.resolve();
+}
+function rootUrisToPaths(uris) {
+  const paths = [];
+  for (const uri of uris)
+    if (uri.startsWith("file:"))
+      try {
+        paths.push(fileURLToPath(uri));
+      } catch {
+      }
+  return paths;
+}
+async function pickProjectRoot(paths, findProject = findProjectRoot) {
+  for (const path of paths)
+    if (await findProject(path))
+      return path;
+  return paths[0];
+}
+function followClientRoots(listRoots, options = {}) {
+  const chdir = options.chdir ?? ((path) => process.chdir(path)), log = options.log ?? ((message) => process.stderr.write(`[mcp] ${message}
+`)), timeoutMs = options.timeoutMs ?? 5e3, previous = settled;
+  return settled = (async () => {
+    if (await previous, current.source === "env")
+      return;
+    let uris;
+    try {
+      const { roots } = await withTimeout(listRoots(), timeoutMs);
+      uris = roots.map((root2) => root2.uri);
+    } catch (error) {
+      log(`client roots unavailable (${getErrorMessage(error)}); serving from ${current.root}`);
+      return;
+    }
+    const root = await pickProjectRoot(rootUrisToPaths(uris));
+    if (!root || root === current.root) {
+      root && (current = { root, source: "client-roots" });
+      return;
+    }
+    try {
+      chdir(root);
+    } catch (error) {
+      log(`client root ${root} is not usable (${getErrorMessage(error)}); serving from ${current.root}`);
+      return;
+    }
+    current = { root, source: "client-roots" };
+    try {
+      await options.onChange?.(root);
+    } catch (error) {
+      log(`after moving to ${root}: ${getErrorMessage(error)}`);
+    }
+  })(), settled;
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`no answer within ${ms}ms`)), ms);
+    promise.then((value) => {
+      clearTimeout(timer), resolve(value);
+    }, (error) => {
+      clearTimeout(timer), reject(error);
+    });
+  });
+}
+export {
+  currentProjectRoot,
+  followClientRoots,
+  markEnvProjectRoot,
+  pickProjectRoot,
+  resetProjectRoot,
+  rootUrisToPaths,
+  whenProjectRootSettled
+};
+//# sourceMappingURL=project-root.js.map

package/dist/mcp/project-root.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mcp/project-root.ts"],
+  "sourcesContent": ["/**\n * Which project the MCP server serves when a tool call doesn't name one with `rootPath`.\n *\n * In order of precedence:\n * 1. DR_MCP_ROOT_PATH, set by a launcher that names the model (DrBot under `dr visualize`).\n * 2. The client's MCP roots: the folder the editor or agent session has open. This lets one\n *    server registered per user (a Claude Code plugin) serve whichever project is in front of\n *    the developer, whatever directory the client happens to start it in.\n * 3. The server's own working directory.\n *\n * The server moves its working directory to the chosen root, so every tool, and the CLI code\n * under it, finds the project the same way it does from a terminal in that folder.\n */\n\nimport { fileURLToPath } from \"node:url\";\nimport { findProjectRoot } from \"../utils/project-paths.js\";\nimport { getErrorMessage } from \"../utils/errors.js\";\n\nexport type ProjectRootSource = \"env\" | \"client-roots\" | \"cwd\";\n\nexport interface ProjectRoot {\n  /** Directory the server serves from (its working directory). */\n  root: string;\n  /** Where that directory came from. */\n  source: ProjectRootSource;\n}\n\nlet current: ProjectRoot = { root: process.cwd(), source: \"cwd\" };\nlet settled: Promise<void> = Promise.resolve();\n\n/** The directory the server serves from, and where it came from. */\nexport function currentProjectRoot(): ProjectRoot {\n  return { ...current };\n}\n\n/**\n * Resolves once the server knows which project to serve. Tool calls and model loads wait on\n * this so none runs against the wrong folder while the client's roots are still being asked for.\n */\nexport function whenProjectRootSettled(): Promise<void> {\n  return settled;\n}\n\n/** Records that a launcher chose the root (DR_MCP_ROOT_PATH); client roots are then ignored. */\nexport function markEnvProjectRoot(root: string): void {\n  current = { root, source: \"env\" };\n}\n\n/** Test-only: forget any chosen root and pending resolution. */\nexport function resetProjectRoot(root: string = process.cwd()): void {\n  current = { root, source: \"cwd\" };\n  settled = Promise.resolve();\n}\n\n/** Local paths for the `file://` root URIs; roots with other schemes are skipped. */\nexport function rootUrisToPaths(uris: readonly string[]): string[] {\n  const paths: string[] = [];\n  for (const uri of uris) {\n    if (!uri.startsWith(\"file:\")) continue;\n    try {\n      paths.push(fileURLToPath(uri));\n    } catch {\n      // A malformed file URI can't name a folder; skip it.\n    }\n  }\n  return paths;\n}\n\n/**\n * The root to serve: the first one inside a DR project (a documentation-robotics/ folder at or\n * above it), else the first root, so a project without a model yet is still the one in front\n * of the developer. Undefined when there are no usable roots.\n */\nexport async function pickProjectRoot(\n  paths: readonly string[],\n  findProject: (path: string) => Promise<string | null> = findProjectRoot\n): Promise<string | undefined> {\n  for (const path of paths) {\n    if (await findProject(path)) return path;\n  }\n  return paths[0];\n}\n\nexport interface FollowClientRootsOptions {\n  /** Called after the server moved to a different root (drop cached models, warm the new one). */\n  onChange?: (root: string) => void | Promise<void>;\n  /** Give up on a client that doesn't answer roots/list within this time (default 5s). */\n  timeoutMs?: number;\n  chdir?: (path: string) => void;\n  log?: (message: string) => void;\n}\n\n/**\n * Asks the client for its roots and moves the server to the chosen one. Call it when the\n * client has initialized and again when it says its roots changed. Never throws: a client that\n * fails or doesn't answer leaves the server where it is. A launcher's DR_MCP_ROOT_PATH wins.\n */\nexport function followClientRoots(\n  listRoots: () => Promise<{ roots: ReadonlyArray<{ uri: string }> }>,\n  options: FollowClientRootsOptions = {}\n): Promise<void> {\n  const chdir = options.chdir ?? ((path: string) => process.chdir(path));\n  const log = options.log ?? ((message: string) => process.stderr.write(`[mcp] ${message}\\n`));\n  const timeoutMs = options.timeoutMs ?? 5000;\n\n  const previous = settled;\n  // Assigned before any await, so a tool call that arrives next already waits on it.\n  settled = (async () => {\n    await previous;\n    if (current.source === \"env\") return;\n\n    let uris: string[];\n    try {\n      const { roots } = await withTimeout(listRoots(), timeoutMs);\n      uris = roots.map((root) => root.uri);\n    } catch (error) {\n      log(`client roots unavailable (${getErrorMessage(error)}); serving from ${current.root}`);\n      return;\n    }\n\n    const root = await pickProjectRoot(rootUrisToPaths(uris));\n    if (!root || root === current.root) {\n      if (root) current = { root, source: \"client-roots\" };\n      return;\n    }\n    try {\n      chdir(root);\n    } catch (error) {\n      log(`client root ${root} is not usable (${getErrorMessage(error)}); serving from ${current.root}`);\n      return;\n    }\n    current = { root, source: \"client-roots\" };\n    try {\n      await options.onChange?.(root);\n    } catch (error) {\n      log(`after moving to ${root}: ${getErrorMessage(error)}`);\n    }\n  })();\n  return settled;\n}\n\nfunction withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    const timer = setTimeout(() => reject(new Error(`no answer within ${ms}ms`)), ms);\n    promise.then(\n      (value) => {\n        clearTimeout(timer);\n        resolve(value);\n      },\n      (error) => {\n        clearTimeout(timer);\n        reject(error);\n      }\n    );\n  });\n}\n"],
+  "mappings": "AAcA,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAWhC,IAAI,UAAuB,EAAE,MAAM,QAAQ,IAAG,GAAI,QAAQ,MAAK,GAC3D,UAAyB,QAAQ,QAAO;AAGtC,SAAU,qBAAkB;AAChC,SAAO,EAAE,GAAG,QAAO;AACrB;AAMM,SAAU,yBAAsB;AACpC,SAAO;AACT;AAGM,SAAU,mBAAmB,MAAY;AAC7C,YAAU,EAAE,MAAM,QAAQ,MAAK;AACjC;AAGM,SAAU,iBAAiB,OAAe,QAAQ,IAAG,GAAE;AAC3D,YAAU,EAAE,MAAM,QAAQ,MAAK,GAC/B,UAAU,QAAQ,QAAO;AAC3B;AAGM,SAAU,gBAAgB,MAAuB;AACrD,QAAM,QAAkB,CAAA;AACxB,aAAW,OAAO;AAChB,QAAK,IAAI,WAAW,OAAO;AAC3B,UAAI;AACF,cAAM,KAAK,cAAc,GAAG,CAAC;MAC/B,QAAQ;MAER;AAEF,SAAO;AACT;AAOA,eAAsB,gBACpB,OACA,cAAwD,iBAAe;AAEvE,aAAW,QAAQ;AACjB,QAAI,MAAM,YAAY,IAAI;AAAG,aAAO;AAEtC,SAAO,MAAM,CAAC;AAChB;AAgBM,SAAU,kBACd,WACA,UAAoC,CAAA,GAAE;AAEtC,QAAM,QAAQ,QAAQ,UAAU,CAAC,SAAiB,QAAQ,MAAM,IAAI,IAC9D,MAAM,QAAQ,QAAQ,CAAC,YAAoB,QAAQ,OAAO,MAAM,SAAS,OAAO;CAAI,IACpF,YAAY,QAAQ,aAAa,KAEjC,WAAW;AAEjB,oBAAW,YAAW;AAEpB,QADA,MAAM,UACF,QAAQ,WAAW;AAAO;AAE9B,QAAI;AACJ,QAAI;AACF,YAAM,EAAE,MAAK,IAAK,MAAM,YAAY,UAAS,GAAI,SAAS;AAC1D,aAAO,MAAM,IAAI,CAACA,UAASA,MAAK,GAAG;IACrC,SAAS,OAAO;AACd,UAAI,6BAA6B,gBAAgB,KAAK,CAAC,mBAAmB,QAAQ,IAAI,EAAE;AACxF;IACF;AAEA,UAAM,OAAO,MAAM,gBAAgB,gBAAgB,IAAI,CAAC;AACxD,QAAI,CAAC,QAAQ,SAAS,QAAQ,MAAM;AAClC,MAAI,SAAM,UAAU,EAAE,MAAM,QAAQ,eAAc;AAClD;IACF;AACA,QAAI;AACF,YAAM,IAAI;IACZ,SAAS,OAAO;AACd,UAAI,eAAe,IAAI,mBAAmB,gBAAgB,KAAK,CAAC,mBAAmB,QAAQ,IAAI,EAAE;AACjG;IACF;AACA,cAAU,EAAE,MAAM,QAAQ,eAAc;AACxC,QAAI;AACF,YAAM,QAAQ,WAAW,IAAI;IAC/B,SAAS,OAAO;AACd,UAAI,mBAAmB,IAAI,KAAK,gBAAgB,KAAK,CAAC,EAAE;IAC1D;EACF,GAAE,GACK;AACT;AAEA,SAAS,YAAe,SAAqB,IAAU;AACrD,SAAO,IAAI,QAAW,CAAC,SAAS,WAAU;AACxC,UAAM,QAAQ,WAAW,MAAM,OAAO,IAAI,MAAM,oBAAoB,EAAE,IAAI,CAAC,GAAG,EAAE;AAChF,YAAQ,KACN,CAAC,UAAS;AACR,mBAAa,KAAK,GAClB,QAAQ,KAAK;IACf,GACA,CAAC,UAAS;AACR,mBAAa,KAAK,GAClB,OAAO,KAAK;IACd,CAAC;EAEL,CAAC;AACH;",
+  "names": ["root"]
+}

package/dist/mcp/server-instructions.js

@@ -0,0 +1,27 @@
+const SERVER_INSTRUCTIONS = `Documentation Robotics (DR) keeps an architecture model of the project in documentation-robotics/: layers from motivation through application, API, data and testing, linked by typed relationships. The base model describes the code as built. A planned change lives in a changeset until it lands with the code. Do each step with these tools; never tell the user to run dr for something a tool does.
+
+Start with project_status: it reports where the project stands and ends with nextStep: the tool to call next (and nextStep.also alongside it). Call it again after a step. Pass rootPath only for another project.
+
+Confirm with the user, and wait, before you create: the model's name (project_init); whether to bootstrap the model from the code now or grow it with each change; a changeset's name and intent (changeset_create). Propose each, don't decide it.
+
+Set up: if the model's spec is behind, project_upgrade previews the migration; show the user and call it with apply: true only when they approve.
+
+Read the model: model_search, model_show, model_trace, model_list. spec_type gives a type's attributes and the relationships the catalog allows. Element ids are {layer}.{type}.{kebab-name}.
+
+Plan a change (the /dr-plan workflow):
+1. changeset_create opens a changeset and makes it active. While one is active, model and relationship writes stage into it, and the reads show the model as the plan leaves it. Wire several at once: model_add with elements: [...] (and relationships among them), relationship_add with relationships: [...]; bad items are skipped and reported.
+2. Check each type with spec_type, and link every new element to what it serves, realizes or depends on.
+3. Pressure-test with changeset_brief (it counts unwired links; list them with sections: ["unwired"], unwiredLayers: [...], never unfiltered) and changeset_impact. Revise with changeset_update and changeset_unstage (changes: [...] for several). changeset_deactivate sets a plan aside; changeset_activate resumes it.
+4. Review: give the user review_open's url (retry if the viewer is still starting). They comment there; read with annotation_list, answer with annotation_reply.
+5. Build from changeset_brief with sections: ["changes"] (large plan: layers: ["<layer>"], one at a time). Don't extract or verify during the build.
+6. Verify as its own step, once the build's code is committed to git: codebase_extract with since (the base branch) stages what was built into an as-built changeset, never written by hand or copied from the plan; changeset_verify compares the plan with it. Its unverifiable items and notes need no plan edit. The as-built changeset is left active: changeset_activate the plan (previousActive) before editing it. Then the plan lands; the as-built changeset is discarded or kept as a record, not landed.
+
+Code: codebase_index indexes in the background. Call it with wait: 30, then with status: true and wait: 30 until job.state is done (or failed: report its error and logPath). If it reports ignoreFile, tell the user to commit it. codebase_verify checks only the API layer; on code with no routes its findings are expected, not drift.
+
+Model the code: codebase_extract stages what the rules decide into an as-built changeset and leaves it active. If it staged nothing it makes no changeset: call changeset_create with the name it gives before model_add. Stage its element cards with model_add (sourceFile and sourceSymbol from the card, sourceProvenance: "extracted"), then call it again for their relationships. Ask the user about cards you can't place, in one short list. For a bootstrap, call it without since.
+
+Land a change with changeset_commit only when the user asks to land it; they confirm it in a dialog. It is refused if they decline, if the client can't show the dialog, or on drift unless they agree to force: true. If it is refused, they land it in the viewer (review_open, then Apply) or an interactive session, never the dr CLI. Never commit on your own initiative. changeset_discard deletes staged work for good; use it only when the user asks.`;
+export {
+  SERVER_INSTRUCTIONS
+};
+//# sourceMappingURL=server-instructions.js.map

package/dist/mcp/server-instructions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mcp/server-instructions.ts"],
+  "sourcesContent": ["/**\n * Instructions the dr MCP server sends in its initialize result. Clients such as Claude Code\n * load them into the session at start (alongside only the tool names), so this is the agent's\n * map of how the tools fit together. Claude Code caps it at 4096 characters; a test holds it\n * under that and checks that every tool named here exists.\n */\nexport const SERVER_INSTRUCTIONS = `Documentation Robotics (DR) keeps an architecture model of the project in documentation-robotics/: layers from motivation through application, API, data and testing, linked by typed relationships. The base model describes the code as built. A planned change lives in a changeset until it lands with the code. Do each step with these tools; never tell the user to run dr for something a tool does.\n\nStart with project_status: it reports where the project stands and ends with nextStep: the tool to call next (and nextStep.also alongside it). Call it again after a step. Pass rootPath only for another project.\n\nConfirm with the user, and wait, before you create: the model's name (project_init); whether to bootstrap the model from the code now or grow it with each change; a changeset's name and intent (changeset_create). Propose each, don't decide it.\n\nSet up: if the model's spec is behind, project_upgrade previews the migration; show the user and call it with apply: true only when they approve.\n\nRead the model: model_search, model_show, model_trace, model_list. spec_type gives a type's attributes and the relationships the catalog allows. Element ids are {layer}.{type}.{kebab-name}.\n\nPlan a change (the /dr-plan workflow):\n1. changeset_create opens a changeset and makes it active. While one is active, model and relationship writes stage into it, and the reads show the model as the plan leaves it. Wire several at once: model_add with elements: [...] (and relationships among them), relationship_add with relationships: [...]; bad items are skipped and reported.\n2. Check each type with spec_type, and link every new element to what it serves, realizes or depends on.\n3. Pressure-test with changeset_brief (it counts unwired links; list them with sections: [\"unwired\"], unwiredLayers: [...], never unfiltered) and changeset_impact. Revise with changeset_update and changeset_unstage (changes: [...] for several). changeset_deactivate sets a plan aside; changeset_activate resumes it.\n4. Review: give the user review_open's url (retry if the viewer is still starting). They comment there; read with annotation_list, answer with annotation_reply.\n5. Build from changeset_brief with sections: [\"changes\"] (large plan: layers: [\"<layer>\"], one at a time). Don't extract or verify during the build.\n6. Verify as its own step, once the build's code is committed to git: codebase_extract with since (the base branch) stages what was built into an as-built changeset, never written by hand or copied from the plan; changeset_verify compares the plan with it. Its unverifiable items and notes need no plan edit. The as-built changeset is left active: changeset_activate the plan (previousActive) before editing it. Then the plan lands; the as-built changeset is discarded or kept as a record, not landed.\n\nCode: codebase_index indexes in the background. Call it with wait: 30, then with status: true and wait: 30 until job.state is done (or failed: report its error and logPath). If it reports ignoreFile, tell the user to commit it. codebase_verify checks only the API layer; on code with no routes its findings are expected, not drift.\n\nModel the code: codebase_extract stages what the rules decide into an as-built changeset and leaves it active. If it staged nothing it makes no changeset: call changeset_create with the name it gives before model_add. Stage its element cards with model_add (sourceFile and sourceSymbol from the card, sourceProvenance: \"extracted\"), then call it again for their relationships. Ask the user about cards you can't place, in one short list. For a bootstrap, call it without since.\n\nLand a change with changeset_commit only when the user asks to land it; they confirm it in a dialog. It is refused if they decline, if the client can't show the dialog, or on drift unless they agree to force: true. If it is refused, they land it in the viewer (review_open, then Apply) or an interactive session, never the dr CLI. Never commit on your own initiative. changeset_discard deletes staged work for good; use it only when the user asks.`;\n"],
+  "mappings": "AAMO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;",
+  "names": []
+}

package/dist/mcp/strict-schema.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+function editDistance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1)), diagonal = above;
+    }
+  }
+  return row[b.length];
+}
+function meantName(key, accepted) {
+  const lower = key.toLowerCase(), exact = accepted.find((name) => name.toLowerCase() === `${lower}id` || `${name.toLowerCase()}id` === lower || name.toLowerCase() === lower);
+  if (exact)
+    return exact;
+  const truncated = accepted.find((name) => {
+    const n = name.toLowerCase();
+    return Math.min(n.length, lower.length) >= 4 && (n.startsWith(lower) || lower.startsWith(n));
+  });
+  if (truncated)
+    return truncated;
+  const allowed = Math.min(2, Math.floor(key.length / 4));
+  let best;
+  for (const name of accepted) {
+    const distance = editDistance(lower, name.toLowerCase());
+    distance <= allowed && (!best || distance < best.distance) && (best = { name, distance });
+  }
+  return best?.name;
+}
+function hintFor(accepted, unknown) {
+  const hints = unknown.map((key) => {
+    const meant = meantName(key, accepted);
+    return meant ? `'${meant}' for '${key}'` : void 0;
+  }).filter((hint) => hint !== void 0);
+  return hints.length > 0 ? ` (did you mean ${hints.join(", ")}?)` : "";
+}
+function unknownArgumentsMessage(toolName, accepted, unknown) {
+  return `${toolName} doesn't take ${unknown.map((key) => `'${key}'`).join(", ")}${hintFor(accepted, unknown)}. It takes: ${accepted.join(", ")}.`;
+}
+function strictItem(what, shape) {
+  const accepted = Object.keys(shape);
+  return z.strictObject(shape, {
+    error: (issue) => issue.code === "unrecognized_keys" ? `${what} doesn't take ${issue.keys.map((key) => `'${key}'`).join(", ")}${hintFor(accepted, issue.keys)}. It takes: ${accepted.join(", ")}.` : void 0
+  });
+}
+export {
+  strictItem,
+  unknownArgumentsMessage
+};
+//# sourceMappingURL=strict-schema.js.map

package/dist/mcp/strict-schema.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mcp/strict-schema.ts"],
+  "sourcesContent": ["/**\n * Strict argument schemas for the MCP tools. A tool refuses an argument it doesn't take, at the\n * top level and inside the objects its arrays carry: the SDK would strip an unknown key, so a\n * misnamed argument (`changeset` for `changesetId`, `sourceSymbl` for `sourceSymbol`) silently\n * changed what the call did.\n */\n\nimport { z, type ZodRawShape } from \"zod\";\n\n/** Edit distance between two short strings (insertions, deletions, substitutions). */\nfunction editDistance(a: string, b: string): number {\n  const row = Array.from({ length: b.length + 1 }, (_, j) => j);\n  for (let i = 1; i <= a.length; i++) {\n    let diagonal = row[0];\n    row[0] = i;\n    for (let j = 1; j <= b.length; j++) {\n      const above = row[j];\n      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));\n      diagonal = above;\n    }\n  }\n  return row[b.length];\n}\n\n/**\n * The accepted name an unknown key most likely meant: the same name with or without an `Id`\n * suffix, in any case; one cut short or run on (`extract`); or one a couple of letters away\n * (`sourceSymbl`).\n */\nfunction meantName(key: string, accepted: string[]): string | undefined {\n  const lower = key.toLowerCase();\n  const exact = accepted.find(\n    (name) => name.toLowerCase() === `${lower}id` || `${name.toLowerCase()}id` === lower || name.toLowerCase() === lower\n  );\n  if (exact) return exact;\n  // A name cut short or run on (`extract` for `extracted`, `sections` for `section`).\n  const truncated = accepted.find((name) => {\n    const n = name.toLowerCase();\n    return Math.min(n.length, lower.length) >= 4 && (n.startsWith(lower) || lower.startsWith(n));\n  });\n  if (truncated) return truncated;\n  const allowed = Math.min(2, Math.floor(key.length / 4));\n  let best: { name: string; distance: number } | undefined;\n  for (const name of accepted) {\n    const distance = editDistance(lower, name.toLowerCase());\n    if (distance <= allowed && (!best || distance < best.distance)) best = { name, distance };\n  }\n  return best?.name;\n}\n\n/** \" (did you mean 'x' for 'y'?)\", or \"\" when no key has a likely match. */\nfunction hintFor(accepted: string[], unknown: string[]): string {\n  const hints = unknown\n    .map((key) => {\n      const meant = meantName(key, accepted);\n      return meant ? `'${meant}' for '${key}'` : undefined;\n    })\n    .filter((hint): hint is string => hint !== undefined);\n  return hints.length > 0 ? ` (did you mean ${hints.join(\", \")}?)` : \"\";\n}\n\n/** The message for arguments a tool doesn't take, with the argument that was probably meant. */\nexport function unknownArgumentsMessage(toolName: string, accepted: string[], unknown: string[]): string {\n  return `${toolName} doesn't take ${unknown.map((key) => `'${key}'`).join(\", \")}${hintFor(accepted, unknown)}. It takes: ${accepted.join(\", \")}.`;\n}\n\n/**\n * A strict object inside a tool's arguments (an `elements[]` item, `against`): a key it doesn't\n * take is refused, naming where it was (`what`), the likely match, and the keys it does take.\n */\nexport function strictItem<T extends ZodRawShape>(what: string, shape: T) {\n  const accepted = Object.keys(shape);\n  return z.strictObject(shape, {\n    error: (issue) =>\n      issue.code === \"unrecognized_keys\"\n        ? `${what} doesn't take ${issue.keys.map((key) => `'${key}'`).join(\", \")}${hintFor(accepted, issue.keys)}. It takes: ${accepted.join(\", \")}.`\n        : undefined,\n  });\n}\n"],
+  "mappings": "AAOA,SAAS,SAA2B;AAGpC,SAAS,aAAa,GAAW,GAAS;AACxC,QAAM,MAAM,MAAM,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAC,GAAI,CAAC,GAAG,MAAM,CAAC;AAC5D,WAAS,IAAI,GAAG,KAAK,EAAE,QAAQ,KAAK;AAClC,QAAI,WAAW,IAAI,CAAC;AACpB,QAAI,CAAC,IAAI;AACT,aAAS,IAAI,GAAG,KAAK,EAAE,QAAQ,KAAK;AAClC,YAAM,QAAQ,IAAI,CAAC;AACnB,UAAI,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,GAAG,YAAY,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,IAAI,EAAE,GACxF,WAAW;IACb;EACF;AACA,SAAO,IAAI,EAAE,MAAM;AACrB;AAOA,SAAS,UAAU,KAAa,UAAkB;AAChD,QAAM,QAAQ,IAAI,YAAW,GACvB,QAAQ,SAAS,KACrB,CAAC,SAAS,KAAK,YAAW,MAAO,GAAG,KAAK,QAAQ,GAAG,KAAK,YAAW,CAAE,SAAS,SAAS,KAAK,YAAW,MAAO,KAAK;AAEtH,MAAI;AAAO,WAAO;AAElB,QAAM,YAAY,SAAS,KAAK,CAAC,SAAQ;AACvC,UAAM,IAAI,KAAK,YAAW;AAC1B,WAAO,KAAK,IAAI,EAAE,QAAQ,MAAM,MAAM,KAAK,MAAM,EAAE,WAAW,KAAK,KAAK,MAAM,WAAW,CAAC;EAC5F,CAAC;AACD,MAAI;AAAW,WAAO;AACtB,QAAM,UAAU,KAAK,IAAI,GAAG,KAAK,MAAM,IAAI,SAAS,CAAC,CAAC;AACtD,MAAI;AACJ,aAAW,QAAQ,UAAU;AAC3B,UAAM,WAAW,aAAa,OAAO,KAAK,YAAW,CAAE;AACvD,IAAI,YAAY,YAAY,CAAC,QAAQ,WAAW,KAAK,cAAW,OAAO,EAAE,MAAM,SAAQ;EACzF;AACA,SAAO,MAAM;AACf;AAGA,SAAS,QAAQ,UAAoB,SAAiB;AACpD,QAAM,QAAQ,QACX,IAAI,CAAC,QAAO;AACX,UAAM,QAAQ,UAAU,KAAK,QAAQ;AACrC,WAAO,QAAQ,IAAI,KAAK,UAAU,GAAG,MAAM;EAC7C,CAAC,EACA,OAAO,CAAC,SAAyB,SAAS,MAAS;AACtD,SAAO,MAAM,SAAS,IAAI,kBAAkB,MAAM,KAAK,IAAI,CAAC,OAAO;AACrE;AAGM,SAAU,wBAAwB,UAAkB,UAAoB,SAAiB;AAC7F,SAAO,GAAG,QAAQ,iBAAiB,QAAQ,IAAI,CAAC,QAAQ,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,CAAC,GAAG,QAAQ,UAAU,OAAO,CAAC,eAAe,SAAS,KAAK,IAAI,CAAC;AAC/I;AAMM,SAAU,WAAkC,MAAc,OAAQ;AACtE,QAAM,WAAW,OAAO,KAAK,KAAK;AAClC,SAAO,EAAE,aAAa,OAAO;IAC3B,OAAO,CAAC,UACN,MAAM,SAAS,sBACX,GAAG,IAAI,iBAAiB,MAAM,KAAK,IAAI,CAAC,QAAQ,IAAI,GAAG,GAAG,EAAE,KAAK,IAAI,CAAC,GAAG,QAAQ,UAAU,MAAM,IAAI,CAAC,eAAe,SAAS,KAAK,IAAI,CAAC,MACxI;GACP;AACH;",
+  "names": []
+}

package/dist/mcp/tool-registry.js

@@ -1,9 +1,18 @@
+import { z } from "zod";
 import { isTelemetryEnabled, startActiveSpan } from "../telemetry/index.js";
+import { unknownArgumentsMessage } from "./strict-schema.js";
 import { annotationCreateTool, annotationDeleteTool, annotationGetTool, annotationListTool, annotationReplyTool, annotationUpdateTool, changesetActivateTool, changesetBriefTool, changesetCreateTool, changesetDeactivateTool, changesetImpactTool, changesetListTool, changesetShowTool, chatLaunchTool, chatStatusTool, modelAddTool, modelDeleteTool, modelExportTool, modelInfoTool, modelListTool, modelReloadTool, modelSearchTool, modelShowTool, modelStatsTool, modelTraceTool, modelUpdateTool, modelValidateTool, relationshipAddTool, relationshipDeleteTool, specTypeTool } from "./tools/index.js";
 import { changesetDiscardTool, changesetUnstageTool, changesetUpdateTool } from "./tools/index.js";
 import { changesetVerifyTool } from "./tools/index.js";
-import { errorResult, loadModel } from "./tools/shared.js";
+import { projectInitTool, projectUpgradeTool } from "./tools/index.js";
+import { codebaseIndexTool, codebaseVerifyTool } from "./tools/index.js";
+import { changesetCommitTool } from "./tools/index.js";
+import { reviewOpenTool } from "./tools/index.js";
+import { projectStatusTool } from "./tools/index.js";
+import { codebaseExtractTool } from "./tools/index.js";
+import { errorResult, loadModel, rootPathSchema } from "./tools/shared.js";
 import { changesetOnlyRefusal } from "./changeset-only.js";
+import { whenProjectRootSettled } from "./project-root.js";
 const MODEL_TOOLS = [
   modelListTool,
   modelShowTool,
@@ -38,14 +47,36 @@ const MODEL_TOOLS = [
   changesetUpdateTool,
   changesetUnstageTool,
   changesetDiscardTool,
-  changesetVerifyTool
+  changesetVerifyTool,
+  projectInitTool,
+  projectUpgradeTool,
+  codebaseIndexTool,
+  codebaseVerifyTool,
+  changesetCommitTool,
+  reviewOpenTool,
+  projectStatusTool,
+  codebaseExtractTool
 ];
+function registeredToolNames() {
+  return MODEL_TOOLS.map((tool) => tool.name);
+}
+function registeredInputSchema(toolName, shape) {
+  const full = "rootPath" in shape ? shape : { ...shape, rootPath: rootPathSchema }, accepted = Object.keys(full);
+  return z.strictObject(full, {
+    error: (issue) => issue.code === "unrecognized_keys" ? unknownArgumentsMessage(toolName, accepted, issue.keys) : void 0
+  });
+}
 class McpToolRegistry {
   /** Registers every model tool onto the given MCP server instance. */
   registerAll(server) {
     for (const tool of MODEL_TOOLS)
-      server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, (args) => startActiveSpan(`mcp.tool.${tool.name}`, async (span) => {
-        const refusal = await changesetOnlyRefusal(tool.name, args.rootPath, loadModel), result = refusal ? errorResult(refusal) : await tool.handler(args);
+      server.registerTool(tool.name, {
+        description: tool.description,
+        inputSchema: registeredInputSchema(tool.name, tool.inputSchema),
+        ...tool._meta ? { _meta: tool._meta } : {}
+      }, (args, extra) => startActiveSpan(`mcp.tool.${tool.name}`, async (span) => {
+        await whenProjectRootSettled();
+        const refusal = await changesetOnlyRefusal(tool.name, args.rootPath, loadModel), result = refusal ? errorResult(refusal) : await tool.handler(args, { server: server.server, requestId: extra?.requestId, signal: extra?.signal });
         if (isTelemetryEnabled && result?.isError) {
           const firstContent = result.content?.[0], message = firstContent?.type === "text" ? firstContent.text : "Tool returned an error";
           span.setStatus({ code: 2, message });
@@ -55,6 +86,9 @@ class McpToolRegistry {
   }
 }
 export {
-  McpToolRegistry
+  McpToolRegistry,
+  registeredInputSchema,
+  registeredToolNames,
+  unknownArgumentsMessage
 };
 //# sourceMappingURL=tool-registry.js.map

package/dist/mcp/tool-registry.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/mcp/tool-registry.ts"],
-  "sourcesContent": ["/**\n * McpToolRegistry \u2014 registers the DR model tool surface onto an MCP server.\n *\n * Read-only tools: model_list, model_show, model_search, model_stats,\n * model_info, model_trace.\n * Mutation tools: model_add, model_update, model_delete (via MutationHandler).\n * Pipeline tools: model_validate, model_export (via the shared validator\n * pipeline and export handlers).\n * Lifecycle tools: model_reload (force a full re-read from disk).\n * Changeset tools: changeset_list, changeset_show (via StagingAreaManager).\n * Change-modeling tools (docs/CHANGE_MODELING.md): changeset_create, changeset_activate,\n * changeset_deactivate, relationship_add, relationship_delete, spec_type, changeset_impact,\n * changeset_brief, changeset_verify. Commit and apply are deliberately not exposed: landing a change\n * is the human's step.\n * Changeset editing (changeset-editing.ts): changeset_update, changeset_unstage, and\n * changeset_discard (requires confirm: true; it deletes the staged changes).\n * Chat tools: chat_status, chat_launch (via the coding-agents chat clients).\n * Annotation tools: annotation_list, annotation_get, annotation_create,\n * annotation_update, annotation_delete, annotation_reply (via AnnotationStore),\n * mirroring the REST server's /api/annotations/* endpoints.\n */\n\nimport type { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { isTelemetryEnabled, startActiveSpan } from \"../telemetry/index.js\";\nimport {\n  annotationCreateTool,\n  annotationDeleteTool,\n  annotationGetTool,\n  annotationListTool,\n  annotationReplyTool,\n  annotationUpdateTool,\n  changesetActivateTool,\n  changesetBriefTool,\n  changesetCreateTool,\n  changesetDeactivateTool,\n  changesetImpactTool,\n  changesetListTool,\n  changesetShowTool,\n  chatLaunchTool,\n  chatStatusTool,\n  modelAddTool,\n  modelDeleteTool,\n  modelExportTool,\n  modelInfoTool,\n  modelListTool,\n  modelReloadTool,\n  modelSearchTool,\n  modelShowTool,\n  modelStatsTool,\n  modelTraceTool,\n  modelUpdateTool,\n  modelValidateTool,\n  relationshipAddTool,\n  relationshipDeleteTool,\n  specTypeTool,\n  type McpToolDefinition,\n} from \"./tools/index.js\";\nimport { changesetDiscardTool, changesetUnstageTool, changesetUpdateTool } from \"./tools/index.js\";\nimport { changesetVerifyTool } from \"./tools/index.js\";\nimport { errorResult, loadModel } from \"./tools/shared.js\";\nimport { changesetOnlyRefusal } from \"./changeset-only.js\";\n\nconst MODEL_TOOLS: McpToolDefinition[] = [\n  modelListTool,\n  modelShowTool,\n  modelSearchTool,\n  modelStatsTool,\n  modelInfoTool,\n  modelTraceTool,\n  modelAddTool,\n  modelUpdateTool,\n  modelDeleteTool,\n  modelValidateTool,\n  modelExportTool,\n  modelReloadTool,\n  changesetListTool,\n  changesetShowTool,\n  changesetCreateTool,\n  changesetActivateTool,\n  changesetDeactivateTool,\n  relationshipAddTool,\n  relationshipDeleteTool,\n  specTypeTool,\n  changesetImpactTool,\n  changesetBriefTool,\n  chatStatusTool,\n  chatLaunchTool,\n  annotationListTool,\n  annotationGetTool,\n  annotationCreateTool,\n  annotationUpdateTool,\n  annotationDeleteTool,\n  annotationReplyTool,\n  changesetUpdateTool,\n  changesetUnstageTool,\n  changesetDiscardTool,\n  changesetVerifyTool,\n];\n\nexport class McpToolRegistry {\n  /** Registers every model tool onto the given MCP server instance. */\n  registerAll(server: McpServer): void {\n    for (const tool of MODEL_TOOLS) {\n      server.registerTool(\n        tool.name,\n        { description: tool.description, inputSchema: tool.inputSchema },\n        (args: Parameters<typeof tool.handler>[0]) =>\n          startActiveSpan(\n            `mcp.tool.${tool.name}`,\n            async (span) => {\n              // Changeset-only mode (DR_CHANGESET_ONLY): refuse base-model writes up front.\n              const refusal = await changesetOnlyRefusal(tool.name, (args as { rootPath?: string }).rootPath, loadModel);\n              const result = refusal ? errorResult(refusal) : await tool.handler(args);\n              if (isTelemetryEnabled && result?.isError) {\n                const firstContent = result.content?.[0];\n                const message =\n                  firstContent?.type === \"text\" ? firstContent.text : \"Tool returned an error\";\n                span.setStatus({ code: 2, message });\n              }\n              return result;\n            },\n            { \"mcp.tool.name\": tool.name }\n          )\n      );\n    }\n  }\n}\n"],
-  "mappings": "AAuBA,SAAS,oBAAoB,uBAAuB;AACpD,SACE,sBACA,sBACA,mBACA,oBACA,qBACA,sBACA,uBACA,oBACA,qBACA,yBACA,qBACA,mBACA,mBACA,gBACA,gBACA,cACA,iBACA,iBACA,eACA,eACA,iBACA,iBACA,eACA,gBACA,gBACA,iBACA,mBACA,qBACA,wBACA,oBAEK;AACP,SAAS,sBAAsB,sBAAsB,2BAA2B;AAChF,SAAS,2BAA2B;AACpC,SAAS,aAAa,iBAAiB;AACvC,SAAS,4BAA4B;AAErC,MAAM,cAAmC;EACvC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGI,MAAO,gBAAe;;EAE1B,YAAY,QAAiB;AAC3B,eAAW,QAAQ;AACjB,aAAO,aACL,KAAK,MACL,EAAE,aAAa,KAAK,aAAa,aAAa,KAAK,YAAW,GAC9D,CAAC,SACC,gBACE,YAAY,KAAK,IAAI,IACrB,OAAO,SAAQ;AAEb,cAAM,UAAU,MAAM,qBAAqB,KAAK,MAAO,KAA+B,UAAU,SAAS,GACnG,SAAS,UAAU,YAAY,OAAO,IAAI,MAAM,KAAK,QAAQ,IAAI;AACvE,YAAI,sBAAsB,QAAQ,SAAS;AACzC,gBAAM,eAAe,OAAO,UAAU,CAAC,GACjC,UACJ,cAAc,SAAS,SAAS,aAAa,OAAO;AACtD,eAAK,UAAU,EAAE,MAAM,GAAG,QAAO,CAAE;QACrC;AACA,eAAO;MACT,GACA,EAAE,iBAAiB,KAAK,KAAI,CAAE,CAC/B;EAGT;;",
+  "sourcesContent": ["/**\n * McpToolRegistry \u2014 registers the DR model tool surface onto an MCP server.\n *\n * Read-only tools: model_list, model_show, model_search, model_stats,\n * model_info, model_trace.\n * Mutation tools: model_add, model_update, model_delete (via MutationHandler).\n * Pipeline tools: model_validate, model_export (via the shared validator\n * pipeline and export handlers).\n * Lifecycle tools: model_reload (force a full re-read from disk).\n * Changeset tools: changeset_list, changeset_show (via StagingAreaManager).\n * Change-modeling tools (docs/CHANGE_MODELING.md): changeset_create, changeset_activate,\n * changeset_deactivate, relationship_add, relationship_delete, spec_type, changeset_impact,\n * changeset_brief, changeset_verify. Apply is not exposed.\n * Landing (changeset-commit.ts): changeset_commit commits a staged changeset only after a person\n * confirms it in an elicitation dialog. It is listed with _meta \"anthropic/requiresUserInteraction\",\n * is refused in changeset-only mode, and is never on DrBot's allowlists.\n * Changeset editing (changeset-editing.ts): changeset_update, changeset_unstage, and\n * changeset_discard (requires confirm: true; it deletes the staged changes).\n * Chat tools: chat_status, chat_launch (via the coding-agents chat clients).\n * Codebase tools: codebase_index (starts a background index and returns at once; poll with\n * status: true), codebase_verify (the code's routes against the model's API). Neither writes the model.\n * codebase_extract stages what the extraction cascade finds into an as-built changeset (never the base).\n * Annotation tools: annotation_list, annotation_get, annotation_create,\n * annotation_update, annotation_delete, annotation_reply (via AnnotationStore),\n * mirroring the REST server's /api/annotations/* endpoints.\n * Project tools (project-tools.ts): project_init (create a model, no prompts) and\n * project_upgrade (preview a spec migration; apply it with apply: true).\n * Review tools: review_open (a viewer link to a changeset; reuses or starts `dr visualize`).\n * Project tools: project_status (where the repo stands with DR, and the next step).\n */\n\nimport { z, type ZodRawShape } from \"zod\";\nimport type { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport type { RequestId } from \"@modelcontextprotocol/sdk/types.js\";\nimport { isTelemetryEnabled, startActiveSpan } from \"../telemetry/index.js\";\nimport { unknownArgumentsMessage } from \"./strict-schema.js\";\nimport {\n  annotationCreateTool,\n  annotationDeleteTool,\n  annotationGetTool,\n  annotationListTool,\n  annotationReplyTool,\n  annotationUpdateTool,\n  changesetActivateTool,\n  changesetBriefTool,\n  changesetCreateTool,\n  changesetDeactivateTool,\n  changesetImpactTool,\n  changesetListTool,\n  changesetShowTool,\n  chatLaunchTool,\n  chatStatusTool,\n  modelAddTool,\n  modelDeleteTool,\n  modelExportTool,\n  modelInfoTool,\n  modelListTool,\n  modelReloadTool,\n  modelSearchTool,\n  modelShowTool,\n  modelStatsTool,\n  modelTraceTool,\n  modelUpdateTool,\n  modelValidateTool,\n  relationshipAddTool,\n  relationshipDeleteTool,\n  specTypeTool,\n  type McpToolDefinition,\n} from \"./tools/index.js\";\nimport { changesetDiscardTool, changesetUnstageTool, changesetUpdateTool } from \"./tools/index.js\";\nimport { changesetVerifyTool } from \"./tools/index.js\";\nimport { projectInitTool, projectUpgradeTool } from \"./tools/index.js\";\nimport { codebaseIndexTool, codebaseVerifyTool } from \"./tools/index.js\";\nimport { changesetCommitTool } from \"./tools/index.js\";\nimport { reviewOpenTool } from \"./tools/index.js\";\nimport { projectStatusTool } from \"./tools/index.js\";\nimport { codebaseExtractTool } from \"./tools/index.js\";\nimport { errorResult, loadModel, rootPathSchema } from \"./tools/shared.js\";\nimport { changesetOnlyRefusal } from \"./changeset-only.js\";\nimport { whenProjectRootSettled } from \"./project-root.js\";\n\nconst MODEL_TOOLS: McpToolDefinition[] = [\n  modelListTool,\n  modelShowTool,\n  modelSearchTool,\n  modelStatsTool,\n  modelInfoTool,\n  modelTraceTool,\n  modelAddTool,\n  modelUpdateTool,\n  modelDeleteTool,\n  modelValidateTool,\n  modelExportTool,\n  modelReloadTool,\n  changesetListTool,\n  changesetShowTool,\n  changesetCreateTool,\n  changesetActivateTool,\n  changesetDeactivateTool,\n  relationshipAddTool,\n  relationshipDeleteTool,\n  specTypeTool,\n  changesetImpactTool,\n  changesetBriefTool,\n  chatStatusTool,\n  chatLaunchTool,\n  annotationListTool,\n  annotationGetTool,\n  annotationCreateTool,\n  annotationUpdateTool,\n  annotationDeleteTool,\n  annotationReplyTool,\n  changesetUpdateTool,\n  changesetUnstageTool,\n  changesetDiscardTool,\n  changesetVerifyTool,\n  projectInitTool,\n  projectUpgradeTool,\n  codebaseIndexTool,\n  codebaseVerifyTool,\n  changesetCommitTool,\n  reviewOpenTool,\n  projectStatusTool,\n  codebaseExtractTool,\n];\n\n/** Names of every tool the registry registers. */\nexport function registeredToolNames(): string[] {\n  return MODEL_TOOLS.map((tool) => tool.name);\n}\n\nexport { unknownArgumentsMessage };\n\n/**\n * The schema a tool is registered with: its arguments plus the optional rootPath every tool takes,\n * strict, so tools/list says no other argument is accepted and a call with one is refused with\n * unknownArgumentsMessage.\n */\nexport function registeredInputSchema(toolName: string, shape: ZodRawShape) {\n  const full: ZodRawShape = \"rootPath\" in shape ? shape : { ...shape, rootPath: rootPathSchema };\n  const accepted = Object.keys(full);\n  return z.strictObject(full, {\n    error: (issue) =>\n      issue.code === \"unrecognized_keys\" ? unknownArgumentsMessage(toolName, accepted, issue.keys) : undefined,\n  });\n}\n\nexport class McpToolRegistry {\n  /** Registers every model tool onto the given MCP server instance. */\n  registerAll(server: McpServer): void {\n    for (const tool of MODEL_TOOLS) {\n      server.registerTool(\n        tool.name,\n        {\n          description: tool.description,\n          inputSchema: registeredInputSchema(tool.name, tool.inputSchema),\n          ...(tool._meta ? { _meta: tool._meta } : {}),\n        },\n        (args: Parameters<typeof tool.handler>[0], extra?: { requestId?: RequestId; signal?: AbortSignal }) =>\n          startActiveSpan(\n            `mcp.tool.${tool.name}`,\n            async (span) => {\n              // Tools that don't load the model still read the project from the working\n              // directory, so wait until the client's roots have settled which project that is.\n              await whenProjectRootSettled();\n              // Changeset-only mode (DR_CHANGESET_ONLY): refuse base-model writes up front.\n              const refusal = await changesetOnlyRefusal(tool.name, (args as { rootPath?: string }).rootPath, loadModel);\n              const result = refusal\n                ? errorResult(refusal)\n                : await tool.handler(args, { server: server.server, requestId: extra?.requestId, signal: extra?.signal });\n              if (isTelemetryEnabled && result?.isError) {\n                const firstContent = result.content?.[0];\n                const message =\n                  firstContent?.type === \"text\" ? firstContent.text : \"Tool returned an error\";\n                span.setStatus({ code: 2, message });\n              }\n              return result;\n            },\n            { \"mcp.tool.name\": tool.name }\n          )\n      );\n    }\n  }\n}\n"],
+  "mappings": "AA+BA,SAAS,SAA2B;AAGpC,SAAS,oBAAoB,uBAAuB;AACpD,SAAS,+BAA+B;AACxC,SACE,sBACA,sBACA,mBACA,oBACA,qBACA,sBACA,uBACA,oBACA,qBACA,yBACA,qBACA,mBACA,mBACA,gBACA,gBACA,cACA,iBACA,iBACA,eACA,eACA,iBACA,iBACA,eACA,gBACA,gBACA,iBACA,mBACA,qBACA,wBACA,oBAEK;AACP,SAAS,sBAAsB,sBAAsB,2BAA2B;AAChF,SAAS,2BAA2B;AACpC,SAAS,iBAAiB,0BAA0B;AACpD,SAAS,mBAAmB,0BAA0B;AACtD,SAAS,2BAA2B;AACpC,SAAS,sBAAsB;AAC/B,SAAS,yBAAyB;AAClC,SAAS,2BAA2B;AACpC,SAAS,aAAa,WAAW,sBAAsB;AACvD,SAAS,4BAA4B;AACrC,SAAS,8BAA8B;AAEvC,MAAM,cAAmC;EACvC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAII,SAAU,sBAAmB;AACjC,SAAO,YAAY,IAAI,CAAC,SAAS,KAAK,IAAI;AAC5C;AASM,SAAU,sBAAsB,UAAkB,OAAkB;AACxE,QAAM,OAAoB,cAAc,QAAQ,QAAQ,EAAE,GAAG,OAAO,UAAU,eAAc,GACtF,WAAW,OAAO,KAAK,IAAI;AACjC,SAAO,EAAE,aAAa,MAAM;IAC1B,OAAO,CAAC,UACN,MAAM,SAAS,sBAAsB,wBAAwB,UAAU,UAAU,MAAM,IAAI,IAAI;GAClG;AACH;AAEM,MAAO,gBAAe;;EAE1B,YAAY,QAAiB;AAC3B,eAAW,QAAQ;AACjB,aAAO,aACL,KAAK,MACL;QACE,aAAa,KAAK;QAClB,aAAa,sBAAsB,KAAK,MAAM,KAAK,WAAW;QAC9D,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,MAAK,IAAK,CAAA;SAE3C,CAAC,MAA0C,UACzC,gBACE,YAAY,KAAK,IAAI,IACrB,OAAO,SAAQ;AAGb,cAAM,uBAAsB;AAE5B,cAAM,UAAU,MAAM,qBAAqB,KAAK,MAAO,KAA+B,UAAU,SAAS,GACnG,SAAS,UACX,YAAY,OAAO,IACnB,MAAM,KAAK,QAAQ,MAAM,EAAE,QAAQ,OAAO,QAAQ,WAAW,OAAO,WAAW,QAAQ,OAAO,OAAM,CAAE;AAC1G,YAAI,sBAAsB,QAAQ,SAAS;AACzC,gBAAM,eAAe,OAAO,UAAU,CAAC,GACjC,UACJ,cAAc,SAAS,SAAS,aAAa,OAAO;AACtD,eAAK,UAAU,EAAE,MAAM,GAAG,QAAO,CAAE;QACrC;AACA,eAAO;MACT,GACA,EAAE,iBAAiB,KAAK,KAAI,CAAE,CAC/B;EAGT;;",
   "names": []
 }