@documentation-robotics/cli 0.2.0 → 0.4.0

package/dist/mcp/tools/changeset-analysis-tools.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-analysis-tools.ts"],
+  "sourcesContent": ["/**\n * changeset_impact, changeset_brief \u2014 pressure-test a planned change against the model.\n * See `cli/src/core/changeset-analysis.ts` and docs/CHANGE_MODELING.md.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { AnnotationStore } from \"../../core/annotation-store.js\";\nimport {\n  buildBrief,\n  computeImpact,\n  computeUnwired,\n  DEFAULT_HUB_THRESHOLD,\n  type BriefDrift,\n} from \"../../core/changeset-analysis.js\";\nimport { briefDelta } from \"../../core/changeset-brief-delta.js\";\nimport { BRIEF_SECTIONS, briefSections, compactBrief } from \"../../core/changeset-brief-compact.js\";\nimport { describeDrift } from \"../../core/changeset-base-index.js\";\nimport { getErrorMessage } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\nimport { loadChangesetGraph } from \"./changeset-shared.js\";\n\nconst changesetIdSchema = z.string().optional().describe(\"Changeset ID or name. Defaults to the active changeset.\");\n\n// ---------------------------------------------------------------------------\n// changeset_impact\n// ---------------------------------------------------------------------------\n\nconst impactInputSchema = {\n  changesetId: changesetIdSchema,\n  depth: z.number().int().min(1).max(6).optional().describe(\"Hops to walk out from the changed elements (default 2).\"),\n  maxElements: z.number().int().positive().optional().describe(\"Stop after this many reached elements (default 200).\"),\n  from: z\n    .array(z.string())\n    .optional()\n    .describe(\n      \"Element ids or paths to walk from instead of every changed element. Ids the projected model does not have \" +\n        \"are listed in unknownFrom.\"\n    ),\n  hubThreshold: z\n    .number()\n    .int()\n    .min(0)\n    .optional()\n    .describe(\n      `An element with more relationships than this is a hub: listed in hubs with its degree and not walked ` +\n        `through (default ${DEFAULT_HUB_THRESHOLD}).`\n    ),\n  expandHubs: z.boolean().optional().describe(\"Walk through hubs too (default false).\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetImpactArgs = z.infer<z.ZodObject<typeof impactInputSchema>>;\n\nexport async function changesetImpactHandler(args: ChangesetImpactArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const { changeset, graph } = await loadChangesetGraph(model, args.changesetId);\n    const report = computeImpact(graph, {\n      depth: args.depth,\n      maxElements: args.maxElements,\n      from: args.from,\n      hubThreshold: args.hubThreshold,\n      expandHubs: args.expandHubs,\n    });\n    return jsonResult({ changeset: { id: changeset.id, name: changeset.name }, ...report });\n  });\n}\n\nexport const changesetImpactTool: McpToolDefinition<typeof impactInputSchema> = {\n  name: \"changeset_impact\",\n  description:\n    \"Walk the model outward from everything a changeset adds, changes or removes (relationships included), or \" +\n    \"from the elements named in `from`, and list the existing elements it reaches, by layer, with how each was \" +\n    \"reached and its source files, plus how many each hop reached (perHop). These are what the change can break \" +\n    \"or must update. Hubs (elements with more than hubThreshold relationships) are listed with their degree and \" +\n    \"not walked through unless expandHubs is set.\",\n  inputSchema: impactInputSchema,\n  handler: changesetImpactHandler,\n};\n\n// ---------------------------------------------------------------------------\n// changeset_brief\n// ---------------------------------------------------------------------------\n\nconst briefInputSchema = {\n  changesetId: changesetIdSchema,\n  unwired: z\n    .enum([\"summary\", \"full\", \"none\"])\n    .optional()\n    .describe(\n      \"Unwired connections (catalog connections an added or updated element has no relationship for). The compact \" +\n        \"brief counts them per layer unless this is set. summary (the full brief's default) counts them per element \" +\n        \"and layer and lists the ones in layers the change already reaches whose other type the model has (existing \" +\n        \"or added), counting the rest as typesNotInModel; full lists them all; none omits them.\"\n    ),\n  unwiredLayers: z\n    .array(z.string())\n    .optional()\n    .describe(\"Only show unwired connections whose other end is in these layers (and list them).\"),\n  detail: z\n    .enum([\"compact\", \"full\"])\n    .optional()\n    .describe(\n      \"compact (default): counts by layer, reach, gaps one line each, intent as ids, drift, unwired counts per \" +\n        \"layer, and each changed element with its connections as `predicate \u2192 id` lines. full: the whole brief \" +\n        \"(attributes, connection names and layers, unwired listing, code per element).\"\n    ),\n  sections: z\n    .array(z.enum(BRIEF_SECTIONS))\n    .optional()\n    .describe(\n      \"Return only these sections, each in full, with a small header (revision, the changeset's id, name and status, \" +\n        \"summary counts). [\\\"changes\\\"] is the build view: each changed element with its name, description, attributes, \" +\n        \"changed fields (before and after), files and connections as `predicate \u2192 id` lines. Others: [\\\"drift\\\", \" +\n        \"\\\"alreadyInBase\\\"], [\\\"unwired\\\"], [\\\"layers\\\"] (the full brief's layers, large). With since, the delta comes too.\"\n    ),\n  layers: z\n    .array(z.string())\n    .optional()\n    .describe(\n      \"With sections: only the elements in these layers (canonical layer names), in changes, layers, gaps, unwired, \" +\n        \"intent and feedback. Combines with ids (either keeps an element).\"\n    ),\n  ids: z\n    .array(z.string())\n    .optional()\n    .describe(\"With sections: only these changed elements (ids), in changes, layers, gaps, unwired, intent and feedback.\"),\n  since: z\n    .union([z.number().int().min(-1), z.string().regex(/^(-1|\\d+):[0-9a-f]+$/, \"a revisionToken from a brief\")])\n    .optional()\n    .describe(\n      \"A revision (or, better, the revisionToken) an earlier brief returned. Adds a delta: elements added, removed \" +\n        \"or updated (with the fields), relationships added or removed, changes unstaged, gaps opened and closed, \" +\n        \"unwired connections wired, layers newly reached or no longer reached, intent newly traced since then. \" +\n        \"Unstaging does not invalidate it. With the token, the delta warns when a change up to that revision was \" +\n        \"rewritten in place since.\"\n    ),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetBriefArgs = z.infer<z.ZodObject<typeof briefInputSchema>>;\n\nexport async function changesetBriefHandler(args: ChangesetBriefArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const { manager, changeset, graph } = await loadChangesetGraph(model, args.changesetId);\n\n    const annotations = await new AnnotationStore(model.rootPath).list();\n\n    let drift: BriefDrift | undefined;\n    if (changeset.status === \"staged\") {\n      // Each part is reported on failure and the brief goes on: the hash check, then the structured view.\n      let hash: { isDrifted: boolean; warnings: string[]; baseSnapshotId?: string; currentSnapshotId?: string };\n      try {\n        hash = await manager.detectDrift(changeset.id);\n      } catch (error) {\n        hash = { isDrifted: false, warnings: [`Drift check failed: ${getErrorMessage(error)}`] };\n      }\n      try {\n        drift = await describeDrift(model, graph, hash);\n      } catch (error) {\n        drift = {\n          isDrifted: hash.isDrifted,\n          warnings: [...hash.warnings, `Could not name what drifted: ${getErrorMessage(error)}`],\n        };\n      }\n    }\n\n    if (args.detail === \"full\") {\n      const brief = buildBrief({ graph, annotations, drift, unwired: args.unwired, unwiredLayers: args.unwiredLayers });\n      // The full brief is the largest result: same JSON, short objects kept on one line.\n      if (args.since === undefined) return jsonResult(brief, { compact: true });\n      return jsonResult({ ...brief, delta: await briefDelta(model, { graph, brief }, args.since) }, { compact: true });\n    }\n\n    // Compact: the unwired listing only when asked for; otherwise counted per layer.\n    const sections = args.sections ?? [];\n    const listUnwired = args.unwired !== undefined || args.unwiredLayers !== undefined || sections.includes(\"unwired\");\n    const brief = buildBrief({\n      graph,\n      annotations,\n      drift,\n      unwired: listUnwired ? (args.unwired ?? \"summary\") : \"none\",\n      unwiredLayers: args.unwiredLayers,\n    });\n    const delta = args.since === undefined ? undefined : await briefDelta(model, { graph, brief }, args.since);\n    if (sections.length > 0) {\n      // Only what was asked for; an unwired listing asked for by its own arguments counts as asked.\n      const named = listUnwired && !sections.includes(\"unwired\") && args.unwired !== \"none\" ? [...sections, \"unwired\" as const] : sections;\n      return jsonResult(briefSections(brief, named, { delta, filter: { layers: args.layers, ids: args.ids } }), { compact: true });\n    }\n    const compact = compactBrief(brief, { unwired: listUnwired ? undefined : computeUnwired(graph), delta });\n    if (args.layers?.length || args.ids?.length) {\n      compact.note =\n        \"layers and ids narrow sections output only, so the whole compact brief is returned. Pass sections too, \" +\n        'e.g. sections: [\"changes\"] with them for those elements\\' build view.';\n    }\n    return jsonResult(compact, { compact: true });\n  });\n}\n\nexport const changesetBriefTool: McpToolDefinition<typeof briefInputSchema> = {\n  name: \"changeset_brief\",\n  description:\n    \"Render a changeset as the spec for its change. By default a compact summary: counts by layer and operation; \" +\n    \"which layers the change reaches and which it does not; gaps, one line each (unconnected additions, missing \" +\n    \"required relationships, connections its peers have); intent as ids (traced, untraced, unanchored: changes \" +\n    \"that reach no goal, requirement or feature, or only an added one that itself traces to nothing); drift since \" +\n    \"the changeset was created; unwired connections (catalog connections an added or updated element has no \" +\n    \"relationship for) counted per layer; the files of the changed elements; open review annotations; and each \" +\n    \"changed element with its type, operation and connections as `predicate \u2192 id` lines (for a plan of more \" +\n    \"than 60 elements, counts per type with the first ids of each, and long id lists cut with their counts). \" +\n    \"detail: \\\"full\\\" returns the whole brief (attributes, connection names, the unwired listing, code per \" +\n    \"element); sections: [...] returns only the sections named, in full, with a small header. It returns a revision and a revisionToken: pass the token back as since on the \" +\n    \"next pass to get what changed. Use it to pressure-test a plan and, at the start of a build, as its spec.\",\n  inputSchema: briefInputSchema,\n  handler: changesetBriefHandler,\n};\n"],
+  "mappings": "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",
+  "names": ["brief"]
+}

package/dist/mcp/tools/changeset-commit.js

@@ -0,0 +1,224 @@
+import { z } from "zod";
+import { Model } from "../../core/model.js";
+import { BaseSnapshotManager } from "../../core/base-snapshot-manager.js";
+import { ChangesetGraph } from "../../core/changeset-graph.js";
+import { describeDrift } from "../../core/changeset-base-index.js";
+import { StagingAreaManager } from "../../core/staging-area.js";
+import { isChangesetOnly, CHANGESET_ONLY_ENV } from "../../core/changeset-only-guard.js";
+import { CLIError, ErrorCategory, getErrorMessage } from "../../utils/errors.js";
+import { jsonResult, loadModel, reloadModel, rootPathSchema, runTool } from "./shared.js";
+import { resolveChangeset } from "./changeset-shared.js";
+import { isExtractionChangeset } from "./codebase-extract.js";
+const CONFIRMATION_TIMEOUT_MS = 10 * 6e4;
+function otherWaysToLand() {
+  return [
+    "Ask the user to commit it in the viewer: call review_open, give them its url, and they press Apply on the changeset",
+    "Or ask them to run changeset_commit again from an interactive Claude Code session, where the confirmation dialog can be shown"
+  ];
+}
+const inputSchema = {
+  changeset: z.string().min(1).describe("Changeset ID or name to commit. Required: it need not be the active changeset."),
+  force: z.boolean().optional().describe("Commit even though the base model changed since the changeset was created (drift). The confirmation dialog shows the drift. Validation still blocks."),
+  rootPath: rootPathSchema
+}, OPERATION_LABELS = {
+  add: "adds",
+  update: "updates",
+  delete: "deletes",
+  "relationship-add": "relationship adds",
+  "relationship-delete": "relationship deletes"
+};
+function summarizeChangeset(changeset) {
+  const byOperation = {}, layers = /* @__PURE__ */ new Set();
+  for (const change of changeset.changes)
+    byOperation[change.type] = (byOperation[change.type] ?? 0) + 1, change.layerName && layers.add(change.layerName);
+  return { byOperation, layers: [...layers].sort() };
+}
+function driftLines(drift, hash, forced) {
+  const overlapping = drift ? drift.overlapping.elements.length + drift.overlapping.relationships.length : 0;
+  if (!hash.isDrifted && !drift?.isDrifted)
+    return ["Drift: none. The base model has not changed under this changeset."];
+  const lines = ["Drift: the base model changed since this changeset was created."], counts = drift?.baseChanges?.counts;
+  if (counts) {
+    const parts = [
+      [counts.elementsAdded, "elements added"],
+      [counts.elementsRemoved, "elements removed"],
+      [counts.elementsChanged, "elements changed"],
+      [counts.relationshipsAdded, "relationships added"],
+      [counts.relationshipsRemoved, "relationships removed"]
+    ].filter(([n]) => n > 0).map(([n, label]) => `${n} ${label}`);
+    parts.length > 0 && lines.push(`  In the base: ${parts.join(", ")}.`);
+  }
+  if (drift && overlapping > 0) {
+    const listed = [
+      ...drift.overlapping.elements.map((e) => `${e.id} (${e.reason})`),
+      ...drift.overlapping.relationships.map((r) => `${r.source} --${r.predicate}--> ${r.target} (${r.reason})`)
+    ];
+    lines.push(`  ${overlapping} staged change(s) overlap the base: ${listed.slice(0, 5).join(", ")}${overlapping > 5 ? ", ..." : ""}.`);
+  }
+  return hash.isDrifted ? forced && lines.push("  Committing anyway: force was passed.") : lines.push("  The drift check still passes, so this does not block the commit."), lines;
+}
+const EXTRACTION_MARKER = /Staged by codebase_extract/;
+async function madeByExtraction(rootPath, changeset) {
+  return EXTRACTION_MARKER.test(changeset.description ?? "") ? !0 : !!changeset.id && await isExtractionChangeset(rootPath, changeset.id, changeset.name);
+}
+async function asBuiltFirstWarning(manager, rootPath, changeset) {
+  if (!await madeByExtraction(rootPath, changeset))
+    return;
+  const plans = [];
+  for (const other of await manager.list())
+    other.id === changeset.id || other.status !== "staged" || other.changes.length === 0 || await madeByExtraction(rootPath, other) || plans.push(other);
+  if (plans.length === 0)
+    return;
+  const names = plans.map((plan) => `"${plan.name}"`).join(", ");
+  return `Warning: "${changeset.name}" is an as-built changeset from codebase_extract, and the plan ${names} is still staged. After verify, land the plan instead, and discard this one or keep it as a record. Landing this one first changes the plan's base: the plan then needs force, and its descriptions won't apply to the elements this one adds.`;
+}
+function confirmationMessage(changeset, drift, hash, preExistingErrors, forced, warnings = []) {
+  const { byOperation, layers } = summarizeChangeset(changeset), counts = Object.entries(byOperation).map(([type, n]) => `${n} ${OPERATION_LABELS[type] ?? type}`).join(", ");
+  return [
+    `Commit changeset "${changeset.name}" to the base model?`,
+    "",
+    ...warnings.flatMap((warning) => [warning, ""]),
+    `Intent: ${changeset.description?.trim() || "(no description)"}`,
+    `Changes: ${changeset.changes.length} (${counts})`,
+    `Layers: ${layers.join(", ") || "none"}`,
+    ...driftLines(drift, hash, forced),
+    preExistingErrors > 0 ? `Validation: passed. ${preExistingErrors} error(s) already in the base model are not counted.` : "Validation: passed.",
+    "",
+    "Committing writes these changes to the base model and marks the changeset committed."
+  ].join(`
+`);
+}
+async function confirmedState(model, changeset) {
+  return JSON.stringify({
+    changes: changeset.changes.map((c) => [c.sequenceNumber ?? null, c.type, c.elementId]),
+    lastSequence: changeset.lastSequence ?? null,
+    modified: changeset.modified,
+    status: changeset.status,
+    baseElements: await new BaseSnapshotManager().captureSnapshot(model),
+    baseRelationships: model.getBaseRelationships().map((r) => `${r.source}::${r.predicate}::${r.target}`).sort()
+  });
+}
+function refusal(message, suggestions) {
+  return new CLIError(message, ErrorCategory.USER, suggestions, { operation: "changeset_commit" });
+}
+function commitError(error, name) {
+  if (error instanceof CLIError)
+    return error;
+  const message = getErrorMessage(error);
+  return message.includes("drifted") ? new CLIError(`Changeset '${name}' was not committed: ${message.replace(/Use --force/, "Pass force: true")}`, ErrorCategory.USER, [
+    'Read the drift with "changeset_brief" and tell the user what changed in the base',
+    "If they still want it landed, call changeset_commit again with force: true"
+  ]) : message.startsWith("Validation failed") ? new CLIError(`Changeset '${name}' was not committed. ${message.replace(/, or skip validation with --no-validate\./, ".")}`, ErrorCategory.VALIDATION, ['Fix the plan (model_update, changeset_unstage, ...) and check it with "model_validate"']) : new CLIError(`Changeset '${name}' was not committed: ${message}`, ErrorCategory.SYSTEM);
+}
+async function askForConfirmation(context, message) {
+  return context.server.elicitInput({
+    mode: "form",
+    message,
+    requestedSchema: {
+      type: "object",
+      properties: {
+        confirm: {
+          type: "boolean",
+          title: "Commit this changeset",
+          description: "Write the staged changes to the base model.",
+          default: !1
+        }
+      },
+      required: ["confirm"]
+    }
+  }, { relatedRequestId: context.requestId, signal: context.signal, timeout: CONFIRMATION_TIMEOUT_MS });
+}
+async function changesetCommitHandler(args, context) {
+  return runTool(async () => {
+    if (isChangesetOnly())
+      throw refusal(`This session can't commit a changeset: it is in changeset-only mode (${CHANGESET_ONLY_ENV}), where no person can confirm the commit.`, ["Tell the user the changeset is ready to land", ...otherWaysToLand()]);
+    const rootPath = (await loadModel(args.rootPath)).rootPath;
+    let model = await Model.load(rootPath, { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model);
+    const changeset = await resolveChangeset(manager, args.changeset, "changeset");
+    if (changeset.status !== "staged")
+      throw new CLIError(`Changeset '${changeset.name}' is ${changeset.status}; only a staged changeset can be committed`, ErrorCategory.USER, [
+        'Use "changeset_list" to find a staged changeset'
+      ]);
+    if (changeset.changes.length === 0)
+      return jsonResult({ id: changeset.id, name: changeset.name, status: "nothing-to-commit", stagedChanges: 0 });
+    if (!context?.server?.getClientCapabilities()?.elicitation?.form)
+      throw refusal(`Changeset '${changeset.name}' was not committed: committing needs a person to confirm it, and this client can't show a confirmation dialog (it does not support MCP elicitation).`, otherWaysToLand());
+    const hash = await manager.detectDrift(changeset.id);
+    let drift;
+    try {
+      drift = await describeDrift(model, await ChangesetGraph.build(model, changeset), hash);
+    } catch (error) {
+      console.error(`[mcp] changeset_commit could not describe drift: ${getErrorMessage(error)}`);
+    }
+    if (hash.isDrifted && args.force !== !0)
+      throw new CLIError(`Changeset '${changeset.name}' was not committed: the base model changed since it was created.
+` + driftLines(drift, hash, !1).slice(1).join(`
+`), ErrorCategory.USER, [
+        'Read the drift with "changeset_brief" and tell the user what changed in the base',
+        "If they still want it landed, call changeset_commit again with force: true; the dialog will show the drift"
+      ], { operation: "changeset_commit" });
+    let preExistingErrors = 0;
+    try {
+      preExistingErrors = (await manager.commit(model, changeset.id, { dryRun: !0, validate: !0, force: args.force === !0 })).validation.preExistingErrors ?? 0;
+    } catch (error) {
+      throw commitError(error, changeset.name);
+    }
+    const warnings = [], asBuiltFirst = await asBuiltFirstWarning(manager, rootPath, changeset);
+    asBuiltFirst && warnings.push(asBuiltFirst);
+    const shown = await confirmedState(model, changeset);
+    let answer;
+    try {
+      answer = await askForConfirmation(context, confirmationMessage(changeset, drift, hash, preExistingErrors, args.force === !0, warnings));
+    } catch (error) {
+      throw refusal(`Changeset '${changeset.name}' was not committed: the confirmation could not be shown (${getErrorMessage(error)}).`, otherWaysToLand());
+    }
+    if (answer.action !== "accept" || answer.content?.confirm !== !0) {
+      const how = answer.action === "accept" ? "did not confirm it" : answer.action === "decline" ? "declined" : "cancelled";
+      throw refusal(`Changeset '${changeset.name}' was not committed: the user ${how}. Nothing was written.`, [
+        "Ask the user what should change before landing it, or leave it staged"
+      ]);
+    }
+    model = await Model.load(rootPath, { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model);
+    const current = await manager.load(changeset.id);
+    if (!current || await confirmedState(model, current) !== shown)
+      throw refusal(`Changeset '${changeset.name}' was not committed: the changeset or the base model changed while the user was confirming. Nothing was written.`, ['Show the user the changeset as it is now ("changeset_brief"), then ask again with changeset_commit']);
+    const wasActive = await manager.getActiveId() === changeset.id;
+    let result;
+    try {
+      result = await manager.commit(model, changeset.id, { validate: !0, force: args.force === !0 });
+    } catch (error) {
+      throw commitError(error, changeset.name);
+    }
+    return wasActive && await manager.clearActive(), await reloadModel(args.rootPath), jsonResult({
+      id: changeset.id,
+      name: changeset.name,
+      status: "committed",
+      committed: result.committed,
+      skipped: result.skipped ?? 0,
+      ...result.skippedDetails?.length ? { skippedDetails: result.skippedDetails.slice(0, 10) } : {},
+      failed: result.failed,
+      preExistingErrors: result.validation.preExistingErrors ?? 0,
+      deactivated: wasActive,
+      // StagingAreaManager.commit reports driftWarning only on a dry run, so use the check made above.
+      ...result.driftWarning || hash.isDrifted ? { driftOverridden: !0 } : {},
+      ...warnings.length > 0 ? { warnings } : {}
+    });
+  });
+}
+const changesetCommitTool = {
+  name: "changeset_commit",
+  description: "Land a staged changeset: write its changes to the base model and mark it committed. Only after a person confirms it: the server asks the user in a confirmation dialog (MCP elicitation) showing the changeset's intent, counts, layers and drift, and commits only if they confirm. Refused when the client can't show the dialog, when the user declines or cancels, and in changeset-only sessions. Validation errors the changeset introduces block it; drift blocks it unless force is passed. Call it only when the user asks to land the change.",
+  inputSchema,
+  _meta: { "anthropic/requiresUserInteraction": !0 },
+  handler: changesetCommitHandler
+};
+export {
+  CONFIRMATION_TIMEOUT_MS,
+  asBuiltFirstWarning,
+  changesetCommitHandler,
+  changesetCommitTool,
+  confirmationMessage,
+  otherWaysToLand,
+  summarizeChangeset
+};
+//# sourceMappingURL=changeset-commit.js.map

package/dist/mcp/tools/changeset-commit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-commit.ts"],
+  "sourcesContent": ["/**\n * changeset_commit \u2014 land a staged changeset in the base model, once a person confirms it.\n *\n * Landing is the human's step (motivation.requirement.landing-a-change-needs-a-humans-confirmation),\n * so the tool is gated twice:\n * - It is listed with `_meta[\"anthropic/requiresUserInteraction\"]`. Claude Code then shows a\n *   permission prompt on every call, whatever the permission mode.\n * - It always asks the client for confirmation (`elicitation/create`), showing the changeset's\n *   name, intent, counts by operation, the layers it touches and any drift. It commits only on\n *   `accept` with `confirm: true`. A decline, a cancel, a client without form elicitation, or a\n *   changeset-only session (DrBot, where no person can answer) is refused, and nothing is written.\n *\n * The commit itself is `StagingAreaManager.commit`, the code `dr changeset commit` and the viewer's\n * Apply (`POST /api/changesets/:id/commit`) run. Like the viewer, it works on a freshly loaded model\n * and may commit any staged changeset, active or not. Like the CLI, it validates (errors the\n * changeset introduces block; the base model's own are counted) and refuses a drifted changeset\n * unless `force` is passed. Landing an as-built changeset from codebase_extract while a plan is\n * staged is allowed, but the dialog warns that the plan should land instead. Both are checked with a dry run before the person is asked, so they are\n * never asked to confirm a commit that would fail. After they accept, the changeset and the base are\n * read again and compared with what the dialog showed; any change refuses the commit.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult, ElicitResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { Model } from \"../../core/model.js\";\nimport type { Changeset, StagedChange } from \"../../core/changeset.js\";\nimport { BaseSnapshotManager } from \"../../core/base-snapshot-manager.js\";\nimport { ChangesetGraph } from \"../../core/changeset-graph.js\";\nimport { describeDrift, type ChangesetDrift } from \"../../core/changeset-base-index.js\";\nimport { StagingAreaManager, type DriftReport } from \"../../core/staging-area.js\";\nimport { isChangesetOnly, CHANGESET_ONLY_ENV } from \"../../core/changeset-only-guard.js\";\nimport { CLIError, ErrorCategory, getErrorMessage } from \"../../utils/errors.js\";\nimport {\n  jsonResult,\n  loadModel,\n  reloadModel,\n  rootPathSchema,\n  runTool,\n  type McpToolContext,\n  type McpToolDefinition,\n} from \"./shared.js\";\nimport { resolveChangeset } from \"./changeset-shared.js\";\nimport { isExtractionChangeset } from \"./codebase-extract.js\";\n\n/** How long the person has to answer the confirmation dialog before the commit is refused. */\nexport const CONFIRMATION_TIMEOUT_MS = 10 * 60_000;\n\n/**\n * How the user can land the changeset without this tool: the viewer, or an interactive session.\n * Never the CLI: the developer types no dr command (round 3 found agents passing it on).\n */\nexport function otherWaysToLand(): string[] {\n  return [\n    \"Ask the user to commit it in the viewer: call review_open, give them its url, and they press Apply on the changeset\",\n    \"Or ask them to run changeset_commit again from an interactive Claude Code session, where the confirmation dialog can be shown\",\n  ];\n}\n\nconst inputSchema = {\n  changeset: z\n    .string()\n    .min(1)\n    .describe(\"Changeset ID or name to commit. Required: it need not be the active changeset.\"),\n  force: z\n    .boolean()\n    .optional()\n    .describe(\n      \"Commit even though the base model changed since the changeset was created (drift). The confirmation \" +\n        \"dialog shows the drift. Validation still blocks.\"\n    ),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetCommitArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nconst OPERATION_LABELS: Record<string, string> = {\n  add: \"adds\",\n  update: \"updates\",\n  delete: \"deletes\",\n  \"relationship-add\": \"relationship adds\",\n  \"relationship-delete\": \"relationship deletes\",\n};\n\n/** Counts by operation and the layers touched, in a stable order. */\nexport function summarizeChangeset(changeset: Changeset): { byOperation: Record<string, number>; layers: string[] } {\n  const byOperation: Record<string, number> = {};\n  const layers = new Set<string>();\n  for (const change of changeset.changes) {\n    byOperation[change.type] = (byOperation[change.type] ?? 0) + 1;\n    if (change.layerName) layers.add(change.layerName);\n  }\n  return { byOperation, layers: [...layers].sort() };\n}\n\nfunction driftLines(drift: ChangesetDrift | undefined, hash: DriftReport, forced: boolean): string[] {\n  const overlapping = drift ? drift.overlapping.elements.length + drift.overlapping.relationships.length : 0;\n  if (!hash.isDrifted && !drift?.isDrifted) return [\"Drift: none. The base model has not changed under this changeset.\"];\n  const lines = [\"Drift: the base model changed since this changeset was created.\"];\n  const counts = drift?.baseChanges?.counts;\n  if (counts) {\n    const parts = [\n      [counts.elementsAdded, \"elements added\"],\n      [counts.elementsRemoved, \"elements removed\"],\n      [counts.elementsChanged, \"elements changed\"],\n      [counts.relationshipsAdded, \"relationships added\"],\n      [counts.relationshipsRemoved, \"relationships removed\"],\n    ]\n      .filter(([n]) => (n as number) > 0)\n      .map(([n, label]) => `${n} ${label}`);\n    if (parts.length > 0) lines.push(`  In the base: ${parts.join(\", \")}.`);\n  }\n  if (drift && overlapping > 0) {\n    const listed = [\n      ...drift.overlapping.elements.map((e) => `${e.id} (${e.reason})`),\n      ...drift.overlapping.relationships.map((r) => `${r.source} --${r.predicate}--> ${r.target} (${r.reason})`),\n    ];\n    lines.push(\n      `  ${overlapping} staged change(s) overlap the base: ${listed.slice(0, 5).join(\", \")}${overlapping > 5 ? \", ...\" : \"\"}.`\n    );\n  }\n  if (!hash.isDrifted) lines.push(\"  The drift check still passes, so this does not block the commit.\");\n  else if (forced) lines.push(\"  Committing anyway: force was passed.\");\n  return lines;\n}\n\n/** The description codebase_extract gives the changesets it creates. */\nconst EXTRACTION_MARKER = /Staged by codebase_extract/;\n\n/**\n * Whether codebase_extract made this changeset: its description says so, or extraction keeps a\n * record for it (its cards file, or waiting cards adopted under this name).\n */\nasync function madeByExtraction(rootPath: string, changeset: Changeset): Promise<boolean> {\n  if (EXTRACTION_MARKER.test(changeset.description ?? \"\")) return true;\n  return !!changeset.id && (await isExtractionChangeset(rootPath, changeset.id, changeset.name));\n}\n\n/**\n * The warning shown when an extraction (as-built) changeset is about to land while a plan is\n * staged. The verify workflow lands the plan and discards the as-built changeset (or keeps it as a\n * record); landing the as-built first drifts the plan's base, so the plan then needs force, and\n * its descriptions don't apply to the elements the as-built side already added.\n */\nexport async function asBuiltFirstWarning(\n  manager: StagingAreaManager,\n  rootPath: string,\n  changeset: Changeset\n): Promise<string | undefined> {\n  if (!(await madeByExtraction(rootPath, changeset))) return undefined;\n  const plans: Changeset[] = [];\n  for (const other of await manager.list()) {\n    if (other.id === changeset.id || other.status !== \"staged\" || other.changes.length === 0) continue;\n    if (!(await madeByExtraction(rootPath, other))) plans.push(other);\n  }\n  if (plans.length === 0) return undefined;\n  const names = plans.map((plan) => `\"${plan.name}\"`).join(\", \");\n  return (\n    `Warning: \"${changeset.name}\" is an as-built changeset from codebase_extract, and the plan ${names} is still ` +\n    `staged. After verify, land the plan instead, and discard this one or keep it as a record. Landing this one ` +\n    `first changes the plan's base: the plan then needs force, and its descriptions won't apply to the elements ` +\n    `this one adds.`\n  );\n}\n\n/** The text of the confirmation dialog. */\nexport function confirmationMessage(\n  changeset: Changeset,\n  drift: ChangesetDrift | undefined,\n  hash: DriftReport,\n  preExistingErrors: number,\n  forced: boolean,\n  warnings: string[] = []\n): string {\n  const { byOperation, layers } = summarizeChangeset(changeset);\n  const counts = Object.entries(byOperation)\n    .map(([type, n]) => `${n} ${OPERATION_LABELS[type] ?? type}`)\n    .join(\", \");\n  return [\n    `Commit changeset \"${changeset.name}\" to the base model?`,\n    \"\",\n    ...warnings.flatMap((warning) => [warning, \"\"]),\n    `Intent: ${changeset.description?.trim() || \"(no description)\"}`,\n    `Changes: ${changeset.changes.length} (${counts})`,\n    `Layers: ${layers.join(\", \") || \"none\"}`,\n    ...driftLines(drift, hash, forced),\n    preExistingErrors > 0\n      ? `Validation: passed. ${preExistingErrors} error(s) already in the base model are not counted.`\n      : \"Validation: passed.\",\n    \"\",\n    \"Committing writes these changes to the base model and marks the changeset committed.\",\n  ].join(\"\\n\");\n}\n\n/**\n * A fingerprint of what the person confirms: the changeset's staged changes, its modified time and\n * status, and the base model's elements (the drift snapshot) and committed relationships.\n */\nasync function confirmedState(model: Model, changeset: Changeset): Promise<string> {\n  return JSON.stringify({\n    changes: (changeset.changes as StagedChange[]).map((c) => [c.sequenceNumber ?? null, c.type, c.elementId]),\n    lastSequence: changeset.lastSequence ?? null,\n    modified: changeset.modified,\n    status: changeset.status,\n    baseElements: await new BaseSnapshotManager().captureSnapshot(model),\n    baseRelationships: model\n      .getBaseRelationships()\n      .map((r) => `${r.source}::${r.predicate}::${r.target}`)\n      .sort(),\n  });\n}\n\nfunction refusal(message: string, suggestions: string[]): CLIError {\n  return new CLIError(message, ErrorCategory.USER, suggestions, { operation: \"changeset_commit\" });\n}\n\n/** Wraps a StagingAreaManager error (plain Error) so the agent sees what blocked the commit. */\nfunction commitError(error: unknown, name: string): CLIError {\n  if (error instanceof CLIError) return error;\n  const message = getErrorMessage(error);\n  if (message.includes(\"drifted\")) {\n    return new CLIError(`Changeset '${name}' was not committed: ${message.replace(/Use --force/, \"Pass force: true\")}`, ErrorCategory.USER, [\n      'Read the drift with \"changeset_brief\" and tell the user what changed in the base',\n      \"If they still want it landed, call changeset_commit again with force: true\",\n    ]);\n  }\n  if (message.startsWith(\"Validation failed\")) {\n    return new CLIError(\n      `Changeset '${name}' was not committed. ${message.replace(/, or skip validation with --no-validate\\./, \".\")}`,\n      ErrorCategory.VALIDATION,\n      ['Fix the plan (model_update, changeset_unstage, ...) and check it with \"model_validate\"']\n    );\n  }\n  return new CLIError(`Changeset '${name}' was not committed: ${message}`, ErrorCategory.SYSTEM);\n}\n\nasync function askForConfirmation(context: McpToolContext, message: string): Promise<ElicitResult> {\n  return context.server!.elicitInput(\n    {\n      mode: \"form\",\n      message,\n      requestedSchema: {\n        type: \"object\",\n        properties: {\n          confirm: {\n            type: \"boolean\",\n            title: \"Commit this changeset\",\n            description: \"Write the staged changes to the base model.\",\n            default: false,\n          },\n        },\n        required: [\"confirm\"],\n      },\n    },\n    { relatedRequestId: context.requestId, signal: context.signal, timeout: CONFIRMATION_TIMEOUT_MS }\n  );\n}\n\nexport async function changesetCommitHandler(\n  args: ChangesetCommitArgs,\n  context?: McpToolContext\n): Promise<CallToolResult> {\n  return runTool(async () => {\n    if (isChangesetOnly()) {\n      throw refusal(\n        `This session can't commit a changeset: it is in changeset-only mode (${CHANGESET_ONLY_ENV}), ` +\n          \"where no person can confirm the commit.\",\n        [\"Tell the user the changeset is ready to land\", ...otherWaysToLand()]\n      );\n    }\n\n    // The cached model names the project; the commit runs on a fresh read, like the viewer's.\n    const rootPath = (await loadModel(args.rootPath)).rootPath;\n    let model = await Model.load(rootPath, { lazyLoad: false });\n    let manager = new StagingAreaManager(model.rootPath, model);\n    const changeset = await resolveChangeset(manager, args.changeset, \"changeset\");\n    if (changeset.status !== \"staged\") {\n      throw new CLIError(`Changeset '${changeset.name}' is ${changeset.status}; only a staged changeset can be committed`, ErrorCategory.USER, [\n        'Use \"changeset_list\" to find a staged changeset',\n      ]);\n    }\n    if (changeset.changes.length === 0) {\n      return jsonResult({ id: changeset.id, name: changeset.name, status: \"nothing-to-commit\", stagedChanges: 0 });\n    }\n\n    const server = context?.server;\n    if (!server?.getClientCapabilities()?.elicitation?.form) {\n      throw refusal(\n        `Changeset '${changeset.name}' was not committed: committing needs a person to confirm it, and this client ` +\n          \"can't show a confirmation dialog (it does not support MCP elicitation).\",\n        otherWaysToLand()\n      );\n    }\n\n    // Check drift and validation before asking, so the person never confirms a commit that would fail.\n    const hash = await manager.detectDrift(changeset.id);\n    let drift: ChangesetDrift | undefined;\n    try {\n      drift = await describeDrift(model, await ChangesetGraph.build(model, changeset), hash);\n    } catch (error) {\n      console.error(`[mcp] changeset_commit could not describe drift: ${getErrorMessage(error)}`);\n    }\n    if (hash.isDrifted && args.force !== true) {\n      // The CLI's rule: a drifted changeset needs --force. Say what drifted so the person can decide.\n      throw new CLIError(\n        `Changeset '${changeset.name}' was not committed: the base model changed since it was created.\\n` +\n          driftLines(drift, hash, false).slice(1).join(\"\\n\"),\n        ErrorCategory.USER,\n        [\n          'Read the drift with \"changeset_brief\" and tell the user what changed in the base',\n          \"If they still want it landed, call changeset_commit again with force: true; the dialog will show the drift\",\n        ],\n        { operation: \"changeset_commit\" }\n      );\n    }\n    let preExistingErrors = 0;\n    try {\n      const dryRun = await manager.commit(model, changeset.id, { dryRun: true, validate: true, force: args.force === true });\n      preExistingErrors = dryRun.validation.preExistingErrors ?? 0;\n    } catch (error) {\n      throw commitError(error, changeset.name);\n    }\n\n    // An as-built changeset landing while the plan is staged: the plan should land instead.\n    const warnings: string[] = [];\n    const asBuiltFirst = await asBuiltFirstWarning(manager, rootPath, changeset);\n    if (asBuiltFirst) warnings.push(asBuiltFirst);\n\n    // What the person is shown; checked again after they answer.\n    const shown = await confirmedState(model, changeset);\n    let answer: ElicitResult;\n    try {\n      answer = await askForConfirmation(\n        context!,\n        confirmationMessage(changeset, drift, hash, preExistingErrors, args.force === true, warnings)\n      );\n    } catch (error) {\n      throw refusal(\n        `Changeset '${changeset.name}' was not committed: the confirmation could not be shown (${getErrorMessage(error)}).`,\n        otherWaysToLand()\n      );\n    }\n    if (answer.action !== \"accept\" || answer.content?.confirm !== true) {\n      const how = answer.action === \"accept\" ? \"did not confirm it\" : answer.action === \"decline\" ? \"declined\" : \"cancelled\";\n      throw refusal(`Changeset '${changeset.name}' was not committed: the user ${how}. Nothing was written.`, [\n        \"Ask the user what should change before landing it, or leave it staged\",\n      ]);\n    }\n\n    // The person may have taken a while. Commit only what they saw: re-read the changeset and the\n    // base, and refuse if either changed. The commit itself checks drift and validation again.\n    model = await Model.load(rootPath, { lazyLoad: false });\n    manager = new StagingAreaManager(model.rootPath, model);\n    const current = await manager.load(changeset.id);\n    if (!current || (await confirmedState(model, current)) !== shown) {\n      throw refusal(\n        `Changeset '${changeset.name}' was not committed: the changeset or the base model changed while the user ` +\n          \"was confirming. Nothing was written.\",\n        ['Show the user the changeset as it is now (\"changeset_brief\"), then ask again with changeset_commit']\n      );\n    }\n    const wasActive = (await manager.getActiveId()) === changeset.id;\n    let result;\n    try {\n      result = await manager.commit(model, changeset.id, { validate: true, force: args.force === true });\n    } catch (error) {\n      throw commitError(error, changeset.name);\n    }\n    if (wasActive) await manager.clearActive();\n    await reloadModel(args.rootPath);\n\n    return jsonResult({\n      id: changeset.id,\n      name: changeset.name,\n      status: \"committed\",\n      committed: result.committed,\n      skipped: result.skipped ?? 0,\n      ...(result.skippedDetails?.length ? { skippedDetails: result.skippedDetails.slice(0, 10) } : {}),\n      failed: result.failed,\n      preExistingErrors: result.validation.preExistingErrors ?? 0,\n      deactivated: wasActive,\n      // StagingAreaManager.commit reports driftWarning only on a dry run, so use the check made above.\n      ...(result.driftWarning || hash.isDrifted ? { driftOverridden: true } : {}),\n      ...(warnings.length > 0 ? { warnings } : {}),\n    });\n  });\n}\n\nexport const changesetCommitTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"changeset_commit\",\n  description:\n    \"Land a staged changeset: write its changes to the base model and mark it committed. Only after a person \" +\n    \"confirms it: the server asks the user in a confirmation dialog (MCP elicitation) showing the changeset's \" +\n    \"intent, counts, layers and drift, and commits only if they confirm. Refused when the client can't show the \" +\n    \"dialog, when the user declines or cancels, and in changeset-only sessions. Validation errors the changeset \" +\n    \"introduces block it; drift blocks it unless force is passed. Call it only when the user asks to land the change.\",\n  inputSchema,\n  _meta: { \"anthropic/requiresUserInteraction\": true },\n  handler: changesetCommitHandler,\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mcp/tools/changeset-editing.js

@@ -0,0 +1,260 @@
+import { z } from "zod";
+import { strictItem } from "../strict-schema.js";
+import { ChangesetGraph } from "../../core/changeset-graph.js";
+import { StagingAreaManager } from "../../core/staging-area.js";
+import { stagedRelationshipChangesAtEnds, stagedRelationshipTriple } from "../../core/relationship-staging.js";
+import { CLIError, ErrorCategory, getErrorMessage } from "../../utils/errors.js";
+import { jsonResult, loadModel, reloadModel, rootPathSchema, runTool } from "./shared.js";
+import { resolveChangeset } from "./changeset-shared.js";
+const changesetIdSchema = z.string().optional().describe("Changeset ID or name. Defaults to the active changeset.");
+function requireStaged(changeset, action) {
+  if (changeset.status !== "staged")
+    throw new CLIError(`Changeset '${changeset.name}' is ${changeset.status}; cannot ${action}`, ErrorCategory.USER, [
+      'Use "changeset_list" to find a staged changeset, or "changeset_create" to start a new one'
+    ]);
+}
+async function asUserError(fn, suggestions) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw error instanceof CLIError ? error : new CLIError(getErrorMessage(error), ErrorCategory.USER, suggestions);
+  }
+}
+function summarize(change) {
+  const triple = change.type.startsWith("relationship-") ? stagedRelationshipTriple(change) : null;
+  return {
+    type: change.type,
+    elementId: change.elementId,
+    layer: change.layerName,
+    ...triple ? { relationship: triple } : {}
+  };
+}
+const updateInputSchema = {
+  changesetId: changesetIdSchema,
+  name: z.string().min(1).optional().describe("New name. Must not be another changeset's name."),
+  description: z.string().optional().describe("New description: the change's intent and what done looks like. An empty string clears it."),
+  rootPath: rootPathSchema
+};
+async function changesetUpdateHandler(args) {
+  return runTool(async () => {
+    if (args.name === void 0 && args.description === void 0)
+      throw new CLIError("Nothing to update", ErrorCategory.USER, ['Pass "name" and/or "description"']);
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), changeset = await resolveChangeset(manager, args.changesetId), updated = await asUserError(() => manager.update(changeset.id, { name: args.name, description: args.description }), ['Use "changeset_list" to see the names already taken']);
+    return await reloadModel(args.rootPath), jsonResult({
+      id: updated.id,
+      name: updated.name,
+      ...changeset.name !== updated.name ? { previousName: changeset.name } : {},
+      description: updated.description ?? null,
+      status: updated.status,
+      changes: updated.changes.length
+    });
+  });
+}
+const changesetUpdateTool = {
+  name: "changeset_update",
+  description: "Rename a changeset or change its description (the change's intent). Staged changes are untouched. Defaults to the active changeset.",
+  inputSchema: updateInputSchema,
+  handler: changesetUpdateHandler
+}, elementIdField = z.string().optional().describe("Drop every staged change to this element (its add, updates or delete). ID or path."), sourceField = z.string().optional().describe("Drop staged relationship changes (adds and deletes) from this element: to target when given, otherwise to any element. The element's own changes are not touched."), targetField = z.string().optional().describe("Drop staged relationship changes (adds and deletes) to this element: from source when given, otherwise from any element. The element's own changes are not touched."), predicateField = z.string().optional().describe("Only relationship changes with this predicate. Omit for any."), keepRelationshipsField = z.boolean().optional().describe("With elementId: keep the staged relationship changes that depend on the element's change. By default, unstaging an element's add also drops staged relationships to it (they would dangle), and unstaging its delete also drops the relationship removals its cascade staged (removals staged before the delete are kept)."), unstageItemSchema = strictItem("A changes[] item", {
+  elementId: elementIdField,
+  source: sourceField,
+  target: targetField,
+  predicate: predicateField,
+  keepRelationships: keepRelationshipsField
+}), unstageInputSchema = {
+  changesetId: changesetIdSchema,
+  elementId: elementIdField,
+  source: sourceField,
+  target: targetField,
+  predicate: predicateField,
+  keepRelationships: keepRelationshipsField,
+  changes: z.array(unstageItemSchema).min(1).optional().describe("Several unstages at once, each {elementId} or {source, predicate?, target} or {source} or {target}, with the same meaning as the single form. All are removed in one write, with a result per item: unstaged, already-unstaged (an earlier item took its changes), not-staged, or invalid with the reason. Cannot be combined with the single-form fields."),
+  rootPath: rootPathSchema
+};
+function describeEnds(args) {
+  return args.source && args.target ? `from ${args.source} to ${args.target}` : args.source ? `from ${args.source}` : `to ${args.target}`;
+}
+function checkUnstageSpec(spec) {
+  const byElement = spec.elementId !== void 0, byRelationship = spec.source !== void 0 || spec.target !== void 0;
+  if (byElement === byRelationship)
+    throw new CLIError("Name either an element or a relationship to unstage", ErrorCategory.USER, [
+      `Pass "elementId" to drop an element's staged changes`,
+      'Or pass "source" and/or "target" (and optionally "predicate") to drop staged relationship changes'
+    ]);
+  if (byRelationship && !spec.source && !spec.target)
+    throw new CLIError('"source" or "target" must not be empty', ErrorCategory.USER);
+}
+function selectUnstage(spec, graph, changeset) {
+  const changes = changeset.changes, keys = /* @__PURE__ */ new Set(), notes = [];
+  if (spec.elementId !== void 0) {
+    const element = graph.getElement(spec.elementId), ids = /* @__PURE__ */ new Set([spec.elementId, ...element ? [element.id, element.uuid ?? element.id] : []]), own = changes.filter((c) => !c.type.startsWith("relationship-") && ids.has(c.elementId));
+    for (const change of own)
+      keys.add(change.elementId);
+    const dependentType = own.some((c) => c.type === "add") ? "relationship-add" : own.some((c) => c.type === "delete") ? "relationship-delete" : null, touching = dependentType ? changes.filter((c) => {
+      if (c.type !== dependentType)
+        return !1;
+      const triple = stagedRelationshipTriple(c);
+      return !!triple && (ids.has(triple.source) || ids.has(triple.target) || element && (graph.resolve(triple.source) === element.id || graph.resolve(triple.target) === element.id));
+    }) : [], seq2 = (c) => c.sequenceNumber ?? changes.indexOf(c), deleteSeqs = own.filter((c) => c.type === "delete").map(seq2), firstDelete = deleteSeqs.length > 0 ? Math.min(...deleteSeqs) : -1, dependent = dependentType === "relationship-delete" ? touching.filter((c) => seq2(c) > firstDelete) : touching, deliberate = touching.filter((c) => !dependent.includes(c));
+    if (deliberate.length > 0 && notes.push(`${deliberate.length} relationship removal(s) on ${spec.elementId} staged before its delete were kept (${deliberate.map((c) => c.elementId).join(", ")}); unstage them by source and target if they should go too`), dependent.length > 0)
+      if (spec.keepRelationships)
+        notes.push(`${dependent.length} staged relationship change(s) on ${spec.elementId} were kept (keepRelationships)` + (dependentType === "relationship-add" ? "; they will dangle unless the element is staged again" : ""));
+      else
+        for (const change of dependent)
+          keys.add(change.elementId);
+    return { keys, notes };
+  }
+  const matched = stagedRelationshipChangesAtEnds(graph, changeset, {
+    source: spec.source || void 0,
+    target: spec.target || void 0,
+    predicate: spec.predicate
+  }), seq = (c) => c.sequenceNumber ?? changes.indexOf(c), deleteSeq = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    if (change.type !== "delete")
+      continue;
+    const id = graph.resolve(change.elementId);
+    deleteSeq.set(id, Math.min(deleteSeq.get(id) ?? 1 / 0, seq(change)));
+  }
+  const deletedEndOf = (change) => {
+    if (change.type !== "relationship-delete")
+      return;
+    const triple = stagedRelationshipTriple(change);
+    if (triple)
+      return [graph.resolve(triple.source), graph.resolve(triple.target)].find((end) => deleteSeq.has(end) && deleteSeq.get(end) < seq(change));
+  }, cascaded = matched.filter((c) => deletedEndOf(c) !== void 0), deletedEnds = [...new Set(cascaded.map((c) => deletedEndOf(c)))].join(", "), cascadeList = cascaded.map((c) => c.elementId).join(", "), bothEnds = !!spec.source && !!spec.target;
+  for (const change of matched)
+    !bothEnds && cascaded.includes(change) || keys.add(change.elementId);
+  return cascaded.length > 0 && bothEnds ? notes.push(`Unstaged ${cascaded.length} relationship removal(s) cascaded from the staged delete of ${deletedEnds} (${cascadeList}): those relationships now dangle, so the changeset will not commit until they are removed again or the delete is unstaged ("changeset_unstage" with elementId)`) : cascaded.length > 0 && notes.push(`Kept ${cascaded.length} relationship removal(s) cascaded from the staged delete of ${deletedEnds} (${cascadeList}): dropping them would leave those relationships dangling. Unstage the delete ("changeset_unstage" with elementId) to restore them, or name both source and target to drop one anyway`), { keys, notes };
+}
+function notStagedMessage(spec, changesetName) {
+  return spec.elementId !== void 0 ? `No staged change to ${spec.elementId} in '${changesetName}'` : `No staged relationship change ${describeEnds(spec)}${spec.predicate ? ` (${spec.predicate})` : ""} in '${changesetName}'`;
+}
+const SINGLE_FORM_FIELDS = ["elementId", "source", "target", "predicate", "keepRelationships"];
+async function changesetUnstageHandler(args) {
+  return runTool(async () => {
+    if (args.changes) {
+      const mixed = SINGLE_FORM_FIELDS.filter((field) => args[field] !== void 0);
+      if (mixed.length > 0)
+        throw new CLIError(`"changes" cannot be combined with ${mixed.map((f) => `"${f}"`).join(", ")}`, ErrorCategory.USER, [
+          'Put those fields on the items of the "changes" list'
+        ]);
+      return unstageBatch(args.changes, args.changesetId, args.rootPath);
+    }
+    checkUnstageSpec(args);
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), changeset = await resolveChangeset(manager, args.changesetId);
+    requireStaged(changeset, "unstage changes");
+    const graph = await ChangesetGraph.build(model, changeset), changes = changeset.changes, { keys, notes } = selectUnstage(args, graph, changeset), removed = changes.filter((c) => keys.has(c.elementId));
+    if (removed.length === 0)
+      return jsonResult({
+        status: "not-staged",
+        changeset: changeset.name,
+        message: notStagedMessage(args, changeset.name),
+        suggestions: ['Use "changeset_show" to list the staged changes'],
+        ...notes.length > 0 ? { notes } : {}
+      });
+    for (const key of keys)
+      await manager.unstage(changeset.id, key);
+    return await reloadModel(args.rootPath), jsonResult({
+      status: "unstaged",
+      changeset: changeset.name,
+      unstaged: removed.map(summarize),
+      remainingChanges: changes.length - removed.length,
+      ...notes.length > 0 ? { notes } : {}
+    });
+  });
+}
+async function unstageBatch(specs, changesetId, rootPath) {
+  const model = await loadModel(rootPath), manager = new StagingAreaManager(model.rootPath, model), changeset = await resolveChangeset(manager, changesetId);
+  requireStaged(changeset, "unstage changes");
+  const graph = await ChangesetGraph.build(model, changeset), changes = changeset.changes, claimed = /* @__PURE__ */ new Set(), results = [];
+  for (const [index, spec] of specs.entries()) {
+    const asSent = {
+      index,
+      status: "unstaged",
+      ...spec.elementId !== void 0 ? { elementId: spec.elementId } : {},
+      ...spec.source !== void 0 ? { source: spec.source } : {},
+      ...spec.target !== void 0 ? { target: spec.target } : {},
+      ...spec.predicate !== void 0 ? { predicate: spec.predicate } : {}
+    };
+    let selection;
+    try {
+      checkUnstageSpec(spec), selection = selectUnstage(spec, graph, changeset);
+    } catch (error) {
+      results.push({
+        ...asSent,
+        status: "invalid",
+        reason: getErrorMessage(error),
+        ...error instanceof CLIError && error.suggestions?.length ? { suggestions: error.suggestions } : {}
+      });
+      continue;
+    }
+    const notes = [...selection.notes], fresh = [...selection.keys].filter((key) => !claimed.has(key)), earlier = selection.keys.size - fresh.length;
+    for (const key of fresh)
+      claimed.add(key);
+    const removed = changes.filter((c) => fresh.includes(c.elementId)), status = removed.length > 0 ? "unstaged" : earlier > 0 ? "already-unstaged" : "not-staged";
+    earlier > 0 && notes.push(`${earlier} of its change(s) were already unstaged by an earlier item`), results.push({
+      ...asSent,
+      status,
+      ...removed.length > 0 ? { unstaged: removed.map(summarize) } : {},
+      ...status === "not-staged" ? { message: notStagedMessage(spec, changeset.name) } : {},
+      ...notes.length > 0 ? { notes } : {}
+    });
+  }
+  claimed.size > 0 && (await manager.unstageMany(changeset.id, [...claimed]), await reloadModel(rootPath));
+  const counts = {};
+  for (const result of results)
+    counts[result.status] = (counts[result.status] ?? 0) + 1;
+  const removedCount = changes.filter((c) => claimed.has(c.elementId)).length;
+  return jsonResult({
+    changeset: changeset.name,
+    counts,
+    results,
+    unstagedChanges: removedCount,
+    remainingChanges: changes.length - removedCount,
+    ...results.some((r) => r.status === "not-staged") ? { suggestions: ['Use "changeset_show" to list the staged changes'] } : {}
+  });
+}
+const changesetUnstageTool = {
+  name: "changeset_unstage",
+  description: "Undo part of a staged changeset: drop the staged changes to one element (elementId), or the staged relationship adds/deletes between source and target, or every one from source alone or to target alone (optionally one predicate). To drop several, send changes: [...] (one write, a result per item). The base model is not touched. Defaults to the active changeset. Use changeset_show to see what is staged.",
+  inputSchema: unstageInputSchema,
+  handler: changesetUnstageHandler
+}, discardInputSchema = {
+  changesetId: z.string().describe("Changeset ID or name to discard. Required: discard is never implied."),
+  confirm: z.boolean().describe("Must be true. Discarding deletes the changeset's staged changes permanently (only its name, description and a 'discarded' status remain), so confirm only when the plan is to be abandoned."),
+  rootPath: rootPathSchema
+};
+async function changesetDiscardHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), changeset = await resolveChangeset(manager, args.changesetId);
+    if (requireStaged(changeset, "discard it"), args.confirm !== !0)
+      throw new CLIError(`Discarding '${changeset.name}' deletes its ${changeset.changes.length} staged change(s) permanently`, ErrorCategory.USER, [
+        'Pass "confirm": true to discard it',
+        'Use "changeset_unstage" to drop individual changes instead',
+        'Use "changeset_deactivate" to stop staging into it and keep its changes'
+      ]);
+    const wasActive = await manager.getActiveId() === changeset.id, discardedChanges = changeset.changes.length;
+    return await manager.discard(changeset.id), wasActive && await manager.clearActive(), await reloadModel(args.rootPath), jsonResult({
+      id: changeset.id,
+      name: changeset.name,
+      status: "discarded",
+      discardedChanges,
+      deactivated: wasActive
+    });
+  });
+}
+const changesetDiscardTool = {
+  name: "changeset_discard",
+  description: "Abandon a staged changeset: PERMANENTLY deletes its staged changes and marks it discarded (deactivating it if active). Not recoverable, so it requires confirm: true. The base model is not touched. To undo part of a plan use changeset_unstage; to pause it use changeset_deactivate.",
+  inputSchema: discardInputSchema,
+  handler: changesetDiscardHandler
+};
+export {
+  changesetDiscardHandler,
+  changesetDiscardTool,
+  changesetUnstageHandler,
+  changesetUnstageTool,
+  changesetUpdateHandler,
+  changesetUpdateTool
+};
+//# sourceMappingURL=changeset-editing.js.map