agentloopkit 0.24.5 → 0.26.0

package/dist/cli/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 
 // src/cli/commands/init.ts
 import { Command } from "commander";
 
 // src/core/init.ts
 import path6 from "path";
-import { readdir as readdir3, realpath } from "fs/promises";
+import { readdir as readdir3, realpath, stat as stat2 } from "fs/promises";
 import { homedir } from "os";
 
 // src/core/constants.ts
@@ -342,6 +342,21 @@ async function listTemplateFiles() {
 }
 
 // src/core/init.ts
+var LOCAL_ONLY_EXCLUDE_START = "# agentloopkit:local-only:start";
+var LOCAL_ONLY_EXCLUDE_END = "# agentloopkit:local-only:end";
+var LOCAL_ONLY_NOTICE_START = "<!-- agentloopkit:local-only:start -->";
+var LOCAL_ONLY_NOTICE_END = "<!-- agentloopkit:local-only:end -->";
+var LOCAL_ONLY_EXCLUDE_PATTERNS = [
+  `${AGENTLOOP_DIR}/`,
+  AGENTS_FILE,
+  AGENTLOOP_FILE,
+  CONFIG_FILE
+];
+var LOCAL_ONLY_NOTICE = `${LOCAL_ONLY_NOTICE_START}
+## Local-only AgentLoopKit harness
+
+This AgentLoopKit setup is excluded by this clone's \`.git/info/exclude\`. Use these files for local agent work. Do not commit these AgentLoopKit files unless a maintainer intentionally converts the repo to a shared harness.
+${LOCAL_ONLY_NOTICE_END}`;
 async function writeGeneratedFile(filePath, content, result) {
   if (await pathExists(filePath)) {
     result.skipped.push(filePath);
@@ -395,6 +410,65 @@ ${section.trim()}
 `);
   result.updated.push(filePath);
 }
+async function resolveGitInfoExcludePath(cwd) {
+  const dotGitPath = path6.join(cwd, ".git");
+  const dotGitStat = await stat2(dotGitPath).catch(() => void 0);
+  if (!dotGitStat) return void 0;
+  if (dotGitStat.isDirectory()) {
+    return path6.join(dotGitPath, "info", "exclude");
+  }
+  if (!dotGitStat.isFile()) return void 0;
+  const gitFile = await readTextIfExists(dotGitPath);
+  const match = /^gitdir:\s*(.+)\s*$/m.exec(gitFile);
+  if (!match) return void 0;
+  const gitDir = match[1].trim();
+  const resolvedGitDir = path6.isAbsolute(gitDir) ? gitDir : path6.resolve(cwd, gitDir);
+  return path6.join(resolvedGitDir, "info", "exclude");
+}
+async function upsertLocalOnlyGitExclude(cwd, result) {
+  const excludePath = await resolveGitInfoExcludePath(cwd);
+  if (!excludePath) {
+    throw new Error(
+      "Local-only mode requires a Git repository because it writes to .git/info/exclude. Run git init first, or run agentloop init without --local-only."
+    );
+  }
+  result.localOnly = {
+    excludePath,
+    patterns: [...LOCAL_ONLY_EXCLUDE_PATTERNS]
+  };
+  const excludeExists = await pathExists(excludePath);
+  const existing = await readTextIfExists(excludePath);
+  if (existing.includes(LOCAL_ONLY_EXCLUDE_START)) return;
+  const block = [
+    LOCAL_ONLY_EXCLUDE_START,
+    "# AgentLoopKit local-only harness files for this clone.",
+    ...LOCAL_ONLY_EXCLUDE_PATTERNS,
+    LOCAL_ONLY_EXCLUDE_END
+  ].join("\n");
+  if (result.dryRun) {
+    (excludeExists ? result.updated : result.created).push(excludePath);
+    return;
+  }
+  const prefix = existing.trimEnd();
+  await writeTextFile(excludePath, `${prefix ? `${prefix}
+
+` : ""}${block}
+`);
+  (excludeExists ? result.updated : result.created).push(excludePath);
+}
+async function upsertLocalOnlyNotice(filePath, result) {
+  const existing = await readTextIfExists(filePath);
+  if (existing.includes(LOCAL_ONLY_NOTICE_START)) return;
+  if (result.dryRun) {
+    (existing ? result.updated : result.created).push(filePath);
+    return;
+  }
+  await writeTextFile(filePath, `${existing.trimEnd()}
+
+${LOCAL_ONLY_NOTICE}
+`);
+  (existing ? result.updated : result.created).push(filePath);
+}
 async function resolveComparablePath(filePath) {
   try {
     return await realpath(filePath);
@@ -420,6 +494,9 @@ async function initializeAgentLoop(options) {
       "Refusing to initialize your home directory. Run this inside a project repository, or pass --force if you intentionally want AgentLoopKit files in your home directory."
     );
   }
+  if (options.localOnly) {
+    await upsertLocalOnlyGitExclude(cwd, result);
+  }
   const packageManager = await detectPackageManager(cwd);
   const projectType = await detectProjectType(cwd);
   const projectName = await detectProjectName(cwd);
@@ -438,7 +515,8 @@ async function initializeAgentLoop(options) {
     lintCommand: commands.lint || "not configured",
     typecheckCommand: commands.typecheck || "not configured",
     buildCommand: commands.build || "not configured",
-    formatCommand: commands.format || "not configured"
+    formatCommand: commands.format || "not configured",
+    localOnlyInstructions: options.localOnly ? LOCAL_ONLY_NOTICE : ""
   };
   for (const group of TEMPLATE_GROUPS) {
     if (group === "tasks") continue;
@@ -480,6 +558,10 @@ async function initializeAgentLoop(options) {
     await readTemplate("root/AGENTLOOP.md", values),
     result
   );
+  if (options.localOnly) {
+    await upsertLocalOnlyNotice(path6.join(cwd, AGENTS_FILE), result);
+    await upsertLocalOnlyNotice(path6.join(cwd, AGENTLOOP_FILE), result);
+  }
   const configPath = path6.join(cwd, CONFIG_FILE);
   if (await pathExists(configPath)) {
     result.skipped.push(configPath);
@@ -502,29 +584,43 @@ var consoleLogger = {
 
 // src/cli/commands/init.ts
 function initCommand() {
-  return new Command("init").description("Initialize AgentLoopKit in the current repository").option("--dry-run", "show planned changes without writing files").option("--json", "print machine-readable output").option("--force", "allow initialization when the current directory is your home directory").action(async (options) => {
-    const result = await initializeAgentLoop({
-      cwd: process.cwd(),
-      dryRun: options.dryRun,
-      force: options.force
-    });
-    if (options.json) {
-      consoleLogger.info(JSON.stringify(result, null, 2));
-      return;
-    }
-    consoleLogger.info(
-      options.dryRun ? "AgentLoopKit init dry run complete." : "AgentLoopKit initialized."
-    );
-    consoleLogger.info(`Created: ${result.created.length}`);
-    consoleLogger.info(`Updated: ${result.updated.length}`);
-    consoleLogger.info(`Skipped: ${result.skipped.length}`);
-    if (!options.dryRun) {
-      consoleLogger.info("\nNext steps:");
-      consoleLogger.info("- Review AGENTS.md and AGENTLOOP.md");
-      consoleLogger.info("- Run agentloop doctor");
-      consoleLogger.info("- Create a task with agentloop create-task");
+  return new Command("init").description("Initialize AgentLoopKit in the current repository").option("--dry-run", "show planned changes without writing files").option("--json", "print machine-readable output").option("--force", "allow initialization when the current directory is your home directory").option(
+    "--local-only",
+    "keep generated AgentLoopKit files out of git by updating this repo clone .git/info/exclude"
+  ).action(
+    async (options) => {
+      const result = await initializeAgentLoop({
+        cwd: process.cwd(),
+        dryRun: options.dryRun,
+        force: options.force,
+        localOnly: options.localOnly
+      });
+      if (options.json) {
+        consoleLogger.info(JSON.stringify(result, null, 2));
+        return;
+      }
+      consoleLogger.info(
+        options.dryRun ? "AgentLoopKit init dry run complete." : "AgentLoopKit initialized."
+      );
+      consoleLogger.info(`Created: ${result.created.length}`);
+      consoleLogger.info(`Updated: ${result.updated.length}`);
+      consoleLogger.info(`Skipped: ${result.skipped.length}`);
+      if (result.localOnly) {
+        consoleLogger.info("\nLocal-only mode:");
+        consoleLogger.info(`- Updated exclude file: ${result.localOnly.excludePath}`);
+        consoleLogger.info(
+          "- AgentLoopKit files stay on disk for local agents but stay out of git status."
+        );
+        consoleLogger.info("- Undo: remove the agentloopkit:local-only block from .git/info/exclude.");
+      }
+      if (!options.dryRun) {
+        consoleLogger.info("\nNext steps:");
+        consoleLogger.info("- Review AGENTS.md and AGENTLOOP.md");
+        consoleLogger.info("- Run agentloop doctor");
+        consoleLogger.info("- Create a task with agentloop create-task");
+      }
     }
-  });
+  );
 }
 
 // src/cli/commands/doctor.ts
@@ -1268,7 +1364,7 @@ import { readFile as readFile8 } from "fs/promises";
 
 // src/core/artifacts.ts
 import path11 from "path";
-import { readdir as readdir4, stat as stat2 } from "fs/promises";
+import { readdir as readdir4, stat as stat3 } from "fs/promises";
 var verificationReportPattern = /^\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-verification-report\.md$/;
 var prSummaryPattern = /^\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-pr-summary\.md$/;
 var ciSummaryPattern = /^\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-ci-summary\.md$/;
@@ -1279,7 +1375,7 @@ async function latestMarkdownFile(dir, options = {}) {
       (entry) => entry.isFile() && entry.name.endsWith(".md") && entry.name.toLowerCase() !== "readme.md"
     ).filter((entry) => !options.pattern || options.pattern.test(entry.name)).map(async (entry) => {
       const filePath = path11.join(dir, entry.name);
-      const fileStat = await stat2(filePath);
+      const fileStat = await stat3(filePath);
       return { filePath, name: entry.name, mtimeMs: fileStat.mtimeMs };
     })
   );
@@ -1292,7 +1388,7 @@ async function latestMarkdownFile(dir, options = {}) {
 
 // src/core/task-state.ts
 import path12 from "path";
-import { mkdir as mkdir2, readdir as readdir5, readFile as readFile7, rename, rm, stat as stat3 } from "fs/promises";
+import { mkdir as mkdir2, readdir as readdir5, readFile as readFile7, rename, rm, stat as stat4 } from "fs/promises";
 var TASK_STATUSES = ["proposed", "in-progress", "blocked", "review", "done"];
 function statePath(cwd, config) {
   return path12.join(cwd, config.paths.agentloopDir, "state.json");
@@ -1337,7 +1433,7 @@ async function resolveTaskPath(options) {
     if (!options.strict) return void 0;
     throw new AgentLoopError("Active task must be a Markdown file.");
   }
-  const fileStat = await stat3(absolutePath).catch(() => void 0);
+  const fileStat = await stat4(absolutePath).catch(() => void 0);
   if (!fileStat?.isFile()) {
     if (!options.strict) return void 0;
     throw new AgentLoopError(`Task contract not found: ${options.taskPath}`);
@@ -1444,7 +1540,7 @@ async function listTasks(options) {
       const filePath = path12.join(root, entry.name);
       const [metadata, fileStat] = await Promise.all([
         readTaskMetadata(options.cwd, filePath),
-        stat3(filePath)
+        stat4(filePath)
       ]);
       return {
         ...metadata,
@@ -1776,7 +1872,7 @@ import { Command as Command9 } from "commander";
 
 // src/core/status.ts
 import path15 from "path";
-import { readFile as readFile9, stat as stat4 } from "fs/promises";
+import { readFile as readFile9, stat as stat5 } from "fs/promises";
 function extractHeading2(markdown, fallback) {
   return markdown.match(/^#\s+(.+)$/m)?.[1]?.trim() || fallback;
 }
@@ -1789,7 +1885,7 @@ function extractOverallStatus(markdown) {
 async function readTask(cwd, filePath) {
   if (!filePath) return void 0;
   const markdown = await readFile9(filePath, "utf8");
-  const fileStat = await stat4(filePath);
+  const fileStat = await stat5(filePath);
   return {
     path: path15.relative(cwd, filePath),
     title: extractHeading2(markdown, path15.basename(filePath, ".md")),
@@ -1800,7 +1896,7 @@ async function readTask(cwd, filePath) {
 async function readReport(cwd, filePath) {
   if (!filePath) return void 0;
   const markdown = await readFile9(filePath, "utf8");
-  const fileStat = await stat4(filePath);
+  const fileStat = await stat5(filePath);
   return {
     path: path15.relative(cwd, filePath),
     title: extractHeading2(markdown, path15.basename(filePath, ".md")),
@@ -2114,6 +2210,7 @@ var topLevelCommands = [
   ["ci-summary", "Summarize CI context and AgentLoop evidence"],
   ["release-notes", "Generate deterministic release notes"],
   ["npm-status", "Check npm registry catch-up status"],
+  ["mcp-server", "Start the read-only MCP stdio server"],
   ["policy", "List or inspect local AgentLoopKit policies"],
   ["task", "List, inspect, update, or archive task contracts"],
   ["install-agent", "Install agent-specific instructions"],
@@ -2566,7 +2663,7 @@ import { Command as Command14 } from "commander";
 
 // src/core/html-report.ts
 import path17 from "path";
-import { readFile as readFile11, readdir as readdir6, stat as stat5 } from "fs/promises";
+import { readFile as readFile11, readdir as readdir6, stat as stat6 } from "fs/promises";
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
@@ -2598,7 +2695,7 @@ async function latestMatchingMarkdownFile(dir, pattern) {
   const entries = await Promise.all(
     (await readdir6(dir, { withFileTypes: true })).filter((entry) => entry.isFile() && pattern.test(entry.name)).map(async (entry) => {
       const filePath = path17.join(dir, entry.name);
-      const fileStat = await stat5(filePath);
+      const fileStat = await stat6(filePath);
       return { filePath, name: entry.name, mtimeMs: fileStat.mtimeMs };
     })
   );
@@ -2827,7 +2924,7 @@ import { Command as Command15 } from "commander";
 
 // src/core/badge.ts
 import path18 from "path";
-import { readFile as readFile12, readdir as readdir7, stat as stat6 } from "fs/promises";
+import { readFile as readFile12, readdir as readdir7, stat as stat7 } from "fs/promises";
 var verificationReportPattern2 = /^\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-verification-report\.md$/;
 function escapeXml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
@@ -2858,7 +2955,7 @@ async function latestVerificationReport(dir) {
   const entries = await Promise.all(
     (await readdir7(dir, { withFileTypes: true })).filter((entry) => entry.isFile() && verificationReportPattern2.test(entry.name)).map(async (entry) => {
       const filePath = path18.join(dir, entry.name);
-      const fileStat = await stat6(filePath);
+      const fileStat = await stat7(filePath);
       return { filePath, name: entry.name, mtimeMs: fileStat.mtimeMs };
     })
   );
@@ -2996,7 +3093,7 @@ import { Command as Command16 } from "commander";
 
 // src/core/policy.ts
 import path19 from "path";
-import { readdir as readdir8, readFile as readFile13, stat as stat7 } from "fs/promises";
+import { readdir as readdir8, readFile as readFile13, stat as stat8 } from "fs/promises";
 function policyRoot(cwd, config) {
   return path19.resolve(cwd, config.paths.agentloopDir, "policies");
 }
@@ -3013,7 +3110,7 @@ function normalizeContent(content) {
   return content.replace(/\r\n/g, "\n");
 }
 async function ensurePolicyRoot(root) {
-  const rootStat = await stat7(root).catch(() => void 0);
+  const rootStat = await stat8(root).catch(() => void 0);
   if (!rootStat?.isDirectory()) {
     throw new AgentLoopError(
       "No AgentLoopKit policy files found. Run `agentloop init` to generate .agentloop/policies/."
@@ -3806,8 +3903,261 @@ function npmStatusCommand() {
   );
 }
 
+// src/cli/commands/mcp-server.ts
+import { Command as Command20 } from "commander";
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/core/mcp-tools.ts
+import path23 from "path";
+import { readdir as readdir9, readFile as readFile18, stat as stat9 } from "fs/promises";
+var emptyInputSchema = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var tools = [
+  {
+    name: "agentloop_status",
+    description: "Read AgentLoopKit status, active task, latest verification, git state, and next action.",
+    inputSchema: emptyInputSchema
+  },
+  {
+    name: "agentloop_next",
+    description: "Read only the next recommended AgentLoopKit action and reason.",
+    inputSchema: emptyInputSchema
+  },
+  {
+    name: "agentloop_list_tasks",
+    description: "List local task contracts under the configured AgentLoopKit task directory.",
+    inputSchema: emptyInputSchema
+  },
+  {
+    name: "agentloop_show_active_task",
+    description: "Read the active task contract content when one is pinned.",
+    inputSchema: emptyInputSchema
+  },
+  {
+    name: "agentloop_list_policies",
+    description: "List local AgentLoopKit safety policy files.",
+    inputSchema: emptyInputSchema
+  },
+  {
+    name: "agentloop_read_policy",
+    description: "Read one local AgentLoopKit policy by policy name.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        policyName: {
+          type: "string",
+          description: 'Policy name, for example "security" or "security-policy.md".'
+        }
+      },
+      required: ["policyName"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "agentloop_latest_verification_report",
+    description: "Read the latest local verification report metadata and Markdown content.",
+    inputSchema: emptyInputSchema
+  },
+  {
+    name: "agentloop_list_handoffs",
+    description: "List recent local reviewer handoff summaries.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          minimum: 1,
+          maximum: 50,
+          description: "Maximum handoff summaries to return. Defaults to 20."
+        }
+      },
+      additionalProperties: false
+    }
+  },
+  {
+    name: "agentloop_latest_handoff",
+    description: "Read the latest local reviewer handoff summary Markdown content.",
+    inputSchema: emptyInputSchema
+  }
+];
+function listMcpTools() {
+  return [...tools];
+}
+function textResult(payload) {
+  return {
+    payload,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload, null, 2)
+      }
+    ]
+  };
+}
+function extractHeading7(markdown, fallback) {
+  return markdown.match(/^#\s+(.+)$/m)?.[1]?.trim() || fallback;
+}
+function toStoredPath3(cwd, absolutePath) {
+  return path23.relative(cwd, absolutePath).split(path23.sep).join("/");
+}
+async function readMarkdownArtifact(cwd, filePath, key) {
+  if (!filePath) return { [key]: null };
+  const content = await readFile18(filePath, "utf8");
+  const fileStat = await stat9(filePath);
+  return {
+    [key]: {
+      path: toStoredPath3(cwd, filePath),
+      title: extractHeading7(content, path23.basename(filePath, ".md")),
+      modifiedAt: fileStat.mtime.toISOString(),
+      content
+    }
+  };
+}
+async function listHandoffs(cwd, handoffsDir, limit) {
+  if (!await pathExists(handoffsDir)) return [];
+  const entries = await readdir9(handoffsDir, { withFileTypes: true });
+  const handoffs = await Promise.all(
+    entries.filter((entry) => entry.isFile() && prSummaryPattern.test(entry.name)).map(async (entry) => {
+      const filePath = path23.join(handoffsDir, entry.name);
+      const [content, fileStat] = await Promise.all([readFile18(filePath, "utf8"), stat9(filePath)]);
+      return {
+        path: toStoredPath3(cwd, filePath),
+        title: extractHeading7(content, path23.basename(filePath, ".md")),
+        modifiedAt: fileStat.mtime.toISOString(),
+        modifiedMs: fileStat.mtimeMs
+      };
+    })
+  );
+  return handoffs.sort((left, right) => {
+    if (left.modifiedMs !== right.modifiedMs) return right.modifiedMs - left.modifiedMs;
+    return left.path.localeCompare(right.path);
+  }).slice(0, limit).map((handoff) => ({
+    path: handoff.path,
+    title: handoff.title,
+    modifiedAt: handoff.modifiedAt
+  }));
+}
+function readStringArgument(args, key) {
+  const value = args?.[key];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new AgentLoopError(`MCP tool argument "${key}" must be a non-empty string.`);
+  }
+  return value;
+}
+function readLimitArgument(args) {
+  const value = args?.limit;
+  if (value === void 0) return 20;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 50) {
+    throw new AgentLoopError('MCP tool argument "limit" must be an integer from 1 to 50.');
+  }
+  return value;
+}
+async function callMcpTool(options) {
+  const config = await loadAgentLoopConfig(options.cwd);
+  switch (options.name) {
+    case "agentloop_status": {
+      const status = await getAgentLoopStatus({ cwd: options.cwd, config });
+      return textResult(status);
+    }
+    case "agentloop_next": {
+      const status = await getAgentLoopStatus({ cwd: options.cwd, config });
+      return textResult(status.nextAction);
+    }
+    case "agentloop_list_tasks": {
+      return textResult({ tasks: await listTasks({ cwd: options.cwd, config }) });
+    }
+    case "agentloop_show_active_task": {
+      const activeTask = await getActiveTask({ cwd: options.cwd, config });
+      if (!activeTask) return textResult({ task: null });
+      const task = await readTaskContract({ cwd: options.cwd, config, taskPath: activeTask.path });
+      return textResult({ task });
+    }
+    case "agentloop_list_policies": {
+      return textResult({ policies: await listPolicies({ cwd: options.cwd, config }) });
+    }
+    case "agentloop_read_policy": {
+      const policyName = readStringArgument(options.arguments, "policyName");
+      return textResult({
+        policy: await readPolicy({ cwd: options.cwd, config, policyName })
+      });
+    }
+    case "agentloop_latest_verification_report": {
+      const reportPath = await latestMarkdownFile(
+        path23.join(options.cwd, config.paths.reportsDir),
+        {
+          pattern: verificationReportPattern
+        }
+      );
+      return textResult(await readMarkdownArtifact(options.cwd, reportPath, "report"));
+    }
+    case "agentloop_list_handoffs": {
+      const limit = readLimitArgument(options.arguments);
+      return textResult({
+        handoffs: await listHandoffs(
+          options.cwd,
+          path23.join(options.cwd, config.paths.handoffsDir),
+          limit
+        )
+      });
+    }
+    case "agentloop_latest_handoff": {
+      const handoffPath = await latestMarkdownFile(
+        path23.join(options.cwd, config.paths.handoffsDir),
+        {
+          pattern: prSummaryPattern
+        }
+      );
+      return textResult(await readMarkdownArtifact(options.cwd, handoffPath, "handoff"));
+    }
+    default:
+      throw new AgentLoopError(`Unknown MCP tool: ${options.name}`);
+  }
+}
+
+// src/mcp/server.ts
+async function startAgentLoopMcpServer(options) {
+  const server = new Server(
+    {
+      name: "agentloopkit",
+      version: getPackageVersion()
+    },
+    {
+      capabilities: {
+        tools: {}
+      },
+      instructions: "Read-only AgentLoopKit server. Exposes local task contracts, policies, verification reports, handoffs, status, and next action. It does not run verification commands, read env file contents, call external APIs, upload files, or mutate repository files."
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: listMcpTools()
+  }));
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    async (request) => callMcpTool({
+      cwd: options.cwd,
+      name: request.params.name,
+      arguments: request.params.arguments
+    })
+  );
+  await server.connect(new StdioServerTransport());
+}
+
+// src/cli/commands/mcp-server.ts
+function mcpServerCommand() {
+  return new Command20("mcp-server").description("Start the read-only AgentLoopKit MCP stdio server").action(async () => {
+    await startAgentLoopMcpServer({ cwd: process.cwd() });
+  });
+}
+
 // src/cli/index.ts
-var program = new Command20();
+var program = new Command21();
 program.name("agentloop").description("A drop-in engineering loop for coding agents.").version(getPackageVersion(), "-V, --version", "print CLI version");
 program.addCommand(initCommand());
 program.addCommand(doctorCommand());
@@ -3823,6 +4173,7 @@ program.addCommand(badgeCommand());
 program.addCommand(ciSummaryCommand());
 program.addCommand(releaseNotesCommand());
 program.addCommand(npmStatusCommand());
+program.addCommand(mcpServerCommand());
 program.addCommand(policyCommand());
 program.addCommand(taskCommand());
 program.addCommand(installAgentCommand());