@documentation-robotics/cli 0.2.0 → 0.4.0

package/dist/mcp/tools/project-status.js

@@ -0,0 +1,237 @@
+import path from "node:path";
+import { findProjectRoot } from "../../utils/project-paths.js";
+import { fileExists } from "../../utils/file-io.js";
+import { getErrorMessage } from "../../utils/errors.js";
+import { currentProjectRoot, whenProjectRootSettled } from "../project-root.js";
+import { readdir, stat } from "node:fs/promises";
+import { jsonResult, loadModel, reloadModel, rootPathSchema, runTool } from "./shared.js";
+import { collectChangesets, collectCodeDrift, collectCodeIndex, collectIndexing, collectModel, collectSpec, collectViewer, runGit } from "./project-status-collectors.js";
+const inputSchema = {
+  rootPath: rootPathSchema
+}, COLLECTORS = {
+  model: collectModel,
+  spec: collectSpec,
+  changesets: collectChangesets,
+  codeIndex: collectCodeIndex,
+  codeDrift: collectCodeDrift,
+  indexing: collectIndexing,
+  viewer: collectViewer
+}, RESOLVED_BY = {
+  env: "DR_MCP_ROOT_PATH",
+  "client-roots": "mcp-roots",
+  cwd: "cwd"
+};
+async function projectStatus(args, options = {}) {
+  let root, resolvedBy;
+  if (args.rootPath)
+    root = path.resolve(args.rootPath), resolvedBy = "rootPath";
+  else {
+    await whenProjectRootSettled();
+    const current = currentProjectRoot();
+    root = current.root, resolvedBy = RESOLVED_BY[current.source];
+  }
+  const projectRoot = await findProjectRoot(root), manifest = projectRoot ? path.join(projectRoot, "documentation-robotics", "model", "manifest.yaml") : null, modelDir = manifest && await fileExists(manifest) ? path.dirname(manifest) : null;
+  let modelPromise;
+  const ctx = {
+    root,
+    resolvedBy,
+    projectRoot,
+    modelDir,
+    model: () => modelPromise ??= freshModel(args.rootPath, modelDir),
+    git: options.git ?? runGit
+  }, entries = await Promise.all(Object.entries(COLLECTORS).map(async ([key, collect]) => {
+    try {
+      return [key, await collect(ctx)];
+    } catch (error) {
+      return [key, { status: "error", error: getErrorMessage(error) }];
+    }
+  })), sections = Object.fromEntries(entries);
+  return {
+    project: { root, resolvedBy, projectRoot },
+    ...sections,
+    nextStep: suggestNextStep(sections, { root, rootPath: args.rootPath })
+  };
+}
+const lastSignature = /* @__PURE__ */ new Map();
+function clearProjectStatusSignatures() {
+  lastSignature.clear();
+}
+async function freshModel(rootPath, modelDir) {
+  const key = rootPath ?? "", signature = modelDir ? await filesSignature(modelDir) : null;
+  if (signature !== null && lastSignature.get(key) === signature)
+    return loadModel(rootPath);
+  const model = await reloadModel(rootPath);
+  return signature !== null && lastSignature.set(key, signature), model;
+}
+async function filesSignature(dir) {
+  try {
+    const entries = await readdir(dir, { recursive: !0, withFileTypes: !0 }), stats = await Promise.all(entries.filter((entry) => entry.isFile()).map((entry) => stat(path.join(entry.parentPath, entry.name))));
+    let mtimes = 0, sizes = 0;
+    for (const s of stats)
+      mtimes += s.mtimeMs, sizes += s.size;
+    return `${stats.length}:${mtimes}:${sizes}`;
+  } catch {
+    return null;
+  }
+}
+function suggestNextStep(s, ctx) {
+  const step = withIndexNote(whileIndexing(pickNextStep(s, ctx.root), s), s);
+  if (!ctx.rootPath)
+    return step;
+  const withRoot = (args) => ({ ...args, rootPath: ctx.rootPath });
+  return {
+    ...step,
+    ...step.tool ? { args: withRoot(step.args) } : {},
+    ...step.then ? { then: { ...step.then, args: withRoot(step.then.args) } } : {},
+    ...step.also ? { also: { ...step.also, args: withRoot(step.also.args) } } : {}
+  };
+}
+const WAIT_ARGS = { status: !0, wait: 30 };
+function withIndexNote(step, s) {
+  if (step.tool === "codebase_index")
+    return step;
+  let also;
+  return s.indexing?.status === "running" ? also = {
+    summary: `The code is being indexed (started ${s.indexing.startedAt}); until it is done, codebase tools read the old index. Call codebase_index with status: true and wait: 30 to wait for it.`,
+    tool: "codebase_index",
+    args: WAIT_ARGS
+  } : s.changesets?.status === "ok" && s.changesets.active && (s.codeIndex?.status === "fresh-with-uncommitted-edits" || s.codeIndex?.status === "stale") && (also = {
+    summary: `${s.codeIndex.status === "stale" ? `The code index is stale${s.codeIndex.reason ? `: ${s.codeIndex.reason}` : ""}.` : `The code index predates uncommitted edits${s.codeIndex.reason ? `: ${s.codeIndex.reason}` : ""}.`} Refresh it with codebase_index before extracting or verifying against the code.`,
+    tool: "codebase_index",
+    args: INDEX_ARGS
+  }), also ? step.also ? { ...step, summary: `${step.summary} Also: ${also.summary}` } : { ...step, summary: `${step.summary} Also: ${also.summary}`, also } : step;
+}
+function whileIndexing(step, s) {
+  return step.tool !== "codebase_index" || s.indexing?.status !== "running" ? step : {
+    summary: `The code is being indexed (started ${s.indexing.startedAt}). Call codebase_index with status: true and wait: 30 until it is done.`,
+    tool: "codebase_index",
+    args: { status: !0, wait: 30 },
+    ...step.then ? { then: step.then } : {}
+  };
+}
+const INDEX_ARGS = { wait: 30 };
+function pickNextStep(s, root) {
+  const ctx = { root }, { model, spec, changesets, codeDrift, codeIndex } = s;
+  if (model.status === "absent")
+    return {
+      summary: `There is no DR model in ${ctx.root}. Create one with project_init.`,
+      tool: "project_init"
+    };
+  if (model.status === "error")
+    return { summary: `The model could not be read: ${model.error}`, tool: null };
+  if (spec.status === "behind") {
+    const how = spec.migration?.available ? "Preview and apply the migration with project_upgrade." : "The CLI has no migration path between them; project_upgrade reports the options.";
+    return {
+      summary: `The model is on spec ${spec.model}; this CLI carries ${spec.cli}. ${how}`,
+      tool: "project_upgrade"
+    };
+  }
+  if (spec.status === "ahead")
+    return {
+      summary: `The model is on spec ${spec.model}, newer than this CLI's ${spec.cli}. Update the dr CLI before changing the model.`,
+      tool: null
+    };
+  if (model.loadError)
+    return {
+      summary: `The model could not be loaded: ${model.loadError}. Fix the files under documentation-robotics/model/.`,
+      tool: null
+    };
+  if (changesets.status === "ok" && changesets.active?.asBuilt)
+    return asBuiltStep(changesets.active, changesets.staged);
+  if (changesets.status === "ok" && changesets.active) {
+    const { name, changes, baseDrifted } = changesets.active, drifted = baseDrifted ? " Its base model has changed since it was opened." : "";
+    return {
+      summary: `Changeset "${name}" is active with ${changes.total} staged change${changes.total === 1 ? "" : "s"}.${drifted} Read its brief with changeset_brief to pick up the plan.`,
+      tool: "changeset_brief"
+    };
+  }
+  if (codeDrift.status === "drift") {
+    const files = codeDrift.changedSourceFiles.length + codeDrift.uncommittedSourceFiles.length, sha = codeDrift.modelCommit.sha, drift = `${files} source file${files === 1 ? "" : "s"} the model references changed since the model was last updated, not counting spec migrations (${sha.slice(0, 7)}, ${codeDrift.commitsSince} commit${codeDrift.commitsSince === 1 ? "" : "s"} ago).`;
+    if (codeIndex.status !== "fresh") {
+      const index = codeIndex.status === "stale" ? "The code index is stale" : codeIndex.status === "fresh-with-uncommitted-edits" ? "Source files were edited after the code index was taken" : "The code has no usable index";
+      return {
+        summary: `${drift} ${index}: rebuild it with codebase_index, then check the API layer with codebase_verify and model the changes with codebase_extract since ${sha.slice(0, 7)}.`,
+        tool: "codebase_index",
+        args: INDEX_ARGS,
+        then: { tool: "codebase_verify" }
+      };
+    }
+    return {
+      summary: `${drift} Check the API layer with codebase_verify, then model the changes with codebase_extract since ${sha.slice(0, 7)}.`,
+      tool: "codebase_verify",
+      then: { tool: "codebase_extract", args: { since: sha } }
+    };
+  }
+  if (codeIndex.status === "absent")
+    return {
+      summary: "The code has no index. Build one with codebase_index.",
+      tool: "codebase_index",
+      args: INDEX_ARGS
+    };
+  if (codeIndex.status === "stale")
+    return {
+      summary: `The code index is stale: ${codeIndex.reason ?? `it was built at ${codeIndex.indexedCommit.slice(0, 7)}`}. Refresh it with codebase_index.`,
+      tool: "codebase_index",
+      args: INDEX_ARGS
+    };
+  if (codeIndex.status === "fresh-with-uncommitted-edits")
+    return {
+      summary: `The code index predates uncommitted edits: ${codeIndex.reason}. Refresh it with codebase_index.`,
+      tool: "codebase_index",
+      args: INDEX_ARGS
+    };
+  if (changesets.status === "ok" && changesets.staged.length > 0) {
+    const names = changesets.staged.map((changeset) => `"${changeset.name}"`).join(", ");
+    return {
+      summary: `No changeset is active; ${changesets.staged.length} staged: ${names}. Activate one with changeset_activate to continue it, or plan a new change with changeset_create.`,
+      tool: "changeset_activate"
+    };
+  }
+  return {
+    summary: "The model is current and in step with the code. To plan a change, start with changeset_create.",
+    tool: "changeset_create"
+  };
+}
+function asBuiltStep(asBuilt, staged) {
+  const changes = `${asBuilt.changes.total} staged change${asBuilt.changes.total === 1 ? "" : "s"}`, intro = `Changeset "${asBuilt.name}" is active, with ${changes}: it is the as-built changeset codebase_extract staged from the code, not a plan. Don't build from it or edit it as a plan.`, plans = staged.filter((entry) => entry.id !== asBuilt.id && !entry.asBuilt), plan = (asBuilt.previousActive ? plans.find((entry) => entry.id === asBuilt.previousActive.id) : void 0) ?? (plans.length === 1 ? plans[0] : void 0);
+  if (plan)
+    return {
+      summary: `${intro} It is the as-built side of a verify against the plan "${plan.name}": compare them with changeset_verify (planned: "${plan.name}", against: {changesetId: "${asBuilt.id}"}), and reactivate the plan with changeset_activate before any edits.`,
+      tool: "changeset_verify",
+      args: { planned: plan.id, against: { changesetId: asBuilt.id } },
+      also: {
+        summary: `Reactivate the plan "${plan.name}" with changeset_activate before editing anything, so changes stage into it.`,
+        tool: "changeset_activate",
+        args: { changesetId: plan.id }
+      }
+    };
+  if (plans.length > 1) {
+    const names = plans.map((entry) => `"${entry.name}"`).join(", ");
+    return {
+      summary: `${intro} ${plans.length} plans are staged (${names}), and nothing records which one this build is for. Ask the user, then call changeset_verify with planned: <that plan> and against: {changesetId: "${asBuilt.id}"}, and reactivate the plan with changeset_activate before any edits.`,
+      tool: null
+    };
+  }
+  return {
+    summary: `${intro} No plan is staged, so it is a keep-as-built catch-up: it holds what was built and is reviewed and landed as itself. Show it to the user with review_open, and land it with changeset_commit when they ask.`,
+    tool: "review_open",
+    args: { changeset: asBuilt.id }
+  };
+}
+async function projectStatusHandler(args) {
+  return runTool(async () => jsonResult(await projectStatus(args), { compact: !0 }));
+}
+const projectStatusTool = {
+  name: "project_status",
+  description: "Where this repo stands with DR, and what to do next: the project root and how it was found, whether a model exists, its spec version against this CLI's, the active and staged changesets, whether the code index exists and is fresh (and any indexing run in progress), code changed since the model last changed (from git), and the viewer running for the project with its link. Ends with nextStep: a sentence and the tool to call. Reads local files and git only. Call it first in a session.",
+  inputSchema,
+  handler: projectStatusHandler
+};
+export {
+  clearProjectStatusSignatures,
+  projectStatus,
+  projectStatusHandler,
+  projectStatusTool,
+  suggestNextStep
+};
+//# sourceMappingURL=project-status.js.map

package/dist/mcp/tools/project-status.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/project-status.ts"],
+  "sourcesContent": ["/**\n * project_status \u2014 where this repo stands with DR, and what to do next. The first call an agent\n * makes in a session.\n *\n * It reads local files and git only: no network, and it never starts the code analyzer. Each\n * section comes from its own collector (project-status-collectors.ts), so one that fails reports\n * an error in its section and the others still answer.\n */\n\nimport path from \"node:path\";\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport type { Model } from \"../../core/model.js\";\nimport { findProjectRoot } from \"../../utils/project-paths.js\";\nimport { fileExists } from \"../../utils/file-io.js\";\nimport { getErrorMessage } from \"../../utils/errors.js\";\nimport { currentProjectRoot, whenProjectRootSettled, type ProjectRootSource } from \"../project-root.js\";\nimport { readdir, stat } from \"node:fs/promises\";\nimport { jsonResult, loadModel, reloadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\nimport {\n  collectChangesets,\n  collectCodeDrift,\n  collectCodeIndex,\n  collectIndexing,\n  collectModel,\n  collectSpec,\n  collectViewer,\n  runGit,\n  type ChangesetEntry,\n  type ErrorSection,\n  type GitRunner,\n  type RootResolution,\n  type StatusContext,\n} from \"./project-status-collectors.js\";\n\nconst inputSchema = {\n  rootPath: rootPathSchema,\n};\n\nexport type ProjectStatusArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\n/** The sections, one collector each. A new section is one more entry here. */\nconst COLLECTORS = {\n  model: collectModel,\n  spec: collectSpec,\n  changesets: collectChangesets,\n  codeIndex: collectCodeIndex,\n  codeDrift: collectCodeDrift,\n  indexing: collectIndexing,\n  viewer: collectViewer,\n} as const;\n\ntype Sections = {\n  [K in keyof typeof COLLECTORS]: Awaited<ReturnType<(typeof COLLECTORS)[K]>> | ErrorSection;\n};\n\nexport interface NextStep {\n  summary: string;\n  /** The tool to call, or null when the step is outside DR (update the CLI, fix a file). */\n  tool: string | null;\n  args?: Record<string, unknown>;\n  /** A second call that follows the first. */\n  then?: { tool: string; args?: Record<string, unknown> };\n  /**\n   * Something else that needs doing alongside this step, not after it: an index run in progress,\n   * or an index that hasn't seen the latest code, while a changeset is active.\n   */\n  also?: { summary: string; tool: string; args?: Record<string, unknown> };\n}\n\nexport interface ProjectStatus extends Sections {\n  project: { root: string; resolvedBy: RootResolution; projectRoot: string | null };\n  nextStep: NextStep;\n}\n\nconst RESOLVED_BY: Record<ProjectRootSource, RootResolution> = {\n  env: \"DR_MCP_ROOT_PATH\",\n  \"client-roots\": \"mcp-roots\",\n  cwd: \"cwd\",\n};\n\n/** Collects every section and picks the next step. `git` is injectable for tests. */\nexport async function projectStatus(\n  args: ProjectStatusArgs,\n  options: { git?: GitRunner } = {}\n): Promise<ProjectStatus> {\n  let root: string;\n  let resolvedBy: RootResolution;\n  if (args.rootPath) {\n    root = path.resolve(args.rootPath);\n    resolvedBy = \"rootPath\";\n  } else {\n    await whenProjectRootSettled();\n    const current = currentProjectRoot();\n    root = current.root;\n    resolvedBy = RESOLVED_BY[current.source];\n  }\n\n  const projectRoot = await findProjectRoot(root);\n  const manifest = projectRoot ? path.join(projectRoot, \"documentation-robotics\", \"model\", \"manifest.yaml\") : null;\n  const modelDir = manifest && (await fileExists(manifest)) ? path.dirname(manifest) : null;\n\n  let modelPromise: Promise<Model> | undefined;\n  const ctx: StatusContext = {\n    root,\n    resolvedBy,\n    projectRoot,\n    modelDir,\n    model: () => (modelPromise ??= freshModel(args.rootPath, modelDir)),\n    git: options.git ?? runGit,\n  };\n\n  const entries = await Promise.all(\n    Object.entries(COLLECTORS).map(async ([key, collect]) => {\n      try {\n        return [key, await collect(ctx)] as const;\n      } catch (error) {\n        return [key, { status: \"error\", error: getErrorMessage(error) } satisfies ErrorSection] as const;\n      }\n    })\n  );\n  const sections = Object.fromEntries(entries) as Sections;\n\n  return {\n    project: { root, resolvedBy, projectRoot },\n    ...sections,\n    nextStep: suggestNextStep(sections, { root, rootPath: args.rootPath }),\n  };\n}\n\n/** The model files' signature when this tool last read the model, per rootPath cache key. */\nconst lastSignature = new Map<string, string>();\n\n/** Test-only: forget the recorded signatures. */\nexport function clearProjectStatusSignatures(): void {\n  lastSignature.clear();\n}\n\n/**\n * The model as it is on disk now. The server's cached model can be stale after a CLI command, a\n * pull or a hand edit, while git and changesets are read fresh. So the model files are stat'ed\n * (cheap), and the model is reloaded into the shared cache when they changed since this tool last\n * read it, or when this tool has not read it yet.\n */\nasync function freshModel(rootPath: string | undefined, modelDir: string | null): Promise<Model> {\n  const key = rootPath ?? \"\";\n  const signature = modelDir ? await filesSignature(modelDir) : null;\n  if (signature !== null && lastSignature.get(key) === signature) return loadModel(rootPath);\n  const model = await reloadModel(rootPath);\n  if (signature !== null) lastSignature.set(key, signature);\n  return model;\n}\n\n/** File count, summed mtimes and summed sizes of every file under `dir`. */\nasync function filesSignature(dir: string): Promise<string | null> {\n  try {\n    const entries = await readdir(dir, { recursive: true, withFileTypes: true });\n    const stats = await Promise.all(\n      entries.filter((entry) => entry.isFile()).map((entry) => stat(path.join(entry.parentPath, entry.name)))\n    );\n    let mtimes = 0;\n    let sizes = 0;\n    for (const s of stats) {\n      mtimes += s.mtimeMs;\n      sizes += s.size;\n    }\n    return `${stats.length}:${mtimes}:${sizes}`;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * The one thing to do next, in order: create a model, upgrade it, continue the active changeset,\n * index the code when drift needs a fresh index, catch the model up with the code, index the code.\n */\nexport function suggestNextStep(s: Sections, ctx: { root: string; rootPath?: string }): NextStep {\n  const step = withIndexNote(whileIndexing(pickNextStep(s, ctx.root), s), s);\n  if (!ctx.rootPath) return step;\n  // A call that named its project passes it on, so the next call serves the same one.\n  const withRoot = (args?: Record<string, unknown>) => ({ ...args, rootPath: ctx.rootPath });\n  return {\n    ...step,\n    ...(step.tool ? { args: withRoot(step.args) } : {}),\n    ...(step.then ? { then: { ...step.then, args: withRoot(step.then.args) } } : {}),\n    ...(step.also ? { also: { ...step.also, args: withRoot(step.also.args) } } : {}),\n  };\n}\n\n/** The call that waits for an index run already going. */\nconst WAIT_ARGS = { status: true, wait: 30 };\n\n/**\n * A step that isn't about the index still says when the index needs attention, so the agent\n * doesn't take an index run in progress, or one that hasn't seen the latest code, as settled.\n * The step itself stands: an active changeset is still the thing to pick up. The index call goes\n * in `also` unless the step already uses it, and in the summary either way.\n */\nfunction withIndexNote(step: NextStep, s: Sections): NextStep {\n  if (step.tool === \"codebase_index\") return step;\n  let also: NextStep[\"also\"];\n  if (s.indexing?.status === \"running\") {\n    also = {\n      summary: `The code is being indexed (started ${s.indexing.startedAt}); until it is done, codebase tools read the old index. Call codebase_index with status: true and wait: 30 to wait for it.`,\n      tool: \"codebase_index\",\n      args: WAIT_ARGS,\n    };\n  } else if (s.changesets?.status === \"ok\" && s.changesets.active) {\n    // Without an active changeset, pickNextStep already sends a stale index to codebase_index.\n    if (s.codeIndex?.status === \"fresh-with-uncommitted-edits\" || s.codeIndex?.status === \"stale\") {\n      const why =\n        s.codeIndex.status === \"stale\"\n          ? `The code index is stale${s.codeIndex.reason ? `: ${s.codeIndex.reason}` : \"\"}.`\n          : `The code index predates uncommitted edits${s.codeIndex.reason ? `: ${s.codeIndex.reason}` : \"\"}.`;\n      also = {\n        summary: `${why} Refresh it with codebase_index before extracting or verifying against the code.`,\n        tool: \"codebase_index\",\n        args: INDEX_ARGS,\n      };\n    }\n  }\n  if (!also) return step;\n  // A step that already has its own `also` (the as-built step's changeset_activate) keeps it; the\n  // index still gets said, in the summary.\n  if (step.also) return { ...step, summary: `${step.summary} Also: ${also.summary}` };\n  return { ...step, summary: `${step.summary} Also: ${also.summary}`, also };\n}\n\n/** A step that would start an index run waits for the one already running instead. */\nfunction whileIndexing(step: NextStep, s: Sections): NextStep {\n  if (step.tool !== \"codebase_index\" || s.indexing?.status !== \"running\") return step;\n  return {\n    summary: `The code is being indexed (started ${s.indexing.startedAt}). Call codebase_index with status: true and wait: 30 until it is done.`,\n    tool: \"codebase_index\",\n    args: { status: true, wait: 30 },\n    ...(step.then ? { then: step.then } : {}),\n  };\n}\n\n/** Starting an index run: block up to 30 s for it rather than poll. */\nconst INDEX_ARGS = { wait: 30 };\n\nfunction pickNextStep(s: Sections, root: string): NextStep {\n  const ctx = { root };\n  const { model, spec, changesets, codeDrift, codeIndex } = s;\n\n  if (model.status === \"absent\") {\n    return {\n      summary: `There is no DR model in ${ctx.root}. Create one with project_init.`,\n      tool: \"project_init\",\n    };\n  }\n  if (model.status === \"error\") {\n    return { summary: `The model could not be read: ${model.error}`, tool: null };\n  }\n\n  if (spec.status === \"behind\") {\n    const how = spec.migration?.available\n      ? \"Preview and apply the migration with project_upgrade.\"\n      : \"The CLI has no migration path between them; project_upgrade reports the options.\";\n    return {\n      summary: `The model is on spec ${spec.model}; this CLI carries ${spec.cli}. ${how}`,\n      tool: \"project_upgrade\",\n    };\n  }\n  if (spec.status === \"ahead\") {\n    return {\n      summary: `The model is on spec ${spec.model}, newer than this CLI's ${spec.cli}. Update the dr CLI before changing the model.`,\n      tool: null,\n    };\n  }\n\n  if (model.loadError) {\n    return {\n      summary: `The model could not be loaded: ${model.loadError}. Fix the files under documentation-robotics/model/.`,\n      tool: null,\n    };\n  }\n\n  if (changesets.status === \"ok\" && changesets.active?.asBuilt) {\n    return asBuiltStep(changesets.active, changesets.staged);\n  }\n\n  if (changesets.status === \"ok\" && changesets.active) {\n    const { name, changes, baseDrifted } = changesets.active;\n    const drifted = baseDrifted ? \" Its base model has changed since it was opened.\" : \"\";\n    return {\n      summary: `Changeset \"${name}\" is active with ${changes.total} staged change${changes.total === 1 ? \"\" : \"s\"}.${drifted} Read its brief with changeset_brief to pick up the plan.`,\n      tool: \"changeset_brief\",\n    };\n  }\n\n  if (codeDrift.status === \"drift\") {\n    const files = codeDrift.changedSourceFiles.length + codeDrift.uncommittedSourceFiles.length;\n    const sha = codeDrift.modelCommit.sha;\n    const drift =\n      `${files} source file${files === 1 ? \"\" : \"s\"} the model references changed since the model was last updated, ` +\n      `not counting spec migrations (${sha.slice(0, 7)}, ${codeDrift.commitsSince} commit${codeDrift.commitsSince === 1 ? \"\" : \"s\"} ago).`;\n    // codebase_verify refuses without a fresh index, so build or refresh it first.\n    if (codeIndex.status !== \"fresh\") {\n      const index =\n        codeIndex.status === \"stale\"\n          ? \"The code index is stale\"\n          : codeIndex.status === \"fresh-with-uncommitted-edits\"\n            ? \"Source files were edited after the code index was taken\"\n            : \"The code has no usable index\";\n      return {\n        summary:\n          `${drift} ${index}: rebuild it with codebase_index, then check the API layer with codebase_verify ` +\n          `and model the changes with codebase_extract since ${sha.slice(0, 7)}.`,\n        tool: \"codebase_index\",\n        args: INDEX_ARGS,\n        then: { tool: \"codebase_verify\" },\n      };\n    }\n    return {\n      summary: `${drift} Check the API layer with codebase_verify, then model the changes with codebase_extract since ${sha.slice(0, 7)}.`,\n      tool: \"codebase_verify\",\n      then: { tool: \"codebase_extract\", args: { since: sha } },\n    };\n  }\n\n  if (codeIndex.status === \"absent\") {\n    return {\n      summary: \"The code has no index. Build one with codebase_index.\",\n      tool: \"codebase_index\",\n      args: INDEX_ARGS,\n    };\n  }\n  if (codeIndex.status === \"stale\") {\n    return {\n      summary: `The code index is stale: ${codeIndex.reason ?? `it was built at ${codeIndex.indexedCommit.slice(0, 7)}`}. Refresh it with codebase_index.`,\n      tool: \"codebase_index\",\n      args: INDEX_ARGS,\n    };\n  }\n  if (codeIndex.status === \"fresh-with-uncommitted-edits\") {\n    return {\n      summary: `The code index predates uncommitted edits: ${codeIndex.reason}. Refresh it with codebase_index.`,\n      tool: \"codebase_index\",\n      args: INDEX_ARGS,\n    };\n  }\n\n  if (changesets.status === \"ok\" && changesets.staged.length > 0) {\n    const names = changesets.staged.map((changeset) => `\"${changeset.name}\"`).join(\", \");\n    return {\n      summary: `No changeset is active; ${changesets.staged.length} staged: ${names}. Activate one with changeset_activate to continue it, or plan a new change with changeset_create.`,\n      tool: \"changeset_activate\",\n    };\n  }\n\n  return {\n    summary: \"The model is current and in step with the code. To plan a change, start with changeset_create.\",\n    tool: \"changeset_create\",\n  };\n}\n\n/**\n * The step for an active as-built changeset (one codebase_extract staged): it holds what was\n * built, not a plan, so it is never \"the plan to pick up\". With a plan staged it is the as-built\n * side of a verify, and the plan is reactivated before any edits; with none, it is a\n * keep-as-built catch-up, reviewed and landed as itself.\n */\nfunction asBuiltStep(asBuilt: ChangesetEntry, staged: ChangesetEntry[]): NextStep {\n  const changes = `${asBuilt.changes.total} staged change${asBuilt.changes.total === 1 ? \"\" : \"s\"}`;\n  const intro =\n    `Changeset \"${asBuilt.name}\" is active, with ${changes}: it is the as-built changeset codebase_extract staged ` +\n    \"from the code, not a plan. Don't build from it or edit it as a plan.\";\n  const plans = staged.filter((entry) => entry.id !== asBuilt.id && !entry.asBuilt);\n  const fromRecord = asBuilt.previousActive ? plans.find((entry) => entry.id === asBuilt.previousActive!.id) : undefined;\n  const plan = fromRecord ?? (plans.length === 1 ? plans[0] : undefined);\n\n  if (plan) {\n    return {\n      summary:\n        `${intro} It is the as-built side of a verify against the plan \"${plan.name}\": compare them with ` +\n        `changeset_verify (planned: \"${plan.name}\", against: {changesetId: \"${asBuilt.id}\"}), and reactivate the plan ` +\n        \"with changeset_activate before any edits.\",\n      tool: \"changeset_verify\",\n      args: { planned: plan.id, against: { changesetId: asBuilt.id } },\n      also: {\n        summary: `Reactivate the plan \"${plan.name}\" with changeset_activate before editing anything, so changes stage into it.`,\n        tool: \"changeset_activate\",\n        args: { changesetId: plan.id },\n      },\n    };\n  }\n  if (plans.length > 1) {\n    const names = plans.map((entry) => `\"${entry.name}\"`).join(\", \");\n    return {\n      summary:\n        `${intro} ${plans.length} plans are staged (${names}), and nothing records which one this build is for. ` +\n        `Ask the user, then call changeset_verify with planned: <that plan> and against: {changesetId: \"${asBuilt.id}\"}, ` +\n        \"and reactivate the plan with changeset_activate before any edits.\",\n      tool: null,\n    };\n  }\n  return {\n    summary:\n      `${intro} No plan is staged, so it is a keep-as-built catch-up: it holds what was built and is reviewed and ` +\n      \"landed as itself. Show it to the user with review_open, and land it with changeset_commit when they ask.\",\n    tool: \"review_open\",\n    args: { changeset: asBuilt.id },\n  };\n}\n\nexport async function projectStatusHandler(args: ProjectStatusArgs): Promise<CallToolResult> {\n  return runTool(async () => jsonResult(await projectStatus(args), { compact: true }));\n}\n\nexport const projectStatusTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"project_status\",\n  description:\n    \"Where this repo stands with DR, and what to do next: the project root and how it was found, whether a model exists, its spec version against this CLI's, the active and staged changesets, whether the code index exists and is fresh (and any indexing run in progress), code changed since the model last changed (from git), and the viewer running for the project with its link. Ends with nextStep: a sentence and the tool to call. Reads local files and git only. Call it first in a session.\",\n  inputSchema,\n  handler: projectStatusHandler,\n};\n"],
+  "mappings": "AASA,OAAO,UAAU;AAIjB,SAAS,uBAAuB;AAChC,SAAS,kBAAkB;AAC3B,SAAS,uBAAuB;AAChC,SAAS,oBAAoB,8BAAsD;AACnF,SAAS,SAAS,YAAY;AAC9B,SAAS,YAAY,WAAW,aAAa,gBAAgB,eAAuC;AACpG,SACE,mBACA,kBACA,kBACA,iBACA,cACA,aACA,eACA,cAMK;AAEP,MAAM,cAAc;EAClB,UAAU;GAMN,aAAa;EACjB,OAAO;EACP,MAAM;EACN,YAAY;EACZ,WAAW;EACX,WAAW;EACX,UAAU;EACV,QAAQ;GA0BJ,cAAyD;EAC7D,KAAK;EACL,gBAAgB;EAChB,KAAK;;AAIP,eAAsB,cACpB,MACA,UAA+B,CAAA,GAAE;AAEjC,MAAI,MACA;AACJ,MAAI,KAAK;AACP,WAAO,KAAK,QAAQ,KAAK,QAAQ,GACjC,aAAa;OACR;AACL,UAAM,uBAAsB;AAC5B,UAAM,UAAU,mBAAkB;AAClC,WAAO,QAAQ,MACf,aAAa,YAAY,QAAQ,MAAM;EACzC;AAEA,QAAM,cAAc,MAAM,gBAAgB,IAAI,GACxC,WAAW,cAAc,KAAK,KAAK,aAAa,0BAA0B,SAAS,eAAe,IAAI,MACtG,WAAW,YAAa,MAAM,WAAW,QAAQ,IAAK,KAAK,QAAQ,QAAQ,IAAI;AAErF,MAAI;AACJ,QAAM,MAAqB;IACzB;IACA;IACA;IACA;IACA,OAAO,MAAO,iBAAiB,WAAW,KAAK,UAAU,QAAQ;IACjE,KAAK,QAAQ,OAAO;KAGhB,UAAU,MAAM,QAAQ,IAC5B,OAAO,QAAQ,UAAU,EAAE,IAAI,OAAO,CAAC,KAAK,OAAO,MAAK;AACtD,QAAI;AACF,aAAO,CAAC,KAAK,MAAM,QAAQ,GAAG,CAAC;IACjC,SAAS,OAAO;AACd,aAAO,CAAC,KAAK,EAAE,QAAQ,SAAS,OAAO,gBAAgB,KAAK,EAAC,CAAyB;IACxF;EACF,CAAC,CAAC,GAEE,WAAW,OAAO,YAAY,OAAO;AAE3C,SAAO;IACL,SAAS,EAAE,MAAM,YAAY,YAAW;IACxC,GAAG;IACH,UAAU,gBAAgB,UAAU,EAAE,MAAM,UAAU,KAAK,SAAQ,CAAE;;AAEzE;AAGA,MAAM,gBAAgB,oBAAI,IAAG;AAGvB,SAAU,+BAA4B;AAC1C,gBAAc,MAAK;AACrB;AAQA,eAAe,WAAW,UAA8B,UAAuB;AAC7E,QAAM,MAAM,YAAY,IAClB,YAAY,WAAW,MAAM,eAAe,QAAQ,IAAI;AAC9D,MAAI,cAAc,QAAQ,cAAc,IAAI,GAAG,MAAM;AAAW,WAAO,UAAU,QAAQ;AACzF,QAAM,QAAQ,MAAM,YAAY,QAAQ;AACxC,SAAI,cAAc,QAAM,cAAc,IAAI,KAAK,SAAS,GACjD;AACT;AAGA,eAAe,eAAe,KAAW;AACvC,MAAI;AACF,UAAM,UAAU,MAAM,QAAQ,KAAK,EAAE,WAAW,IAAM,eAAe,GAAI,CAAE,GACrE,QAAQ,MAAM,QAAQ,IAC1B,QAAQ,OAAO,CAAC,UAAU,MAAM,OAAM,CAAE,EAAE,IAAI,CAAC,UAAU,KAAK,KAAK,KAAK,MAAM,YAAY,MAAM,IAAI,CAAC,CAAC,CAAC;AAEzG,QAAI,SAAS,GACT,QAAQ;AACZ,eAAW,KAAK;AACd,gBAAU,EAAE,SACZ,SAAS,EAAE;AAEb,WAAO,GAAG,MAAM,MAAM,IAAI,MAAM,IAAI,KAAK;EAC3C,QAAQ;AACN,WAAO;EACT;AACF;AAMM,SAAU,gBAAgB,GAAa,KAAwC;AACnF,QAAM,OAAO,cAAc,cAAc,aAAa,GAAG,IAAI,IAAI,GAAG,CAAC,GAAG,CAAC;AACzE,MAAI,CAAC,IAAI;AAAU,WAAO;AAE1B,QAAM,WAAW,CAAC,UAAoC,EAAE,GAAG,MAAM,UAAU,IAAI,SAAQ;AACvF,SAAO;IACL,GAAG;IACH,GAAI,KAAK,OAAO,EAAE,MAAM,SAAS,KAAK,IAAI,EAAC,IAAK,CAAA;IAChD,GAAI,KAAK,OAAO,EAAE,MAAM,EAAE,GAAG,KAAK,MAAM,MAAM,SAAS,KAAK,KAAK,IAAI,EAAC,EAAE,IAAK,CAAA;IAC7E,GAAI,KAAK,OAAO,EAAE,MAAM,EAAE,GAAG,KAAK,MAAM,MAAM,SAAS,KAAK,KAAK,IAAI,EAAC,EAAE,IAAK,CAAA;;AAEjF;AAGA,MAAM,YAAY,EAAE,QAAQ,IAAM,MAAM,GAAE;AAQ1C,SAAS,cAAc,MAAgB,GAAW;AAChD,MAAI,KAAK,SAAS;AAAkB,WAAO;AAC3C,MAAI;AAqBJ,SApBI,EAAE,UAAU,WAAW,YACzB,OAAO;IACL,SAAS,sCAAsC,EAAE,SAAS,SAAS;IACnE,MAAM;IACN,MAAM;MAEC,EAAE,YAAY,WAAW,QAAQ,EAAE,WAAW,WAEnD,EAAE,WAAW,WAAW,kCAAkC,EAAE,WAAW,WAAW,aAKpF,OAAO;IACL,SAAS,GAJT,EAAE,UAAU,WAAW,UACnB,0BAA0B,EAAE,UAAU,SAAS,KAAK,EAAE,UAAU,MAAM,KAAK,EAAE,MAC7E,4CAA4C,EAAE,UAAU,SAAS,KAAK,EAAE,UAAU,MAAM,KAAK,EAAE,GAEpF;IACf,MAAM;IACN,MAAM;MAIP,OAGD,KAAK,OAAa,EAAE,GAAG,MAAM,SAAS,GAAG,KAAK,OAAO,UAAU,KAAK,OAAO,GAAE,IAC1E,EAAE,GAAG,MAAM,SAAS,GAAG,KAAK,OAAO,UAAU,KAAK,OAAO,IAAI,KAAI,IAJtD;AAKpB;AAGA,SAAS,cAAc,MAAgB,GAAW;AAChD,SAAI,KAAK,SAAS,oBAAoB,EAAE,UAAU,WAAW,YAAkB,OACxE;IACL,SAAS,sCAAsC,EAAE,SAAS,SAAS;IACnE,MAAM;IACN,MAAM,EAAE,QAAQ,IAAM,MAAM,GAAE;IAC9B,GAAI,KAAK,OAAO,EAAE,MAAM,KAAK,KAAI,IAAK,CAAA;;AAE1C;AAGA,MAAM,aAAa,EAAE,MAAM,GAAE;AAE7B,SAAS,aAAa,GAAa,MAAY;AAC7C,QAAM,MAAM,EAAE,KAAI,GACZ,EAAE,OAAO,MAAM,YAAY,WAAW,UAAS,IAAK;AAE1D,MAAI,MAAM,WAAW;AACnB,WAAO;MACL,SAAS,2BAA2B,IAAI,IAAI;MAC5C,MAAM;;AAGV,MAAI,MAAM,WAAW;AACnB,WAAO,EAAE,SAAS,gCAAgC,MAAM,KAAK,IAAI,MAAM,KAAI;AAG7E,MAAI,KAAK,WAAW,UAAU;AAC5B,UAAM,MAAM,KAAK,WAAW,YACxB,0DACA;AACJ,WAAO;MACL,SAAS,wBAAwB,KAAK,KAAK,sBAAsB,KAAK,GAAG,KAAK,GAAG;MACjF,MAAM;;EAEV;AACA,MAAI,KAAK,WAAW;AAClB,WAAO;MACL,SAAS,wBAAwB,KAAK,KAAK,2BAA2B,KAAK,GAAG;MAC9E,MAAM;;AAIV,MAAI,MAAM;AACR,WAAO;MACL,SAAS,kCAAkC,MAAM,SAAS;MAC1D,MAAM;;AAIV,MAAI,WAAW,WAAW,QAAQ,WAAW,QAAQ;AACnD,WAAO,YAAY,WAAW,QAAQ,WAAW,MAAM;AAGzD,MAAI,WAAW,WAAW,QAAQ,WAAW,QAAQ;AACnD,UAAM,EAAE,MAAM,SAAS,YAAW,IAAK,WAAW,QAC5C,UAAU,cAAc,qDAAqD;AACnF,WAAO;MACL,SAAS,cAAc,IAAI,oBAAoB,QAAQ,KAAK,iBAAiB,QAAQ,UAAU,IAAI,KAAK,GAAG,IAAI,OAAO;MACtH,MAAM;;EAEV;AAEA,MAAI,UAAU,WAAW,SAAS;AAChC,UAAM,QAAQ,UAAU,mBAAmB,SAAS,UAAU,uBAAuB,QAC/E,MAAM,UAAU,YAAY,KAC5B,QACJ,GAAG,KAAK,eAAe,UAAU,IAAI,KAAK,GAAG,iGACZ,IAAI,MAAM,GAAG,CAAC,CAAC,KAAK,UAAU,YAAY,UAAU,UAAU,iBAAiB,IAAI,KAAK,GAAG;AAE9H,QAAI,UAAU,WAAW,SAAS;AAChC,YAAM,QACJ,UAAU,WAAW,UACjB,4BACA,UAAU,WAAW,iCACnB,4DACA;AACR,aAAO;QACL,SACE,GAAG,KAAK,IAAI,KAAK,qIACoC,IAAI,MAAM,GAAG,CAAC,CAAC;QACtE,MAAM;QACN,MAAM;QACN,MAAM,EAAE,MAAM,kBAAiB;;IAEnC;AACA,WAAO;MACL,SAAS,GAAG,KAAK,iGAAiG,IAAI,MAAM,GAAG,CAAC,CAAC;MACjI,MAAM;MACN,MAAM,EAAE,MAAM,oBAAoB,MAAM,EAAE,OAAO,IAAG,EAAE;;EAE1D;AAEA,MAAI,UAAU,WAAW;AACvB,WAAO;MACL,SAAS;MACT,MAAM;MACN,MAAM;;AAGV,MAAI,UAAU,WAAW;AACvB,WAAO;MACL,SAAS,4BAA4B,UAAU,UAAU,mBAAmB,UAAU,cAAc,MAAM,GAAG,CAAC,CAAC,EAAE;MACjH,MAAM;MACN,MAAM;;AAGV,MAAI,UAAU,WAAW;AACvB,WAAO;MACL,SAAS,8CAA8C,UAAU,MAAM;MACvE,MAAM;MACN,MAAM;;AAIV,MAAI,WAAW,WAAW,QAAQ,WAAW,OAAO,SAAS,GAAG;AAC9D,UAAM,QAAQ,WAAW,OAAO,IAAI,CAAC,cAAc,IAAI,UAAU,IAAI,GAAG,EAAE,KAAK,IAAI;AACnF,WAAO;MACL,SAAS,2BAA2B,WAAW,OAAO,MAAM,YAAY,KAAK;MAC7E,MAAM;;EAEV;AAEA,SAAO;IACL,SAAS;IACT,MAAM;;AAEV;AAQA,SAAS,YAAY,SAAyB,QAAwB;AACpE,QAAM,UAAU,GAAG,QAAQ,QAAQ,KAAK,iBAAiB,QAAQ,QAAQ,UAAU,IAAI,KAAK,GAAG,IACzF,QACJ,cAAc,QAAQ,IAAI,qBAAqB,OAAO,+HAElD,QAAQ,OAAO,OAAO,CAAC,UAAU,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,OAAO,GAE1E,QADa,QAAQ,iBAAiB,MAAM,KAAK,CAAC,UAAU,MAAM,OAAO,QAAQ,eAAgB,EAAE,IAAI,YACjF,MAAM,WAAW,IAAI,MAAM,CAAC,IAAI;AAE5D,MAAI;AACF,WAAO;MACL,SACE,GAAG,KAAK,0DAA0D,KAAK,IAAI,oDAC5C,KAAK,IAAI,8BAA8B,QAAQ,EAAE;MAElF,MAAM;MACN,MAAM,EAAE,SAAS,KAAK,IAAI,SAAS,EAAE,aAAa,QAAQ,GAAE,EAAE;MAC9D,MAAM;QACJ,SAAS,wBAAwB,KAAK,IAAI;QAC1C,MAAM;QACN,MAAM,EAAE,aAAa,KAAK,GAAE;;;AAIlC,MAAI,MAAM,SAAS,GAAG;AACpB,UAAM,QAAQ,MAAM,IAAI,CAAC,UAAU,IAAI,MAAM,IAAI,GAAG,EAAE,KAAK,IAAI;AAC/D,WAAO;MACL,SACE,GAAG,KAAK,IAAI,MAAM,MAAM,sBAAsB,KAAK,sJAC+C,QAAQ,EAAE;MAE9G,MAAM;;EAEV;AACA,SAAO;IACL,SACE,GAAG,KAAK;IAEV,MAAM;IACN,MAAM,EAAE,WAAW,QAAQ,GAAE;;AAEjC;AAEA,eAAsB,qBAAqB,MAAuB;AAChE,SAAO,QAAQ,YAAY,WAAW,MAAM,cAAc,IAAI,GAAG,EAAE,SAAS,GAAI,CAAE,CAAC;AACrF;AAEO,MAAM,oBAA2D;EACtE,MAAM;EACN,aACE;EACF;EACA,SAAS;;",
+  "names": []
+}