codetrellis 0.0.0-stage → 0.2.0

package/src/backend/mcp/tools/drift-tools.js

@@ -0,0 +1,252 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var drift_tools_exports = {};
+__export(drift_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(drift_tools_exports);
+var import_zod = require("zod");
+var import_node_fs = __toESM(require("node:fs"));
+var import_helpers = require("../helpers");
+function register(server, deps) {
+  const missingPlan = (uid) => deps.planService.getPlan(uid) ? null : { content: [{ type: "text", text: `Plan ${uid} not found.` }], isError: true };
+  server.registerTool(
+    "get_deviations",
+    {
+      description: "Get all deviations between a plan and the actual codebase state. Shows where reality diverges from the plan.",
+      inputSchema: { plan_uid: import_zod.z.string() }
+    },
+    async ({ plan_uid }) => {
+      const refused = missingPlan(plan_uid);
+      if (refused) return refused;
+      const devs = deps.getDeviations(plan_uid);
+      return { content: [{ type: "text", text: JSON.stringify(devs, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "reconcile",
+    {
+      description: "Resolve deviations from a plan. Accept (update plan to match), revert (flag for review), or ignore.",
+      inputSchema: {
+        plan_uid: import_zod.z.string(),
+        deviations: import_zod.z.array(import_zod.z.object({
+          id: import_zod.z.number(),
+          action: import_zod.z.enum(["accepted", "reverted", "ignored"])
+        }))
+      }
+    },
+    async ({ plan_uid, deviations }, extra) => {
+      const refused = missingPlan(plan_uid);
+      if (refused) return refused;
+      const id = (0, import_helpers.authorFromExtra)(deps, extra);
+      try {
+        const n = deps.reconcileDeviations(plan_uid, deviations, { actor: id.author, actorType: id.authorType });
+        deps.broadcast("deviations-resolved", { planUid: plan_uid, ids: deviations.map((d) => d.id) });
+        deps.saveNow(() => deps.exportDatabase());
+        return { content: [{ type: "text", text: `Resolved ${n} deviation${n === 1 ? "" : "s"} on plan ${plan_uid}, in your name.` }] };
+      } catch (err) {
+        if (err instanceof deps.DeviationError) return { content: [{ type: "text", text: err.message }], isError: true };
+        throw err;
+      }
+    }
+  );
+  server.registerTool(
+    "detect_deviations",
+    {
+      description: "Run deviation detection for a plan \u2014 compares plan expectations against actual codebase state. Also detects unexpected files (changed since the baseline snapshot but not in any plan item's fileSpecs).",
+      inputSchema: { plan_uid: import_zod.z.string() }
+    },
+    async ({ plan_uid }) => {
+      const plan = deps.planService.getPlan(plan_uid);
+      if (!plan) return missingPlan(plan_uid);
+      const projectPath = plan.projectPath;
+      const snapshots = deps.listSnapshots(plan_uid);
+      let changedFiles;
+      if (snapshots.length > 0) {
+        const rawDiff = deps.computeTrellisDiff(snapshots[0].id);
+        if (rawDiff) {
+          const allChanged = [...rawDiff.addedFiles, ...rawDiff.modifiedFiles];
+          changedFiles = allChanged.filter((f) => {
+            const abs = f.startsWith("/") ? f : `${projectPath}/${f}`;
+            return import_node_fs.default.existsSync(abs);
+          });
+        }
+      }
+      const devs = deps.detectDeviations(plan_uid, changedFiles);
+      return { content: [{ type: "text", text: JSON.stringify({ detected: devs.length, deviations: devs }, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "list_proposed_changes",
+    {
+      description: `Granular CRUD feed projected from a plan's Actions: every affected file, symbol_spec, new_connection, and removed_connection becomes one ProposedChange row with operation (add/modify/remove/move), kind (file/symbol/connection), target, and a drift status (planned / in_progress / satisfied / missing / unexpected). Use this instead of walking item fields by hand to ask "what's left in this plan?".`,
+      inputSchema: { plan_uid: import_zod.z.string() }
+    },
+    async ({ plan_uid }) => {
+      const changes = deps.planChangesService.listProposedChanges(plan_uid);
+      return { content: [{ type: "text", text: JSON.stringify(changes, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "get_changes_summary",
+    {
+      description: `Aggregate counts for a plan's proposed changes \u2014 total + breakdown by drift status, kind, and operation. Use this to get a one-line "12/18 satisfied" picture without pulling every change row.`,
+      inputSchema: { plan_uid: import_zod.z.string() }
+    },
+    async ({ plan_uid }) => {
+      const summary = deps.planChangesService.summarizeChanges(plan_uid);
+      return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "get_change_status",
+    {
+      description: "Fetch a single ProposedChange (by id from list_proposed_changes) with its current drift status freshly computed against the live database.",
+      inputSchema: {
+        plan_uid: import_zod.z.string(),
+        change_id: import_zod.z.string()
+      }
+    },
+    async ({ plan_uid, change_id }) => {
+      const change = deps.planChangesService.getChange(plan_uid, change_id);
+      if (!change) return { content: [{ type: "text", text: `Change ${change_id} not found in plan ${plan_uid}` }], isError: true };
+      return { content: [{ type: "text", text: JSON.stringify(change, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "get_drift_report",
+    {
+      description: "Check if you are still following the plan. Compares the baseline snapshot (captured at plan approval) against the current live state. Returns what has changed, what is on track, and what has drifted. Also surfaces comment activity since `since_ms` (or since the baseline snapshot when omitted) so a returning agent can see what humans / other agents have said while it was away.",
+      inputSchema: {
+        plan_uid: import_zod.z.string(),
+        since_ms: import_zod.z.number().int().optional().describe('Epoch ms cutoff for "comment activity since". Defaults to the baseline snapshot timestamp.')
+      }
+    },
+    async ({ plan_uid, since_ms }) => {
+      const plan = deps.planService.getPlan(plan_uid);
+      const projectPath = plan?.projectPath ?? process.cwd();
+      const changesSummary = deps.planChangesService.summarizeChanges(plan_uid);
+      const proposedChanges = deps.planChangesService.listProposedChanges(plan_uid);
+      const onTrack = proposedChanges.filter((c) => c.driftStatus === "satisfied").map((c) => c.target);
+      const inProgress = proposedChanges.filter((c) => c.driftStatus === "in_progress").map((c) => c.target);
+      const missingChanges = proposedChanges.filter((c) => c.driftStatus === "missing").map((c) => c.target);
+      const planned = proposedChanges.filter((c) => c.driftStatus === "planned").map((c) => c.target);
+      const snapshots = deps.listSnapshots(plan_uid);
+      let snapshotDiff = null;
+      if (snapshots.length > 0) {
+        const rawDiff = deps.computeTrellisDiff(snapshots[0].id);
+        if (rawDiff) {
+          const freshAdded = rawDiff.addedFiles.filter((f) => {
+            const abs = f.startsWith("/") ? f : `${projectPath}/${f}`;
+            return import_node_fs.default.existsSync(abs);
+          });
+          const freshModified = rawDiff.modifiedFiles.filter((f) => {
+            const abs = f.startsWith("/") ? f : `${projectPath}/${f}`;
+            return import_node_fs.default.existsSync(abs);
+          });
+          snapshotDiff = {
+            addedFiles: freshAdded,
+            modifiedFiles: freshModified,
+            removedFiles: rawDiff.removedFiles,
+            addedEdges: rawDiff.addedEdges.length,
+            removedEdges: rawDiff.removedEdges.length
+          };
+        }
+      }
+      const plannedPaths = new Set(proposedChanges.filter((c) => c.kind === "file").map((c) => c.target));
+      const unexpectedFiles = [];
+      if (snapshotDiff) {
+        for (const file of [...snapshotDiff.addedFiles, ...snapshotDiff.modifiedFiles]) {
+          const isPlanned = [...plannedPaths].some(
+            (p) => file === p || file.endsWith("/" + p) || p.endsWith("/" + file)
+          );
+          if (!isPlanned) unexpectedFiles.push(file);
+        }
+      }
+      const items = deps.planItemService.listItemSummaries(plan_uid);
+      const actions = items.filter((i) => i.kind === "action");
+      const completedTasks = actions.filter((i) => i.status === "done").length;
+      const totalTasks = actions.length;
+      const since = since_ms ?? (snapshots.length > 0 ? snapshots[0].createdAt : Date.now() - 36e5);
+      const recentComments = deps.commentService.listCommentsForPlanSince(plan_uid, since);
+      const blockers = recentComments.filter((c) => c.kind === "blocker");
+      const questions = recentComments.filter((c) => c.kind === "question");
+      const progressUpdates = recentComments.filter((c) => c.kind === "progress");
+      return { content: [{ type: "text", text: JSON.stringify({
+        planTitle: plan?.title,
+        taskProgress: `${completedTasks}/${totalTasks}`,
+        // Plan-aware classification (from plan-changes-service — always fresh)
+        planAlignment: {
+          satisfied: onTrack.length,
+          inProgress: inProgress.length,
+          missing: missingChanges.length,
+          planned: planned.length,
+          unexpected: unexpectedFiles.length,
+          satisfiedTargets: onTrack,
+          missingTargets: missingChanges,
+          unexpectedFiles
+        },
+        changesSummary,
+        // Snapshot diff (filesystem-verified, no phantoms)
+        snapshotDiff,
+        hasBaseline: snapshots.length > 0,
+        commentActivitySince: since,
+        commentSummary: {
+          total: recentComments.length,
+          blockers: blockers.length,
+          questions: questions.length,
+          progressUpdates: progressUpdates.length
+        },
+        recentBlockers: blockers,
+        recentQuestions: questions
+      }, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "capture_checkpoint",
+    {
+      description: "Create a named checkpoint of the current codebase state. Useful for marking progress during long plans.",
+      inputSchema: {
+        plan_uid: import_zod.z.string(),
+        name: import_zod.z.string().describe('Name for this checkpoint, e.g. "After task 3"'),
+        project_path: import_zod.z.string()
+      }
+    },
+    async ({ plan_uid, name, project_path }) => {
+      const refused = missingPlan(plan_uid);
+      if (refused) return refused;
+      const snapshot = deps.captureCurrentTrellis(project_path, plan_uid, name);
+      deps.saveNow(() => deps.exportDatabase());
+      return { content: [{ type: "text", text: `Checkpoint "${name}" captured (snapshot #${snapshot.id}, ${snapshot.filesJson ? JSON.parse(snapshot.filesJson).length : 0} files)` }] };
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});

package/src/backend/mcp/tools/git-tools.js

@@ -0,0 +1,316 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var git_tools_exports = {};
+__export(git_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(git_tools_exports);
+var import_zod = require("zod");
+var import_git_commit_service = require("../../services/git-commit-service");
+var import_git_activity_service = require("../../services/git-activity-service");
+var import_plan_history_service = require("../../services/plan-history-service");
+var import_plan_conflict_service = require("../../services/plan-conflict-service");
+var import_line_history = require("../../services/line-history");
+var import_git_refs = require("../../services/git-refs");
+var import_commit_attribution = require("../../services/commit-attribution");
+function register(server, deps) {
+  server.registerTool(
+    "line_history",
+    {
+      description: "Who wrote a line (or lines) of a file and why: the commit, its git author and time, and what CodeTrellis knows of who made it and how it knows (from the commit message, seen when it landed in a recorded session, or by timing in this checkout), with the session, task and plan where known. Lines not yet committed say so. Read only; with no line, every run of lines from one commit.",
+      inputSchema: {
+        path: import_zod.z.string().describe("The file, relative to the project."),
+        line: import_zod.z.number().int().positive().optional().describe("The line (1-based). Omit for the whole file."),
+        end_line: import_zod.z.number().int().positive().optional().describe("The last line of a range, with line."),
+        at: import_zod.z.string().optional().describe("Which side: live (default), commit:<ref>, or workstream:<id> from list_workstreams."),
+        project_path: import_zod.z.string().optional().describe("An opened project. Defaults to the active project.")
+      }
+    },
+    async ({ path: rel, line, end_line, at, project_path }) => {
+      const projectRoot = project_path ?? deps.getActiveProjectPath();
+      if (!projectRoot) return { isError: true, content: [{ type: "text", text: "No project is open." }] };
+      if (!(0, import_commit_attribution.isProjectRelativePath)(rel)) return { isError: true, content: [{ type: "text", text: "path must be relative to the project." }] };
+      try {
+        const h = (0, import_line_history.lineHistory)(projectRoot, at ?? "live", rel, (0, import_git_refs.worktreesForCompare)(projectRoot), (0, import_commit_attribution.recordedKnowledge)(projectRoot));
+        if (line && line > h.lineCount) {
+          const has = h.lineCount === 0 ? "has no lines" : `has ${h.lineCount} line${h.lineCount === 1 ? "" : "s"}`;
+          return { isError: true, content: [{ type: "text", text: `${h.path} ${has} at ${at ?? "live"}; line ${line} is past its end.` }] };
+        }
+        const from = line ?? 1;
+        const to = line ? Math.max(end_line ?? line, line) : h.lineCount;
+        const said = h.hunks.filter((x) => x.end >= from && x.start <= to).map((x) => (0, import_line_history.lineWords)(h, Math.max(x.start, from)));
+        const words = line ? said.join("\n") : `${h.path}: ${h.hunks.length} run${h.hunks.length === 1 ? "" : "s"} of lines.
+${said.join("\n")}`;
+        return {
+          _meta: { summary: said[0] ?? `${h.path} has no lines.` },
+          content: [{ type: "text", text: `${words}
+
+$ ${h.command}` }]
+        };
+      } catch (err) {
+        if (err instanceof import_line_history.LineHistoryError) return { isError: true, content: [{ type: "text", text: err.message }] };
+        throw err;
+      }
+    }
+  );
+  server.registerTool(
+    "commit_manifest_changes",
+    {
+      description: 'Create a git commit in the project for the given paths, with a CDev-formatted message. Stages the supplied paths, composes a "[cdev] <subject>" commit message, and runs git commit. When agent attribution is supplied, appends a Co-Authored-By trailer and an agent/model metadata line so the commit history shows that an agent acted on the user\'s behalf. The git user identity (from `git config`) is always the commit author \u2014 accountability rests with the human. The Co-Authored-By possessive ("<human>\'s <agent>") reads `settings.identity.displayName ?? .email` \u2014 not git config directly \u2014 so if the user has edited their CodeTrellis identity the trailer reflects that. Use this when you (the agent) have completed work the user has authorised you to commit, or when the user has explicitly asked you to commit their pending manifest changes.',
+      inputSchema: {
+        project_root: import_zod.z.string().describe(
+          "Absolute path to the project root (must contain a .git directory)."
+        ),
+        subject: import_zod.z.string().describe(
+          'Imperative-mood subject line. Will be prefixed with "[cdev] " automatically. Keep under 72 characters.'
+        ),
+        paths: import_zod.z.array(import_zod.z.string()).describe(
+          "File paths to stage and commit, relative to project_root. The commit fails if this is empty or the paths produce no staged changes."
+        ),
+        body: import_zod.z.array(import_zod.z.string()).optional().describe(
+          "Optional commit message body paragraphs. Each entry becomes its own paragraph."
+        ),
+        agent: import_zod.z.object({
+          agent_type: import_zod.z.string().describe('Runtime identifier \u2014 e.g., "claude-code", "cursor", "codex".'),
+          model: import_zod.z.string().nullable().optional().describe('Specific model \u2014 e.g., "opus-4". Optional.')
+        }).optional().describe(
+          "When set, attributes the commit to an agent acting on the user's behalf. Adds Co-Authored-By trailer + agent/model metadata line. Omit for direct human commits."
+        ),
+        signed: import_zod.z.boolean().optional().describe(
+          "Sign the commit with the user's configured signing key (git commit -S). Requires the user to have signing set up."
+        )
+      }
+    },
+    async ({ project_root, subject, paths, body, agent, signed }) => {
+      let agentAttribution;
+      if (agent) {
+        const settings = deps.getSettings();
+        const humanIdentity = settings.identity.displayName || settings.identity.email || null;
+        agentAttribution = {
+          agentType: agent.agent_type,
+          model: agent.model ?? null,
+          humanIdentity
+        };
+      }
+      const result = (0, import_git_commit_service.commitManifestChanges)({
+        projectRoot: project_root,
+        subject,
+        body,
+        paths,
+        agent: agentAttribution,
+        signed
+      });
+      deps.broadcast("git-commit-created", {
+        projectRoot: project_root,
+        sha: result.sha,
+        subject,
+        agentAttributed: !!agent
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ sha: result.sha, message: result.message }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "get_team_activity",
+    {
+      description: 'Get the team activity feed for a project \u2014 a "what happened recently" view drawn entirely from the git history of the .codetrellis/ manifest directory. Shows who created, updated, or deleted plans, items, channel events, system docs, and config. Each entry is attributed and timestamped. Complementary to the DB-driven plan_events (which tracks in-session mutations).',
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path to the project root."),
+        since: import_zod.z.string().optional().describe("ISO date \u2014 only include commits after this point. Default: last 7 days."),
+        limit: import_zod.z.number().optional().describe("Max entries to return (default 50).")
+      }
+    },
+    async ({ project_path, since, limit }) => {
+      const sinceVal = since ?? new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString();
+      const entries = (0, import_git_activity_service.getTeamActivity)({ projectRoot: project_path, since: sinceVal, limit });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ total: entries.length, entries }, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "get_plan_history",
+    {
+      description: "List commits that touched a specific plan's manifest directory. Returns commit metadata (hash, timestamp, author, subject) in reverse-chronological order. Use the commit hashes with get_plan_at_commit to reconstruct the plan's state at any point in history.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path to the project root."),
+        plan_slug: import_zod.z.string().describe("Slug of the plan directory under .codetrellis/plans/."),
+        limit: import_zod.z.number().optional().describe("Max commits to return (default 30)."),
+        since: import_zod.z.string().optional().describe("ISO date \u2014 only include commits after this point.")
+      }
+    },
+    async ({ project_path, plan_slug, limit, since }) => {
+      const commits = (0, import_git_activity_service.getPlanCommitHistory)(project_path, plan_slug, { limit, since });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ total: commits.length, commits }, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "get_plan_at_commit",
+    {
+      description: 'Reconstruct the full state of a plan at a specific git commit. Returns the plan metadata and all items as they existed at that point in time. Use this with get_plan_history to implement a "time machine" for plans \u2014 view any historical snapshot.',
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path to the project root."),
+        plan_slug: import_zod.z.string().describe("Slug of the plan directory under .codetrellis/plans/."),
+        commit_hash: import_zod.z.string().describe("Git commit hash to read the plan state from.")
+      }
+    },
+    async ({ project_path, plan_slug, commit_hash }) => {
+      const state = (0, import_plan_history_service.getPlanAtCommit)(project_path, plan_slug, commit_hash);
+      if (!state) {
+        return { content: [{ type: "text", text: `Could not read plan "${plan_slug}" at commit ${commit_hash}. The plan or commit may not exist.` }], isError: true };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(state, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "diff_plan_between_commits",
+    {
+      description: "Compare a plan's state between two commits. Shows what items were added, removed, and which fields changed. Useful for understanding what happened between two points in time.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path to the project root."),
+        plan_slug: import_zod.z.string().describe("Slug of the plan directory."),
+        base_commit: import_zod.z.string().describe('Earlier commit hash (the "before").'),
+        head_commit: import_zod.z.string().describe('Later commit hash (the "after"). Use "HEAD" for current.')
+      }
+    },
+    async ({ project_path, plan_slug, base_commit, head_commit }) => {
+      const diff = (0, import_plan_history_service.diffPlanBetweenCommits)(project_path, plan_slug, base_commit, head_commit);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(diff, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "search_plan_history",
+    {
+      description: `Search a plan's git history for commits where specific text was added or removed. "Why did we choose this approach?" \u2014 find the commit where a decision was recorded and view the plan's state at that moment. Uses git log -G for content-level search.`,
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path to the project root."),
+        plan_slug: import_zod.z.string().describe("Slug of the plan directory."),
+        query: import_zod.z.string().describe("Text to search for in plan file content (case-insensitive)."),
+        since: import_zod.z.string().optional().describe("ISO date \u2014 only include commits after this point."),
+        until: import_zod.z.string().optional().describe("ISO date \u2014 only include commits before this point."),
+        limit: import_zod.z.number().optional().describe("Max results (default 20).")
+      }
+    },
+    async ({ project_path, plan_slug, query, since, until, limit }) => {
+      const results = (0, import_git_activity_service.searchPlanHistory)(project_path, plan_slug, query, { since, until, limit });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ total: results.length, results }, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "detect_conflicts",
+    {
+      description: "Detect merge conflicts in .codetrellis/ manifest files. Returns a summary of all conflicted files with field-level details where possible (structured fields like status, assignee, visibility can be auto-resolved; free-text fields need manual resolution). Only returns results when git is in a merge state.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path to the project root.")
+      }
+    },
+    async ({ project_path }) => {
+      const summary = (0, import_plan_conflict_service.detectManifestConflicts)(project_path);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(summary, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "resolve_conflict",
+    {
+      description: 'Resolve a merge conflict in a specific .codetrellis/ file. Two modes: "by_side" picks the entire ours or theirs version; "by_field" allows field-level resolution where each conflicting field can independently use ours, theirs, or a custom value. The resolved file is written and staged.',
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path to the project root."),
+        file_path: import_zod.z.string().describe("Path to the conflicted file (relative to project root)."),
+        mode: import_zod.z.enum(["by_side", "by_field"]).describe('"by_side" to pick ours/theirs entirely, "by_field" for per-field resolution.'),
+        side: import_zod.z.enum(["ours", "theirs"]).optional().describe("Required for by_side mode. Which side to pick."),
+        resolutions: import_zod.z.array(import_zod.z.object({
+          field: import_zod.z.string().describe("Field name to resolve."),
+          pick: import_zod.z.enum(["ours", "theirs", "custom"]).describe("Which side to pick for this field."),
+          custom_value: import_zod.z.unknown().optional().describe('Custom value when pick is "custom".')
+        })).optional().describe("Required for by_field mode. Per-field resolutions.")
+      }
+    },
+    async ({ project_path, file_path, mode, side, resolutions }) => {
+      if (mode === "by_side") {
+        if (!side) {
+          return { content: [{ type: "text", text: "Side is required for by_side mode." }], isError: true };
+        }
+        const result2 = (0, import_plan_conflict_service.resolveFileConflictBySide)(project_path, file_path, side);
+        return {
+          content: [{
+            type: "text",
+            text: result2.resolved ? `Resolved ${file_path} using "${side}" version.` : `Failed to resolve: ${result2.error}`
+          }],
+          isError: !result2.resolved
+        };
+      }
+      if (!resolutions || resolutions.length === 0) {
+        return { content: [{ type: "text", text: "Resolutions are required for by_field mode." }], isError: true };
+      }
+      const result = (0, import_plan_conflict_service.resolveFileConflict)(
+        project_path,
+        file_path,
+        resolutions.map((r) => ({
+          field: r.field,
+          pick: r.pick,
+          customValue: r.custom_value
+        }))
+      );
+      return {
+        content: [{
+          type: "text",
+          text: result.resolved ? `Resolved ${file_path} with ${resolutions.length} field-level resolutions.` : `Failed to resolve: ${result.error}`
+        }],
+        isError: !result.resolved
+      };
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});