forgeos 0.1.0-alpha.11 → 0.1.0-alpha.13

package/src/forge/_generated/workflowSubscriptions.ts

@@ -1,10 +1,10 @@
-// @forge-generated generator=0.1.0-alpha.11 input=dc56d0c4319efa7c4d9ba9f2661ff05cb9fb78e956666f8032cc01e4aca54367 content=0d90054a74861bf8bf26347fb3d3d14bec08e01ff61448b10e59913f7af59e00
+// @forge-generated generator=0.1.0-alpha.13 input=3f5e1915da753f2190d1baa076ce591a66915ab697552bf8768f4c1c6850b945 content=3075b08b0bccea60cfe02bc8deb3f71af9aefa8e465b29999a279112bcec5353
 export const workflowSubscriptions = {
   "analyzerVersion": "0.1.0",
   "byEvent": {},
   "diagnostics": [],
-  "generatorVersion": "0.1.0-alpha.11",
-  "inputHash": "1d0974042a10eac0028a9fc38a69cc23306b3eac069f6f04aa497723ad4634a5",
+  "generatorVersion": "0.1.0-alpha.13",
+  "inputHash": "06bfbcbe27d8a631e77cfc206b83997252aa45b78fdcc90a8b9136f1bd8e6e47",
   "schemaVersion": "0.1.0",
   "subscriptions": []
 } as const;

package/src/forge/agent-adapters/index.ts

@@ -32,6 +32,12 @@ import type {
   CustomAdapterConfig,
   AgentCheckResult,
 } from "./types.ts";
+import {
+  formatAgentMemoryHuman,
+  formatAgentMemoryJson,
+  runAgentMemoryCommand,
+  type AgentMemoryCommandResult,
+} from "../agent-memory/bridge.ts";
 
 export const AGENT_ADAPTER_VERSION = "agent-adapter-0.1.0";
 export const AGENT_FORMAT_VERSION = "2026-06";
@@ -945,7 +951,7 @@ export function runAgentDoctor(options: AgentCommandOptions): AgentDoctorResult
 }
 
 export async function runAgentCommand(options: AgentCommandOptions): Promise<
-  AgentExportResult | AgentCheckResult | AgentTargetsResult | AgentPrintContextResult | AgentDoctorResult
+  AgentExportResult | AgentCheckResult | AgentTargetsResult | AgentPrintContextResult | AgentDoctorResult | AgentMemoryCommandResult
 > {
   if (options.subcommand === "list-targets") {
     return runAgentListTargets(options.workspaceRoot);
@@ -965,6 +971,27 @@ export async function runAgentCommand(options: AgentCommandOptions): Promise<
   if (options.subcommand === "clean") {
     return runAgentClean(options);
   }
+  if (
+    options.subcommand === "install" ||
+    options.subcommand === "ingest" ||
+    options.subcommand === "context" ||
+    options.subcommand === "memory"
+  ) {
+    return runAgentMemoryCommand({
+      subcommand: options.subcommand,
+      workspaceRoot: options.workspaceRoot,
+      json: options.json,
+      target: options.target,
+      source: options.target,
+      eventName: options.eventName,
+      input: options.input,
+      entry: options.entry,
+      current: options.current,
+      dryRun: options.dryRun,
+      force: options.force,
+      limit: options.limit,
+    });
+  }
   return {
     ok: false,
     target: options.target,
@@ -979,10 +1006,16 @@ export async function runAgentCommand(options: AgentCommandOptions): Promise<
 }
 
 export function formatAgentJson(result: Awaited<ReturnType<typeof runAgentCommand>>): string {
+  if ("privacy" in result || "event" in result || "agentMemory" in result || "events" in result) {
+    return formatAgentMemoryJson(result as AgentMemoryCommandResult);
+  }
   return `${JSON.stringify(result, null, 2)}\n`;
 }
 
 export function formatAgentHuman(result: Awaited<ReturnType<typeof runAgentCommand>>): string {
+  if ("privacy" in result || "event" in result || "agentMemory" in result || "events" in result) {
+    return formatAgentMemoryHuman(result as AgentMemoryCommandResult);
+  }
   if ("targets" in result) {
     return `${result.targets.map((target) => `${target.name}${target.default ? " (default)" : ""}${target.optional ? " (optional)" : ""}${target.custom ? " (custom)" : ""}`).join("\n")}\n`;
   }
@@ -998,5 +1031,6 @@ export function formatAgentHuman(result: Awaited<ReturnType<typeof runAgentComma
     }
     return `agent adapter exports are stale\nmissing: ${result.missing.join(", ") || "none"}\nstale: ${result.stale.join(", ") || "none"}\n`;
   }
-  return `agent export ${result.ok ? "ok" : "failed"} for ${result.target}\nfiles written:\n${result.filesWritten.map((file) => `- ${file}`).join("\n") || "- none"}\n`;
+  const exportResult = result as AgentExportResult;
+  return `agent export ${exportResult.ok ? "ok" : "failed"} for ${exportResult.target}\nfiles written:\n${exportResult.filesWritten.map((file: string) => `- ${file}`).join("\n") || "- none"}\n`;
 }

package/src/forge/agent-adapters/types.ts

@@ -10,7 +10,11 @@ export type AgentSubcommand =
   | "check"
   | "doctor"
   | "print-context"
-  | "clean";
+  | "clean"
+  | "install"
+  | "ingest"
+  | "context"
+  | "memory";
 
 export interface AgentCommandOptions {
   subcommand: AgentSubcommand;
@@ -22,6 +26,11 @@ export interface AgentCommandOptions {
   preserveUserSections: boolean;
   skills: boolean;
   rules: boolean;
+  eventName?: string;
+  input?: unknown;
+  entry?: string;
+  current?: boolean;
+  limit?: number;
 }
 
 export interface AgentExportFile {

package/src/forge/agent-memory/bridge.ts

@@ -0,0 +1,228 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { DeltaStore } from "../delta/store.ts";
+import { extractAgentEventBindings, normalizeAgentEvent, summarizeAgentEvent } from "./normalize.ts";
+import { buildAgentMemoryContext } from "./context-pack.ts";
+import { claudeCodeInstallFiles, claudeCodeInstallResult } from "./sources/claude-code.ts";
+import { codexInstallFiles, codexInstallResult, privacyDefaults } from "./sources/codex.ts";
+import { cursorInstallFiles, cursorInstallResult } from "./sources/cursor.ts";
+import type {
+  AgentEventEnvelope,
+  AgentIngestResult,
+  AgentInstallResult,
+  AgentMemoryContextPack,
+  AgentMemoryEventRecord,
+  AgentMemorySourceName,
+} from "./types.ts";
+
+export interface AgentMemoryCommandOptions {
+  subcommand: "install" | "ingest" | "context" | "memory";
+  workspaceRoot: string;
+  json: boolean;
+  target?: string;
+  source?: string;
+  eventName?: string;
+  input?: unknown;
+  entry?: string;
+  current?: boolean;
+  dryRun?: boolean;
+  force?: boolean;
+  limit?: number;
+}
+
+export type AgentMemoryCommandResult =
+  | AgentInstallResult
+  | AgentIngestResult
+  | AgentMemoryContextPack
+  | { ok: true; events: AgentMemoryEventRecord[]; exitCode: 0 };
+
+export async function runAgentMemoryCommand(options: AgentMemoryCommandOptions): Promise<AgentMemoryCommandResult> {
+  if (options.subcommand === "install") {
+    return installAgentMemory(options);
+  }
+  if (options.subcommand === "ingest") {
+    return ingestAgentMemory(options);
+  }
+  if (options.subcommand === "context") {
+    return buildAgentMemoryContext({
+      workspaceRoot: options.workspaceRoot,
+      entry: options.entry,
+      limit: options.limit,
+    });
+  }
+  const store = await DeltaStore.open(options.workspaceRoot);
+  try {
+    return {
+      ok: true,
+      events: await store.listAgentMemoryEvents({ target: options.entry, limit: options.limit }),
+      exitCode: 0,
+    };
+  } finally {
+    await store.close();
+  }
+}
+
+export async function ingestEnvelope(workspaceRoot: string, envelope: AgentEventEnvelope): Promise<AgentIngestResult> {
+  const store = await DeltaStore.open(workspaceRoot);
+  try {
+    const bindings = extractAgentEventBindings(envelope);
+    const summary = summarizeAgentEvent(envelope);
+    const event = await store.recordAgentMemoryEvent({ envelope, summary, bindings });
+    return { ok: true, event, envelope, exitCode: 0 };
+  } finally {
+    await store.close();
+  }
+}
+
+async function ingestAgentMemory(options: AgentMemoryCommandOptions): Promise<AgentIngestResult> {
+  const source = options.source ?? options.target ?? "generic";
+  const raw = normalizeRawInput(options.input ?? await readStdinJson());
+  if (!raw) {
+    return { ok: false, exitCode: 1, error: "agent ingest requires JSON input on stdin or --input" };
+  }
+  const envelope = normalizeAgentEvent({
+    workspaceRoot: options.workspaceRoot,
+    source,
+    eventName: options.eventName,
+    raw,
+    integration: source === "cursor" ? "mcp" : "native-hook",
+  });
+  return ingestEnvelope(options.workspaceRoot, envelope);
+}
+
+function installAgentMemory(options: AgentMemoryCommandOptions): AgentInstallResult {
+  const target = normalizeInstallTarget(options.target ?? options.source ?? "generic");
+  const files =
+    target === "codex"
+      ? codexInstallFiles()
+      : target === "claude-code"
+        ? claudeCodeInstallFiles()
+        : target === "cursor"
+          ? cursorInstallFiles()
+          : [];
+  if (files.length === 0) {
+    return {
+      ok: false,
+      target,
+      filesWritten: [],
+      filesPlanned: [],
+      privacy: privacyDefaults(),
+      warnings: [`unknown agent memory install target: ${target}`],
+      exitCode: 1,
+    };
+  }
+  const filesWritten: string[] = [];
+  for (const file of files) {
+    const absolute = join(options.workspaceRoot, file.path);
+    const content = maybeMergeJson(absolute, file.content);
+    if (options.dryRun) {
+      continue;
+    }
+    if (!options.force && existsSync(absolute) && readFileSync(absolute, "utf8") === content) {
+      continue;
+    }
+    mkdirSync(dirname(absolute), { recursive: true });
+    writeFileSync(absolute, content);
+    filesWritten.push(file.path);
+  }
+  const planned = files.map((file) => file.path);
+  if (target === "codex") {
+    return codexInstallResult(filesWritten, planned);
+  }
+  if (target === "claude-code") {
+    return claudeCodeInstallResult(filesWritten, planned);
+  }
+  return cursorInstallResult(filesWritten, planned);
+}
+
+export function formatAgentMemoryJson(result: AgentMemoryCommandResult): string {
+  return `${JSON.stringify(result, null, 2)}\n`;
+}
+
+export function formatAgentMemoryHuman(result: AgentMemoryCommandResult): string {
+  if ("event" in result || "envelope" in result) {
+    return result.ok
+      ? `agent memory ingested: ${result.event?.normalizedKind ?? "event"}\n`
+      : `agent memory ingest failed: ${result.error ?? "unknown error"}\n`;
+  }
+  if ("filesPlanned" in result) {
+    return [
+      `Forge Agent Memory Bridge ${result.ok ? "installed" : "failed"} for ${result.target}.`,
+      "files written:",
+      ...(result.filesWritten.length > 0 ? result.filesWritten.map((file) => `- ${file}`) : ["- none"]),
+      "privacy:",
+      "- raw prompts: off",
+      "- raw completions: off",
+      "- raw tool args: off",
+      "- transcript import: off",
+    ].join("\n") + "\n";
+  }
+  if ("agentMemory" in result) {
+    return `${JSON.stringify(result, null, 2)}\n`;
+  }
+  const events = "events" in result ? result.events : [];
+  return `${JSON.stringify(events, null, 2)}\n`;
+}
+
+function normalizeInstallTarget(target: string): AgentMemorySourceName | string {
+  if (target === "claude") {
+    return "claude-code";
+  }
+  return target;
+}
+
+function normalizeRawInput(input: unknown): Record<string, unknown> | null {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    return input as Record<string, unknown>;
+  }
+  if (typeof input === "string" && input.trim()) {
+    try {
+      const parsed = JSON.parse(input) as unknown;
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+async function readStdinJson(): Promise<unknown> {
+  if (process.stdin.isTTY) {
+    return undefined;
+  }
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  return raw ? raw : undefined;
+}
+
+function maybeMergeJson(path: string, generated: string): string {
+  if (!existsSync(path) || !path.endsWith(".json")) {
+    return generated;
+  }
+  try {
+    const current = JSON.parse(readFileSync(path, "utf8")) as unknown;
+    const next = JSON.parse(generated) as unknown;
+    if (!current || typeof current !== "object" || Array.isArray(current) || !next || typeof next !== "object" || Array.isArray(next)) {
+      return generated;
+    }
+    return `${JSON.stringify(deepMerge(current as Record<string, unknown>, next as Record<string, unknown>), null, 2)}\n`;
+  } catch {
+    return generated;
+  }
+}
+
+function deepMerge(left: Record<string, unknown>, right: Record<string, unknown>): Record<string, unknown> {
+  const output: Record<string, unknown> = { ...left };
+  for (const [key, value] of Object.entries(right)) {
+    const existing = output[key];
+    output[key] =
+      existing && typeof existing === "object" && !Array.isArray(existing) &&
+      value && typeof value === "object" && !Array.isArray(value)
+        ? deepMerge(existing as Record<string, unknown>, value as Record<string, unknown>)
+        : value;
+  }
+  return output;
+}

package/src/forge/agent-memory/context-pack.ts

@@ -0,0 +1,104 @@
+import { DeltaStore } from "../delta/store.ts";
+import type { AgentMemoryContextPack, AgentMemoryEventRecord } from "./types.ts";
+
+export async function buildAgentMemoryContext(input: {
+  workspaceRoot: string;
+  entry?: string;
+  limit?: number;
+}): Promise<AgentMemoryContextPack> {
+  const store = await DeltaStore.open(input.workspaceRoot);
+  try {
+    const target = input.entry;
+    const events = await store.listAgentMemoryEvents({ target, limit: input.limit ?? 50 });
+    const timeline = target ? await store.semanticTimeline({ target, limit: input.limit ?? 50 }) : undefined;
+    const current = target ? timeline?.currentState ?? {} : await currentSessionState(store);
+    return {
+      ok: true,
+      scope: target ? "entry" : "current",
+      entry: target,
+      currentState: current,
+      agentMemory: {
+        goals: events
+          .filter((event) => event.normalizedKind === "agent.prompt.submitted")
+          .map((event) => ({
+            source: event.sourceName,
+            summary: event.summary ?? "Prompt submitted",
+            confidence: event.confidence,
+          })),
+        toolCalls: toolCalls(events),
+        files: uniqueStrings(events.flatMap((event) => bindings(event).files)),
+        entries: uniqueStrings(events.flatMap((event) => bindings(event).entries)),
+        approvals: events
+          .filter((event) => event.normalizedKind.startsWith("approval."))
+          .map((event) => ({
+            source: event.sourceName,
+            status: event.normalizedKind.replace(/^approval\./, ""),
+            summary: event.summary,
+          })),
+        proofs: uniqueStrings(events.flatMap((event) => bindings(event).proofs))
+          .map((kind) => ({ kind })),
+        events,
+        openQuestions: timeline?.openQuestions ?? [],
+      },
+      exitCode: 0,
+    };
+  } finally {
+    await store.close();
+  }
+}
+
+async function currentSessionState(store: DeltaStore): Promise<Record<string, unknown>> {
+  const session = await store.currentWorkSession();
+  return session
+    ? {
+        sessionId: session.id,
+        title: session.title,
+        inferredIntent: session.inferredIntent,
+        confidence: session.confidence,
+        status: session.status,
+      }
+    : {};
+}
+
+function toolCalls(events: AgentMemoryEventRecord[]): AgentMemoryContextPack["agentMemory"]["toolCalls"] {
+  return events
+    .filter((event) => event.normalizedKind.startsWith("agent.tool"))
+    .map((event) => {
+      const eventBindings = bindings(event);
+      return {
+        source: event.sourceName,
+        tool: eventBindings.toolName ?? "unknown",
+        status: eventBindings.status,
+        summary: event.summary,
+      };
+    });
+}
+
+function bindings(event: AgentMemoryEventRecord): {
+  toolName?: string;
+  status?: string;
+  files: string[];
+  entries: string[];
+  proofs: string[];
+} {
+  const raw = event.data.bindings;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { files: [], entries: [], proofs: [] };
+  }
+  const record = raw as Record<string, unknown>;
+  return {
+    toolName: typeof record.toolName === "string" ? record.toolName : undefined,
+    status: typeof record.status === "string" ? record.status : undefined,
+    files: arrayOfStrings(record.files),
+    entries: arrayOfStrings(record.entries),
+    proofs: arrayOfStrings(record.proofs),
+  };
+}
+
+function arrayOfStrings(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string" && item.length > 0) : [];
+}
+
+function uniqueStrings(values: string[]): string[] {
+  return [...new Set(values)].sort();
+}

package/src/forge/agent-memory/mcp.ts

@@ -0,0 +1,224 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DeltaStore } from "../delta/store.ts";
+import { buildAgentMemoryContext } from "./context-pack.ts";
+import { ingestEnvelope } from "./bridge.ts";
+import { normalizeAgentEvent } from "./normalize.ts";
+
+interface JsonRpcRequest {
+  jsonrpc?: "2.0";
+  id?: string | number | null;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+export async function handleMcpRequest(workspaceRoot: string, request: JsonRpcRequest): Promise<Record<string, unknown> | null> {
+  if (request.method.startsWith("notifications/")) {
+    return null;
+  }
+  try {
+    if (request.method === "initialize") {
+      return response(request.id, {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "forgeos-agent-memory", version: "0.1.0" },
+      });
+    }
+    if (request.method === "tools/list") {
+      return response(request.id, {
+        tools: [
+          {
+            name: "agent_context",
+            description: "Read the ForgeOS Agent Memory context pack for the current work or a runtime entry.",
+            inputSchema: {
+              type: "object",
+              properties: { entry: { type: "string" } },
+              additionalProperties: false,
+            },
+          },
+          {
+            name: "agent_memory",
+            description: "List recent redacted agent memory events.",
+            inputSchema: {
+              type: "object",
+              properties: { target: { type: "string" }, limit: { type: "number" } },
+              additionalProperties: false,
+            },
+          },
+          {
+            name: "timeline",
+            description: "Read the semantic timeline for an entry, file, policy, service, tool, or agent.",
+            inputSchema: {
+              type: "object",
+              properties: { target: { type: "string" }, limit: { type: "number" } },
+              required: ["target"],
+              additionalProperties: false,
+            },
+          },
+          {
+            name: "inspect_all",
+            description: "Read the generated ForgeOS machine contract artifacts that are safe for agents.",
+            inputSchema: {
+              type: "object",
+              properties: {},
+              additionalProperties: false,
+            },
+          },
+        ],
+      });
+    }
+    if (request.method === "tools/call") {
+      const params = request.params ?? {};
+      const name = typeof params.name === "string" ? params.name : "";
+      const args = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments)
+        ? params.arguments as Record<string, unknown>
+        : {};
+      const result = await runTool(workspaceRoot, name, args);
+      await logMcpToolCall(workspaceRoot, name, args, "completed");
+      return response(request.id, {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      });
+    }
+    return response(request.id, null, { code: -32601, message: `unknown MCP method: ${request.method}` });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return response(request.id, null, { code: -32000, message });
+  }
+}
+
+export async function runMcpServe(workspaceRoot: string): Promise<number> {
+  let buffer = "";
+  let sawFramedMessage = false;
+  for await (const chunk of process.stdin) {
+    buffer += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+    const parsed = parseMcpFrames(buffer);
+    buffer = parsed.remainder;
+    if (parsed.requests.length > 0) {
+      sawFramedMessage = true;
+    }
+    for (const request of parsed.requests) {
+      const result = await handleMcpRequest(workspaceRoot, request);
+      if (result) {
+        writeMcpMessage(result);
+      }
+    }
+  }
+  const leftover = buffer.trim();
+  if (!sawFramedMessage && leftover.startsWith("{")) {
+    const result = await handleMcpRequest(workspaceRoot, JSON.parse(leftover) as JsonRpcRequest);
+    if (result) {
+      writeMcpMessage(result);
+    }
+  }
+  return 0;
+}
+
+async function runTool(workspaceRoot: string, name: string, args: Record<string, unknown>): Promise<unknown> {
+  if (name === "agent_context") {
+    return buildAgentMemoryContext({
+      workspaceRoot,
+      entry: typeof args.entry === "string" ? args.entry : undefined,
+    });
+  }
+  if (name === "agent_memory") {
+    const store = await DeltaStore.open(workspaceRoot);
+    try {
+      return {
+        ok: true,
+        events: await store.listAgentMemoryEvents({
+          target: typeof args.target === "string" ? args.target : undefined,
+          limit: typeof args.limit === "number" ? args.limit : undefined,
+        }),
+      };
+    } finally {
+      await store.close();
+    }
+  }
+  if (name === "timeline") {
+    const target = typeof args.target === "string" ? args.target : undefined;
+    if (!target) {
+      throw new Error("timeline requires target");
+    }
+    const store = await DeltaStore.open(workspaceRoot);
+    try {
+      return {
+        ok: true,
+        timeline: await store.semanticTimeline({
+          target,
+          limit: typeof args.limit === "number" ? args.limit : undefined,
+        }),
+      };
+    } finally {
+      await store.close();
+    }
+  }
+  if (name === "inspect_all") {
+    return readInspectAll(workspaceRoot);
+  }
+  throw new Error(`unknown ForgeOS MCP tool: ${name}`);
+}
+
+async function logMcpToolCall(workspaceRoot: string, toolName: string, args: Record<string, unknown>, status: string): Promise<void> {
+  const envelope = normalizeAgentEvent({
+    workspaceRoot,
+    source: "generic",
+    integration: "mcp",
+    eventName: "tool.call",
+    raw: {
+      toolName,
+      args,
+      status,
+      timestamp: new Date().toISOString(),
+    },
+  });
+  await ingestEnvelope(workspaceRoot, envelope);
+}
+
+function readInspectAll(workspaceRoot: string): Record<string, unknown> {
+  const generated = join(workspaceRoot, "src", "forge", "_generated");
+  const read = (name: string) => {
+    try {
+      return JSON.parse(readFileSync(join(generated, name), "utf8")) as unknown;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    ok: true,
+    agentContract: read("agentContract.json"),
+    agentTools: read("agentTools.json"),
+    runtimeGraph: read("runtimeGraph.json"),
+    policyRegistry: read("policyRegistry.json"),
+  };
+}
+
+function response(id: JsonRpcRequest["id"], result: unknown, error?: Record<string, unknown>): Record<string, unknown> {
+  return error ? { jsonrpc: "2.0", id: id ?? null, error } : { jsonrpc: "2.0", id: id ?? null, result };
+}
+
+function parseMcpFrames(raw: string): { requests: JsonRpcRequest[]; remainder: string } {
+  const messages: JsonRpcRequest[] = [];
+  let cursor = 0;
+  while (cursor < raw.length) {
+    const headerEnd = raw.indexOf("\r\n\r\n", cursor);
+    if (headerEnd === -1) {
+      break;
+    }
+    const header = raw.slice(cursor, headerEnd);
+    const match = /Content-Length:\s*(\d+)/i.exec(header);
+    if (!match) {
+      break;
+    }
+    const length = Number(match[1]);
+    const bodyStart = headerEnd + 4;
+    const body = raw.slice(bodyStart, bodyStart + length);
+    messages.push(JSON.parse(body) as JsonRpcRequest);
+    cursor = bodyStart + length;
+  }
+  return { requests: messages, remainder: raw.slice(cursor) };
+}
+
+function writeMcpMessage(message: Record<string, unknown>): void {
+  const body = JSON.stringify(message);
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+}