@remixhq/mcp 0.1.2

package/dist/index.js

@@ -0,0 +1,1708 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/domain/apiClient.ts
+import { createApiClient as createCoreApiClient, resolveConfig as resolveConfig2 } from "@remixhq/core";
+
+// src/bootstrap/auth.ts
+import { createLocalSessionStore, createStoredSessionTokenProvider, createSupabaseAuthHelpers, resolveConfig } from "@remixhq/core";
+async function createRemixTokenProvider(config) {
+  const resolvedConfig = config ?? await resolveConfig();
+  const sessionStore = createLocalSessionStore();
+  return createStoredSessionTokenProvider({
+    config: resolvedConfig,
+    sessionStore,
+    refreshStoredSession: async ({ config: refreshConfig, session }) => {
+      const supabase = createSupabaseAuthHelpers(refreshConfig);
+      return supabase.refreshWithStoredSession({ session });
+    }
+  });
+}
+
+// src/domain/apiClient.ts
+async function createCollabApiClient() {
+  const config = await resolveConfig2();
+  const tokenProvider = await createRemixTokenProvider(config);
+  const api = createCoreApiClient(config, {
+    tokenProvider
+  });
+  return api;
+}
+async function createApiClient() {
+  const config = await resolveConfig2();
+  const tokenProvider = await createRemixTokenProvider(config);
+  return createCoreApiClient(config, {
+    tokenProvider
+  });
+}
+
+// src/observability/logger.ts
+function createLogger() {
+  return {
+    log(event) {
+      const payload = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...event
+      };
+      const line = JSON.stringify(payload);
+      if (event.level === "error") {
+        process.stderr.write(`${line}
+`);
+        return;
+      }
+      process.stderr.write(`${line}
+`);
+    }
+  };
+}
+
+// src/policy/policy.ts
+import path from "path";
+
+// src/errors/normalizeError.ts
+import { ZodError } from "zod";
+
+// src/errors/errorCodes.ts
+var ERROR_CODES = {
+  AUTH_REQUIRED: "AUTH_REQUIRED",
+  INVALID_INPUT: "INVALID_INPUT",
+  NOT_GIT_REPO: "NOT_GIT_REPO",
+  NOT_BOUND: "NOT_BOUND",
+  DIRTY_WORKTREE: "DIRTY_WORKTREE",
+  DETACHED_HEAD: "DETACHED_HEAD",
+  PREFERRED_BRANCH_MISMATCH: "PREFERRED_BRANCH_MISMATCH",
+  MISSING_HEAD: "MISSING_HEAD",
+  REPO_LOCK_HELD: "REPO_LOCK_HELD",
+  REPO_LOCK_TIMEOUT: "REPO_LOCK_TIMEOUT",
+  REPO_LOCK_STALE_RECOVERED: "REPO_LOCK_STALE_RECOVERED",
+  REPO_STATE_CHANGED_DURING_OPERATION: "REPO_STATE_CHANGED_DURING_OPERATION",
+  REMOTE_ERROR: "REMOTE_ERROR",
+  METADATA_CONFLICT: "METADATA_CONFLICT",
+  DESTRUCTIVE_OPERATION_BLOCKED: "DESTRUCTIVE_OPERATION_BLOCKED",
+  CONFIG_INVALID: "CONFIG_INVALID",
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
+var RemixMcpError = class extends Error {
+  normalized;
+  constructor(normalized) {
+    super(normalized.message);
+    this.name = "RemixMcpError";
+    this.normalized = normalized;
+  }
+};
+
+// src/errors/normalizeError.ts
+function toStringOrNull(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function makeNormalized(params) {
+  return {
+    code: params.code,
+    message: params.message,
+    hint: params.hint ?? null,
+    retryable: params.retryable ?? false,
+    category: params.category
+  };
+}
+function normalizeByMessage(err) {
+  const code = toStringOrNull(err.code);
+  const message = toStringOrNull(err.message) ?? "Unexpected error.";
+  const hint = toStringOrNull(err.hint);
+  if (code === ERROR_CODES.REPO_LOCK_HELD) {
+    return makeNormalized({
+      code: ERROR_CODES.REPO_LOCK_HELD,
+      message,
+      hint,
+      retryable: true,
+      category: "local_state"
+    });
+  }
+  if (code === ERROR_CODES.REPO_LOCK_TIMEOUT) {
+    return makeNormalized({
+      code: ERROR_CODES.REPO_LOCK_TIMEOUT,
+      message,
+      hint,
+      retryable: true,
+      category: "local_state"
+    });
+  }
+  if (code === ERROR_CODES.REPO_STATE_CHANGED_DURING_OPERATION) {
+    return makeNormalized({
+      code: ERROR_CODES.REPO_STATE_CHANGED_DURING_OPERATION,
+      message,
+      hint,
+      retryable: true,
+      category: "local_state"
+    });
+  }
+  if (code === ERROR_CODES.REPO_LOCK_STALE_RECOVERED) {
+    return makeNormalized({
+      code: ERROR_CODES.REPO_LOCK_STALE_RECOVERED,
+      message,
+      hint,
+      retryable: true,
+      category: "local_state"
+    });
+  }
+  if (message === "Not signed in.") {
+    return makeNormalized({
+      code: ERROR_CODES.AUTH_REQUIRED,
+      message,
+      hint,
+      category: "auth"
+    });
+  }
+  if (message === "Not inside a git repository.") {
+    return makeNormalized({
+      code: ERROR_CODES.NOT_GIT_REPO,
+      message,
+      hint,
+      category: "local_state"
+    });
+  }
+  if (message === "Repository is not bound to Remix.") {
+    return makeNormalized({
+      code: ERROR_CODES.NOT_BOUND,
+      message,
+      hint,
+      category: "local_state"
+    });
+  }
+  if (message.includes("Working tree must be clean")) {
+    return makeNormalized({
+      code: ERROR_CODES.DIRTY_WORKTREE,
+      message,
+      hint,
+      category: "local_state"
+    });
+  }
+  if (message.includes("requires a checked out local branch") || message.includes("detached HEAD")) {
+    return makeNormalized({
+      code: ERROR_CODES.DETACHED_HEAD,
+      message,
+      hint,
+      category: "local_state"
+    });
+  }
+  if (code === ERROR_CODES.PREFERRED_BRANCH_MISMATCH || message.includes("preferred branch")) {
+    return makeNormalized({
+      code: ERROR_CODES.PREFERRED_BRANCH_MISMATCH,
+      message,
+      hint,
+      category: "local_state"
+    });
+  }
+  if (message.includes("Failed to resolve local HEAD")) {
+    return makeNormalized({
+      code: ERROR_CODES.MISSING_HEAD,
+      message,
+      hint,
+      category: "local_state"
+    });
+  }
+  if (message.includes("metadata conflicts with the bound Remix app") || message.includes("manual intervention")) {
+    return makeNormalized({
+      code: ERROR_CODES.METADATA_CONFLICT,
+      message,
+      hint,
+      category: "remote_state"
+    });
+  }
+  if (message.includes("Timed out") || message.includes("failed") || message.includes("error state")) {
+    return makeNormalized({
+      code: ERROR_CODES.REMOTE_ERROR,
+      message,
+      hint,
+      retryable: true,
+      category: "remote_state"
+    });
+  }
+  return makeNormalized({
+    code: ERROR_CODES.INTERNAL_ERROR,
+    message,
+    hint,
+    retryable: true,
+    category: "internal"
+  });
+}
+function createPolicyError(message, hint) {
+  return new RemixMcpError(
+    makeNormalized({
+      code: ERROR_CODES.DESTRUCTIVE_OPERATION_BLOCKED,
+      message,
+      hint,
+      category: "policy"
+    })
+  );
+}
+function normalizeToolError(error) {
+  if (error instanceof RemixMcpError) {
+    return error.normalized;
+  }
+  if (error instanceof ZodError) {
+    return makeNormalized({
+      code: ERROR_CODES.INVALID_INPUT,
+      message: "Tool arguments failed validation.",
+      hint: error.issues.map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; "),
+      category: "validation"
+    });
+  }
+  if (error && typeof error === "object") {
+    return normalizeByMessage(error);
+  }
+  return makeNormalized({
+    code: ERROR_CODES.INTERNAL_ERROR,
+    message: typeof error === "string" && error.trim() ? error.trim() : "Unexpected error.",
+    hint: null,
+    retryable: true,
+    category: "internal"
+  });
+}
+
+// src/policy/policy.ts
+function parseBooleanEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const normalized = raw.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function parsePositiveIntEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function parseAllowedRoots(raw) {
+  if (!raw) return null;
+  const roots = raw.split(path.delimiter).map((entry) => entry.trim()).filter(Boolean).map((entry) => path.resolve(entry));
+  return roots.length > 0 ? roots : null;
+}
+function isWithinRoot(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function loadPolicy() {
+  return {
+    allowLocalWrite: parseBooleanEnv("COMERGE_MCP_ALLOW_LOCAL_WRITE", true),
+    allowRemoteWrite: parseBooleanEnv("COMERGE_MCP_ALLOW_REMOTE_WRITE", true),
+    allowedRepoRoots: parseAllowedRoots(process.env.COMERGE_MCP_ALLOWED_REPO_ROOTS),
+    maxDiffBytes: parsePositiveIntEnv("COMERGE_MCP_MAX_DIFF_BYTES", 1024 * 1024),
+    maxDiffOutputChars: parsePositiveIntEnv("COMERGE_MCP_MAX_DIFF_OUTPUT_CHARS", 2e4)
+  };
+}
+function resolvePolicyCwd(policy, cwd) {
+  const resolved = path.resolve(cwd?.trim() || process.cwd());
+  if (!policy.allowedRepoRoots) return resolved;
+  if (policy.allowedRepoRoots.some((root) => isWithinRoot(root, resolved))) return resolved;
+  throw createPolicyError("Requested working directory is outside the allowed repository roots.", resolved);
+}
+function assertToolAccess(policy, access) {
+  if (access === "read") return;
+  if (access === "remote_write" && !policy.allowRemoteWrite) {
+    throw createPolicyError("Remote-mutating Remix tools are disabled by policy.");
+  }
+  if (access === "local_write" && !policy.allowLocalWrite) {
+    throw createPolicyError("Local-mutating Remix tools are disabled by policy.");
+  }
+}
+function assertConfirm(confirm, operation) {
+  if (confirm) return;
+  throw createPolicyError(`${operation} requires explicit confirmation.`, "Pass confirm=true to run this tool.");
+}
+function assertDiffWithinLimit(policy, diff) {
+  const sizeBytes = Buffer.byteLength(diff, "utf8");
+  if (sizeBytes <= policy.maxDiffBytes) return;
+  throw createPolicyError(
+    "Diff exceeds the configured maximum size for Remix MCP.",
+    `Configured limit=${policy.maxDiffBytes} bytes actual=${sizeBytes} bytes.`
+  );
+}
+
+// src/bootstrap/context.ts
+function createServerContext(params) {
+  return {
+    serverName: "remix-mcp",
+    version: params.version,
+    policy: loadPolicy(),
+    logger: createLogger(),
+    getCollabApiClient: () => createCollabApiClient(),
+    agentMetadata: {
+      type: process.env.COMERGE_AGENT_TYPE?.trim() || "agent",
+      name: process.env.COMERGE_AGENT_NAME?.trim() || "remix-mcp",
+      version: process.env.COMERGE_AGENT_VERSION?.trim() || params.version,
+      provider: process.env.COMERGE_AGENT_PROVIDER?.trim() || "remix"
+    }
+  };
+}
+
+// src/tools/collab/register.ts
+import { z as z3 } from "zod";
+
+// src/contracts/collab.ts
+import { z as z2 } from "zod";
+
+// src/contracts/common.ts
+import { z } from "zod";
+var SCHEMA_VERSION = 1;
+var commonRequestFieldsSchema = {
+  cwd: z.string().trim().min(1).optional(),
+  requestId: z.string().trim().min(1).optional(),
+  outputMode: z.enum(["summary", "full"]).optional()
+};
+var errorEnvelopeSchema = z.object({
+  code: z.custom(),
+  message: z.string().min(1),
+  hint: z.string().nullable(),
+  retryable: z.boolean(),
+  category: z.custom()
+});
+function makeSuccessSchema(dataSchema) {
+  return z.object({
+    schemaVersion: z.literal(SCHEMA_VERSION),
+    ok: z.literal(true),
+    tool: z.string().min(1),
+    requestId: z.string().nullable(),
+    data: dataSchema,
+    warnings: z.array(z.string()),
+    risks: z.array(z.string()),
+    recommendedNextActions: z.array(z.string())
+  });
+}
+function makeErrorSchema() {
+  return z.object({
+    schemaVersion: z.literal(SCHEMA_VERSION),
+    ok: z.literal(false),
+    tool: z.string().min(1),
+    requestId: z.string().nullable(),
+    error: errorEnvelopeSchema,
+    warnings: z.array(z.string()),
+    risks: z.array(z.string()),
+    recommendedNextActions: z.array(z.string())
+  });
+}
+function toJsonText(value) {
+  return JSON.stringify(value, null, 2);
+}
+function makeSuccessResult(envelope) {
+  return {
+    content: [{ type: "text", text: toJsonText(envelope) }],
+    structuredContent: envelope
+  };
+}
+function makeErrorResult(envelope) {
+  return {
+    content: [{ type: "text", text: toJsonText(envelope) }],
+    structuredContent: envelope,
+    isError: true
+  };
+}
+
+// src/contracts/collab.ts
+var genericRecordSchema = z2.record(z2.string(), z2.unknown());
+var genericArraySchema = z2.array(genericRecordSchema);
+var statusInputSchema = {
+  ...commonRequestFieldsSchema,
+  includeRemote: z2.boolean().optional()
+};
+var initInputSchema = {
+  ...commonRequestFieldsSchema,
+  appName: z2.string().trim().min(1).optional(),
+  forceNew: z2.boolean().optional()
+};
+var listInputSchema = {
+  requestId: z2.string().trim().min(1).optional(),
+  outputMode: z2.enum(["summary", "full"]).optional(),
+  forked: z2.enum(["only", "exclude", "all"]).optional()
+};
+var remixInputSchema = {
+  ...commonRequestFieldsSchema,
+  appId: z2.string().trim().min(1),
+  name: z2.string().trim().min(1).optional(),
+  outputDir: z2.string().trim().min(1).optional()
+};
+var addInputSchema = {
+  ...commonRequestFieldsSchema,
+  prompt: z2.string().trim().min(1),
+  assistantResponse: z2.string().trim().min(1).optional(),
+  diffSource: z2.enum(["worktree", "external"]).optional(),
+  externalDiff: z2.string().optional(),
+  allowBranchMismatch: z2.boolean().optional(),
+  idempotencyKey: z2.string().trim().min(1).optional()
+};
+var recordTurnInputSchema = {
+  ...commonRequestFieldsSchema,
+  prompt: z2.string().trim().min(1),
+  assistantResponse: z2.string().trim().min(1),
+  allowBranchMismatch: z2.boolean().optional(),
+  idempotencyKey: z2.string().trim().min(1).optional()
+};
+var previewInputSchema = {
+  ...commonRequestFieldsSchema
+};
+var applyInputSchema = {
+  ...commonRequestFieldsSchema,
+  confirm: z2.boolean(),
+  allowBranchMismatch: z2.boolean().optional()
+};
+var requestMergeInputSchema = {
+  ...commonRequestFieldsSchema
+};
+var inboxInputSchema = {
+  requestId: z2.string().trim().min(1).optional(),
+  outputMode: z2.enum(["summary", "full"]).optional(),
+  status: z2.string().trim().min(1).optional()
+};
+var viewMergeRequestInputSchema = {
+  requestId: z2.string().trim().min(1).optional(),
+  outputMode: z2.enum(["summary", "full"]).optional(),
+  mrId: z2.string().trim().min(1),
+  includeUnifiedDiff: z2.boolean().optional(),
+  diffMaxChars: z2.number().int().positive().max(2e5).optional()
+};
+var approveInputSchema = {
+  ...commonRequestFieldsSchema,
+  mrId: z2.string().trim().min(1),
+  confirm: z2.boolean(),
+  allowBranchMismatch: z2.boolean().optional()
+};
+var rejectInputSchema = {
+  requestId: z2.string().trim().min(1).optional(),
+  mrId: z2.string().trim().min(1),
+  confirm: z2.boolean()
+};
+var inviteInputSchema = {
+  ...commonRequestFieldsSchema,
+  email: z2.string().email(),
+  scope: z2.enum(["organization", "project", "app"]).optional(),
+  targetId: z2.string().trim().min(1).optional(),
+  role: z2.string().trim().min(1).optional(),
+  ttlDays: z2.number().int().positive().max(30).optional()
+};
+var statusDataSchema = z2.object({
+  status: genericRecordSchema,
+  riskLevel: z2.enum(["low", "medium", "high"])
+});
+var initDataSchema = z2.object({
+  reused: z2.boolean(),
+  projectId: z2.string(),
+  appId: z2.string(),
+  upstreamAppId: z2.string(),
+  bindingPath: z2.string(),
+  repoRoot: z2.string()
+});
+var listDataSchema = z2.object({
+  apps: genericArraySchema
+});
+var remixDataSchema = z2.object({
+  appId: z2.string(),
+  projectId: z2.string(),
+  upstreamAppId: z2.string(),
+  bindingPath: z2.string(),
+  repoRoot: z2.string()
+});
+var addDataSchema = z2.object({
+  changeStep: genericRecordSchema,
+  autoSync: genericRecordSchema
+});
+var recordTurnDataSchema = genericRecordSchema;
+var syncDataSchema = genericRecordSchema;
+var requestMergeDataSchema = genericRecordSchema;
+var inboxDataSchema = z2.object({
+  mergeRequests: z2.array(genericRecordSchema)
+});
+var viewMergeRequestDataSchema = genericRecordSchema;
+var approveDataSchema = genericRecordSchema;
+var rejectDataSchema = genericRecordSchema;
+var syncUpstreamDataSchema = genericRecordSchema;
+var reconcileDataSchema = genericRecordSchema;
+var inviteDataSchema = genericRecordSchema;
+var statusSuccessSchema = makeSuccessSchema(statusDataSchema);
+var initSuccessSchema = makeSuccessSchema(initDataSchema);
+var listSuccessSchema = makeSuccessSchema(listDataSchema);
+var remixSuccessSchema = makeSuccessSchema(remixDataSchema);
+var addSuccessSchema = makeSuccessSchema(addDataSchema);
+var recordTurnSuccessSchema = makeSuccessSchema(recordTurnDataSchema);
+var syncSuccessSchema = makeSuccessSchema(syncDataSchema);
+var requestMergeSuccessSchema = makeSuccessSchema(requestMergeDataSchema);
+var inboxSuccessSchema = makeSuccessSchema(inboxDataSchema);
+var viewMergeRequestSuccessSchema = makeSuccessSchema(viewMergeRequestDataSchema);
+var approveSuccessSchema = makeSuccessSchema(approveDataSchema);
+var rejectSuccessSchema = makeSuccessSchema(rejectDataSchema);
+var syncUpstreamSuccessSchema = makeSuccessSchema(syncUpstreamDataSchema);
+var reconcileSuccessSchema = makeSuccessSchema(reconcileDataSchema);
+var inviteSuccessSchema = makeSuccessSchema(inviteDataSchema);
+
+// src/domain/coreAdapter.ts
+import {
+  collabAdd as coreCollabAdd,
+  collabRecordTurn as coreCollabRecordTurn,
+  collabApprove as coreCollabApprove,
+  collabInbox as coreCollabInbox,
+  collabInit as coreCollabInit,
+  collabInvite as coreCollabInvite,
+  collabReconcile as coreCollabReconcile,
+  collabReject as coreCollabReject,
+  collabRemix as coreCollabRemix,
+  collabRequestMerge as coreCollabRequestMerge,
+  collabStatus as coreCollabStatus,
+  collabSync as coreCollabSync,
+  collabSyncUpstream as coreCollabSyncUpstream,
+  collabView as coreCollabView
+} from "@remixhq/core/collab";
+import { findGitRoot, getHeadCommitHash, listUntrackedFiles } from "@remixhq/core/repo";
+function unwrapResponseObject(resp, label) {
+  const obj = resp?.responseObject;
+  if (obj === void 0 || obj === null) {
+    throw new Error(typeof resp?.message === "string" && resp.message.trim() ? resp.message : `Missing ${label} response`);
+  }
+  return obj;
+}
+function normalizeMergeRequestsPayload(payload) {
+  if (Array.isArray(payload)) return payload;
+  if (!payload || typeof payload !== "object") return [];
+  return Object.values(payload).flatMap(
+    (value) => Array.isArray(value) ? value : []
+  );
+}
+function getRiskLevel(status) {
+  if (status.recommendedAction === "reconcile") return "high";
+  if (status.recommendedAction === "sync" || status.remote.incomingOpenMergeRequestCount) return "medium";
+  if (status.repo.branchMismatch || !status.repo.isGitRepo || !status.binding.isBound || !status.repo.worktree.isClean) return "medium";
+  return "low";
+}
+function getRecommendedNextActions(status) {
+  if (status.repo.branchMismatch) {
+    return [
+      `Switch to the preferred branch (${status.binding.preferredBranch ?? "configured in the binding"}) before mutating Remix state, or rerun with allowBranchMismatch=true if intentional.`
+    ];
+  }
+  switch (status.recommendedAction) {
+    case "init":
+      return ["Run remix_collab_init to bind the repository to Remix."];
+    case "sync":
+      return ["Run remix_collab_sync_preview, then remix_collab_sync_apply if the preview is acceptable."];
+    case "reconcile":
+      return ["Run remix_collab_reconcile_preview before attempting remix_collab_reconcile_apply."];
+    case "review_inbox":
+      return ["Run remix_collab_inbox to inspect open merge requests."];
+    default:
+      return [];
+  }
+}
+function collectWarnings(value) {
+  if (!value || !Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function collectResultWarnings(value) {
+  return collectWarnings(value.warnings);
+}
+function truncateText(value, maxChars) {
+  if (value.length <= maxChars) {
+    return {
+      text: value,
+      truncated: false,
+      originalChars: value.length
+    };
+  }
+  return {
+    text: `${value.slice(0, maxChars)}
+
+[truncated ${value.length - maxChars} chars]`,
+    truncated: true,
+    originalChars: value.length
+  };
+}
+async function getStatus(params) {
+  const api = params.includeRemote ? await createCollabApiClient() : null;
+  const status = await coreCollabStatus({
+    api,
+    cwd: params.cwd
+  });
+  return {
+    data: {
+      status,
+      riskLevel: getRiskLevel(status)
+    },
+    warnings: status.warnings,
+    recommendedNextActions: getRecommendedNextActions(status),
+    logContext: {
+      repoRoot: status.repo.repoRoot,
+      appId: status.binding.currentAppId
+    }
+  };
+}
+async function initCollab(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabInit({
+    api,
+    cwd: params.cwd,
+    appName: params.appName ?? null,
+    forceNew: params.forceNew ?? false
+  });
+  return {
+    data: result,
+    warnings: collectResultWarnings(result),
+    recommendedNextActions: ["Run remix_collab_status to inspect sync and merge readiness."],
+    logContext: {
+      repoRoot: result.repoRoot,
+      appId: result.appId
+    }
+  };
+}
+async function listApps(params) {
+  const api = await createApiClient();
+  const resp = await api.listApps({ forked: params.forked ?? "all" });
+  const apps = unwrapResponseObject(resp, "apps");
+  return {
+    data: { apps },
+    warnings: [],
+    recommendedNextActions: [],
+    logContext: {}
+  };
+}
+async function remixCollab(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabRemix({
+    api,
+    cwd: params.cwd,
+    appId: params.appId,
+    name: params.name ?? null,
+    outputDir: params.outputDir ?? null
+  });
+  return {
+    data: result,
+    warnings: collectResultWarnings(result),
+    recommendedNextActions: ["Run remix_collab_status inside the remix checkout to inspect its state."],
+    logContext: {
+      repoRoot: result.repoRoot,
+      appId: result.appId
+    }
+  };
+}
+async function addCollabStep(params) {
+  const api = await createCollabApiClient();
+  const repoRoot = await findGitRoot(params.cwd);
+  const preHead = await getHeadCommitHash(repoRoot);
+  const untrackedBefore = params.diffSource === "worktree" ? await listUntrackedFiles(repoRoot) : [];
+  const changeStep = await coreCollabAdd({
+    api,
+    cwd: params.cwd,
+    prompt: params.prompt,
+    assistantResponse: params.assistantResponse ?? null,
+    diff: params.externalDiff ?? null,
+    diffSource: params.diffSource,
+    allowBranchMismatch: params.allowBranchMismatch ?? false,
+    idempotencyKey: params.idempotencyKey ?? null,
+    actor: params.agent
+  });
+  const postHead = await getHeadCommitHash(repoRoot);
+  const autoSyncEligible = params.diffSource === "worktree";
+  const localRepoMutated = autoSyncEligible && preHead !== postHead;
+  return {
+    data: {
+      changeStep,
+      autoSync: {
+        requested: true,
+        eligible: autoSyncEligible,
+        attempted: autoSyncEligible,
+        applied: autoSyncEligible,
+        trackedChangesDiscarded: autoSyncEligible,
+        capturedUntrackedPathsCandidate: untrackedBefore,
+        localHeadBefore: preHead,
+        localHeadAfter: postHead,
+        localRepoMutated
+      }
+    },
+    warnings: [
+      ...collectResultWarnings(changeStep),
+      ...params.diffSource === "external" ? [
+        "Automatic local discard+sync was skipped because the diff came from an external source and may not match the current worktree."
+      ] : []
+    ],
+    recommendedNextActions: [],
+    logContext: {
+      repoRoot
+    }
+  };
+}
+async function recordCollabTurn(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabRecordTurn({
+    api,
+    cwd: params.cwd,
+    prompt: params.prompt,
+    assistantResponse: params.assistantResponse,
+    allowBranchMismatch: params.allowBranchMismatch ?? false,
+    idempotencyKey: params.idempotencyKey ?? null,
+    actor: params.agent
+  });
+  return {
+    data: result,
+    warnings: [],
+    recommendedNextActions: [],
+    logContext: {
+      repoRoot: params.cwd,
+      appId: result.appId
+    }
+  };
+}
+async function syncCollab(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabSync({
+    api,
+    cwd: params.cwd,
+    dryRun: params.dryRun,
+    allowBranchMismatch: params.allowBranchMismatch ?? false
+  });
+  return {
+    data: result,
+    warnings: collectResultWarnings(result),
+    recommendedNextActions: params.dryRun ? ["Run remix_collab_sync_apply with confirm=true to apply this fast-forward update."] : [],
+    logContext: {
+      repoRoot: result.repoRoot
+    }
+  };
+}
+async function requestMerge(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabRequestMerge({
+    api,
+    cwd: params.cwd
+  });
+  return {
+    data: result,
+    warnings: [],
+    recommendedNextActions: result.id ? [`Run remix_collab_view_merge_request with mrId=${String(result.id)} to inspect the request.`] : [],
+    logContext: {
+      mrId: typeof result.id === "string" ? result.id : null
+    }
+  };
+}
+async function inbox(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabInbox({ api });
+  const mergeRequests = normalizeMergeRequestsPayload(result.mergeRequests).filter(
+    (mr) => params.status ? String(mr.status ?? "") === params.status : true
+  );
+  return {
+    data: { mergeRequests },
+    warnings: [],
+    recommendedNextActions: [],
+    logContext: {}
+  };
+}
+async function viewMergeRequest(params) {
+  const api = await createCollabApiClient();
+  const review = await coreCollabView({
+    api,
+    mrId: params.mrId
+  });
+  const truncatedDiff = params.includeUnifiedDiff ? truncateText(review.unifiedDiff, params.diffMaxChars) : null;
+  return {
+    data: {
+      mergeRequest: review.mergeRequest,
+      prompts: review.prompts,
+      changeSteps: review.changeSteps,
+      stats: review.stats,
+      unifiedDiff: truncatedDiff?.text ?? null,
+      diffTruncated: truncatedDiff?.truncated ?? false,
+      originalUnifiedDiffChars: truncatedDiff?.originalChars ?? review.unifiedDiff.length
+    },
+    warnings: truncatedDiff?.truncated ? ["Unified diff output was truncated to respect the configured output limit."] : [],
+    recommendedNextActions: [],
+    logContext: {
+      mrId: params.mrId,
+      appId: review.mergeRequest.targetAppId
+    }
+  };
+}
+async function approveMergeRequest(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabApprove({
+    api,
+    mrId: params.mrId,
+    cwd: params.cwd,
+    mode: params.mode,
+    allowBranchMismatch: params.allowBranchMismatch ?? false
+  });
+  return {
+    data: result,
+    warnings: collectResultWarnings(result),
+    recommendedNextActions: [],
+    logContext: {
+      repoRoot: result.repoRoot ?? null,
+      appId: result.targetAppId,
+      mrId: result.mergeRequestId
+    }
+  };
+}
+async function rejectMergeRequest(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabReject({
+    api,
+    mrId: params.mrId
+  });
+  return {
+    data: result,
+    warnings: [],
+    recommendedNextActions: [],
+    logContext: {
+      mrId: params.mrId
+    }
+  };
+}
+async function syncUpstream(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabSyncUpstream({
+    api,
+    cwd: params.cwd
+  });
+  return {
+    data: result,
+    warnings: collectResultWarnings(result),
+    recommendedNextActions: [],
+    logContext: {
+      repoRoot: result.repoRoot,
+      appId: result.appId,
+      mrId: "mergeRequestId" in result ? result.mergeRequestId ?? null : null
+    }
+  };
+}
+async function reconcile(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabReconcile({
+    api,
+    cwd: params.cwd,
+    dryRun: params.dryRun,
+    allowBranchMismatch: params.allowBranchMismatch ?? false
+  });
+  return {
+    data: result,
+    warnings: collectWarnings(result.warnings),
+    recommendedNextActions: params.dryRun ? ["Run remix_collab_reconcile_apply with confirm=true only if the preview is acceptable."] : [],
+    risks: params.dryRun ? ["Reconcile apply rewrites local history and creates a backup branch."] : [],
+    logContext: {
+      repoRoot: result.repoRoot ?? null
+    }
+  };
+}
+async function inviteCollaborator(params) {
+  const api = await createCollabApiClient();
+  const result = await coreCollabInvite({
+    api,
+    cwd: params.cwd,
+    email: params.email,
+    role: params.role ?? null,
+    scope: params.scope ?? "project",
+    targetId: params.targetId ?? null,
+    ttlDays: params.ttlDays
+  });
+  return {
+    data: result,
+    warnings: [],
+    recommendedNextActions: [],
+    logContext: {}
+  };
+}
+
+// src/tools/collab/register.ts
+function getAnnotations(access) {
+  if (access === "read") {
+    return {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    };
+  }
+  return {
+    readOnlyHint: false,
+    destructiveHint: access === "local_write",
+    idempotentHint: false,
+    openWorldHint: false
+  };
+}
+function buildSuccessEnvelope(tool, requestId, result) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    ok: true,
+    tool,
+    requestId: requestId ?? null,
+    data: result.data,
+    warnings: result.warnings ?? [],
+    risks: result.risks ?? [],
+    recommendedNextActions: result.recommendedNextActions ?? []
+  };
+}
+function deriveErrorRisks(tool, normalized) {
+  if (tool === "remix_collab_add" && normalized.message === "Change step succeeded remotely, but automatic local sync failed.") {
+    return ["The change step succeeded remotely, but the local repository may need manual recovery or a follow-up sync."];
+  }
+  if (normalized.code === "DESTRUCTIVE_OPERATION_BLOCKED") {
+    return ["A policy guard blocked a potentially destructive or state-mutating operation."];
+  }
+  if (normalized.code === "REPO_LOCK_TIMEOUT") {
+    return ["Another Remix mutation was already in progress for this repository, so the local mutation did not run."];
+  }
+  if (normalized.code === "REPO_STATE_CHANGED_DURING_OPERATION") {
+    return ["The repository changed during the operation, so Remix aborted before applying a destructive local mutation."];
+  }
+  return [];
+}
+function buildErrorEnvelope(tool, requestId, error) {
+  const normalized = normalizeToolError(error);
+  const recommendedNextActions = normalized.code === "AUTH_REQUIRED" ? ["Set COMERGE_ACCESS_TOKEN, then retry the tool call."] : normalized.code === "REPO_LOCK_TIMEOUT" ? ["Wait for the active Remix mutation to finish, then retry the tool call."] : normalized.code === "REPO_STATE_CHANGED_DURING_OPERATION" ? ["Review local repository changes, then rerun the tool once the worktree is stable."] : normalized.code === "PREFERRED_BRANCH_MISMATCH" ? ["Switch to the repository's preferred Remix branch, or rerun with allowBranchMismatch=true if intentional."] : [];
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    ok: false,
+    tool,
+    requestId: requestId ?? null,
+    error: normalized,
+    warnings: [],
+    risks: deriveErrorRisks(tool, normalized),
+    recommendedNextActions
+  };
+}
+function registerTool(server, context, params) {
+  const errorSchema = makeErrorSchema();
+  server.registerTool(
+    params.name,
+    {
+      title: params.name,
+      description: params.description,
+      inputSchema: params.inputSchema,
+      outputSchema: params.outputSchema,
+      annotations: getAnnotations(params.access)
+    },
+    async (rawArgs) => {
+      const requestId = typeof rawArgs.requestId === "string" ? rawArgs.requestId : void 0;
+      const startedAt = Date.now();
+      try {
+        assertToolAccess(context.policy, params.access);
+        const result = await params.run(rawArgs);
+        const envelope = buildSuccessEnvelope(params.name, requestId, result);
+        params.outputSchema.parse(envelope);
+        context.logger.log({
+          level: "info",
+          message: "tool_completed",
+          tool: params.name,
+          requestId: envelope.requestId,
+          durationMs: Date.now() - startedAt,
+          result: "success",
+          repoRoot: result.logContext?.repoRoot ?? null,
+          appId: result.logContext?.appId ?? null,
+          mrId: result.logContext?.mrId ?? null,
+          truncated: result.warnings?.some((warning) => warning.toLowerCase().includes("truncated")) ?? false
+        });
+        return makeSuccessResult(envelope);
+      } catch (error) {
+        const envelope = buildErrorEnvelope(params.name, requestId, error);
+        errorSchema.parse(envelope);
+        context.logger.log({
+          level: "error",
+          message: "tool_failed",
+          tool: params.name,
+          requestId: envelope.requestId,
+          durationMs: Date.now() - startedAt,
+          result: "error",
+          errorCode: envelope.error.code
+        });
+        return makeErrorResult(envelope);
+      }
+    }
+  );
+}
+function registerCollabTools(server, context) {
+  registerTool(server, context, {
+    name: "remix_collab_status",
+    description: "Summarize repository binding, worktree state, merge request counts, and sync or reconcile readiness.",
+    access: "read",
+    inputSchema: statusInputSchema,
+    outputSchema: statusSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(statusInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return getStatus({
+        cwd,
+        includeRemote: input.includeRemote ?? true
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_init",
+    description: "Import the current repository into Remix and write the local binding file.",
+    access: "remote_write",
+    inputSchema: initInputSchema,
+    outputSchema: initSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(initInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return initCollab({
+        cwd,
+        appName: input.appName,
+        forceNew: input.forceNew
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_list",
+    description: "List Remix apps visible to the current authenticated user.",
+    access: "read",
+    inputSchema: listInputSchema,
+    outputSchema: listSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(listInputSchema).parse(args);
+      return listApps({ forked: input.forked });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_remix",
+    description: "Fork a Remix app and materialize a new local checkout bound to the remix. Prefer `outputDir` for an exact destination outside any existing git repo; `cwd` is only the parent-directory fallback.",
+    access: "remote_write",
+    inputSchema: remixInputSchema,
+    outputSchema: remixSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(remixInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return remixCollab({
+        cwd,
+        appId: input.appId,
+        name: input.name,
+        outputDir: input.outputDir
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_add",
+    description: "Record one collaboration change step for the current bound repository, using the live worktree by default.",
+    access: "local_write",
+    inputSchema: addInputSchema,
+    outputSchema: addSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(addInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const diffSource = input.diffSource ?? "worktree";
+      if (diffSource === "external") {
+        const externalDiff = input.externalDiff ?? "";
+        assertDiffWithinLimit(context.policy, externalDiff);
+      }
+      return addCollabStep({
+        cwd,
+        prompt: input.prompt,
+        assistantResponse: input.assistantResponse,
+        diffSource,
+        externalDiff: input.externalDiff,
+        allowBranchMismatch: input.allowBranchMismatch ?? false,
+        idempotencyKey: input.idempotencyKey,
+        agent: context.agentMetadata
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_record_turn",
+    description: "Record one no-diff collaboration turn for the current bound repository after a completed assistant response.",
+    access: "remote_write",
+    inputSchema: recordTurnInputSchema,
+    outputSchema: recordTurnSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(recordTurnInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return recordCollabTurn({
+        cwd,
+        prompt: input.prompt,
+        assistantResponse: input.assistantResponse,
+        allowBranchMismatch: input.allowBranchMismatch ?? false,
+        idempotencyKey: input.idempotencyKey,
+        agent: context.agentMetadata
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_sync_preview",
+    description: "Preview whether the current bound repository can be fast-forward synced to the Remix app state.",
+    access: "read",
+    inputSchema: previewInputSchema,
+    outputSchema: syncSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(previewInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return syncCollab({ cwd, dryRun: true });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_sync_apply",
+    description: "Fast-forward sync the current bound repository to the Remix app state.",
+    access: "local_write",
+    inputSchema: applyInputSchema,
+    outputSchema: syncSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(applyInputSchema).parse(args);
+      assertConfirm(input.confirm, "remix_collab_sync_apply");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return syncCollab({ cwd, dryRun: false, allowBranchMismatch: input.allowBranchMismatch ?? false });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_request_merge",
+    description: "Open a merge request from the current bound repository to its upstream app.",
+    access: "remote_write",
+    inputSchema: requestMergeInputSchema,
+    outputSchema: requestMergeSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(requestMergeInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return requestMerge({ cwd });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_inbox",
+    description: "List merge requests available for review.",
+    access: "read",
+    inputSchema: inboxInputSchema,
+    outputSchema: inboxSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(inboxInputSchema).parse(args);
+      return inbox({ status: input.status });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_view_merge_request",
+    description: "View merge request metadata, prompts, change steps, and optionally a bounded unified diff.",
+    access: "read",
+    inputSchema: viewMergeRequestInputSchema,
+    outputSchema: viewMergeRequestSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(viewMergeRequestInputSchema).parse(args);
+      return viewMergeRequest({
+        mrId: input.mrId,
+        includeUnifiedDiff: input.includeUnifiedDiff ?? false,
+        diffMaxChars: input.diffMaxChars ?? context.policy.maxDiffOutputChars
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_approve_remote",
+    description: "Approve a merge request remotely and wait for terminal completion without mutating the local repository.",
+    access: "remote_write",
+    inputSchema: approveInputSchema,
+    outputSchema: approveSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(approveInputSchema).parse(args);
+      assertConfirm(input.confirm, "remix_collab_approve_remote");
+      return approveMergeRequest({
+        mrId: input.mrId,
+        mode: "remote-only",
+        allowBranchMismatch: input.allowBranchMismatch ?? false
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_approve_and_sync_target",
+    description: "Approve a merge request, wait for completion, and sync the target repository locally.",
+    access: "local_write",
+    inputSchema: approveInputSchema,
+    outputSchema: approveSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(approveInputSchema).parse(args);
+      assertConfirm(input.confirm, "remix_collab_approve_and_sync_target");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return approveMergeRequest({
+        mrId: input.mrId,
+        cwd,
+        mode: "sync-target-repo",
+        allowBranchMismatch: input.allowBranchMismatch ?? false
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_reject",
+    description: "Reject a merge request.",
+    access: "remote_write",
+    inputSchema: rejectInputSchema,
+    outputSchema: rejectSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(rejectInputSchema).parse(args);
+      assertConfirm(input.confirm, "remix_collab_reject");
+      return rejectMergeRequest({ mrId: input.mrId });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_sync_upstream",
+    description: "Sync upstream changes into the current remix and update the local checkout.",
+    access: "local_write",
+    inputSchema: applyInputSchema,
+    outputSchema: syncUpstreamSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(applyInputSchema).parse(args);
+      assertConfirm(input.confirm, "remix_collab_sync_upstream");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return syncUpstream({ cwd });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_reconcile_preview",
+    description: "Preview reconcile readiness when the local repository cannot be fast-forward synced.",
+    access: "read",
+    inputSchema: previewInputSchema,
+    outputSchema: reconcileSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(previewInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return reconcile({ cwd, dryRun: true });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_reconcile_apply",
+    description: "Reconcile divergent local history against the bound Remix app and update the local checkout.",
+    access: "local_write",
+    inputSchema: applyInputSchema,
+    outputSchema: reconcileSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(applyInputSchema).parse(args);
+      assertConfirm(input.confirm, "remix_collab_reconcile_apply");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return reconcile({ cwd, dryRun: false, allowBranchMismatch: input.allowBranchMismatch ?? false });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_invite",
+    description: "Invite a collaborator to an organization, project, or app, using the current repository binding unless targetId is provided.",
+    access: "remote_write",
+    inputSchema: inviteInputSchema,
+    outputSchema: inviteSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(inviteInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return inviteCollaborator({
+        cwd,
+        email: input.email,
+        role: input.role,
+        scope: input.scope,
+        targetId: input.targetId,
+        ttlDays: input.ttlDays
+      });
+    }
+  });
+}
+
+// src/tools/memory/register.ts
+import { z as z5 } from "zod";
+
+// src/contracts/memory.ts
+import { z as z4 } from "zod";
+var genericRecordSchema2 = z4.record(z4.string(), z4.unknown());
+var genericArraySchema2 = z4.array(genericRecordSchema2);
+var memoryKindSchema = z4.enum(["collab_turn", "change_step", "merge_request", "reconcile"]);
+var paginationSchema = z4.object({
+  limit: z4.number().int().nonnegative(),
+  offset: z4.number().int().nonnegative(),
+  hasMore: z4.boolean()
+});
+var memorySummaryInputSchema = {
+  ...commonRequestFieldsSchema,
+  appId: z4.string().trim().min(1).optional()
+};
+var memorySearchInputSchema = {
+  ...commonRequestFieldsSchema,
+  appId: z4.string().trim().min(1).optional(),
+  query: z4.string().trim().min(1),
+  kinds: z4.array(memoryKindSchema).max(4).optional(),
+  limit: z4.number().int().positive().max(50).optional(),
+  offset: z4.number().int().nonnegative().optional(),
+  createdAfter: z4.string().trim().min(1).optional(),
+  createdBefore: z4.string().trim().min(1).optional()
+};
+var memoryTimelineInputSchema = {
+  ...commonRequestFieldsSchema,
+  appId: z4.string().trim().min(1).optional(),
+  kinds: z4.array(memoryKindSchema).max(4).optional(),
+  limit: z4.number().int().positive().max(50).optional(),
+  offset: z4.number().int().nonnegative().optional(),
+  createdAfter: z4.string().trim().min(1).optional(),
+  createdBefore: z4.string().trim().min(1).optional()
+};
+var changeStepDiffInputSchema = {
+  ...commonRequestFieldsSchema,
+  appId: z4.string().trim().min(1).optional(),
+  changeStepId: z4.string().trim().min(1)
+};
+var memorySummaryDataSchema = genericRecordSchema2;
+var memorySearchDataSchema = z4.object({
+  items: genericArraySchema2,
+  pagination: paginationSchema
+});
+var memoryTimelineDataSchema = z4.object({
+  items: genericArraySchema2,
+  pagination: paginationSchema
+});
+var changeStepDiffDataSchema = z4.object({
+  changeStepId: z4.string(),
+  appId: z4.string(),
+  diff: z4.string(),
+  diffSha256: z4.string(),
+  contentType: z4.string(),
+  encoding: z4.string(),
+  expiresIn: z4.number().int().positive()
+});
+var memorySummarySuccessSchema = makeSuccessSchema(memorySummaryDataSchema);
+var memorySearchSuccessSchema = makeSuccessSchema(memorySearchDataSchema);
+var memoryTimelineSuccessSchema = makeSuccessSchema(memoryTimelineDataSchema);
+var changeStepDiffSuccessSchema = makeSuccessSchema(changeStepDiffDataSchema);
+
+// src/domain/memoryAdapter.ts
+import { readCollabBinding } from "@remixhq/core/binding";
+import { findGitRoot as findGitRoot2 } from "@remixhq/core/repo";
+function buildSummaryNextActions(summary) {
+  const actions = [];
+  actions.push(
+    "Use `remix_collab_memory_search` next for focused why/history/failed-attempt questions about this app."
+  );
+  const recentItemCount = summary.recent.collabTurns.length + summary.recent.changeSteps.length + summary.recent.mergeRequests.length + summary.recent.reconciles.length;
+  if (recentItemCount > 0) {
+    actions.push("Use `remix_collab_memory_timeline` next if you need the chronological sequence of recent activity.");
+  }
+  if (summary.counts.failedChangeStepCount > 0 || summary.counts.reconcileCount > 0) {
+    actions.push(
+      "For prior failures or recovery history, run `remix_collab_memory_search` with a focused query and `kinds` narrowed to `change_step` and `reconcile` when appropriate."
+    );
+  }
+  return actions;
+}
+function getFirstChangeStepId(items) {
+  const changeStep = items.find((item) => item.kind === "change_step");
+  return changeStep?.id ?? null;
+}
+function buildSearchNextActions(result) {
+  if (result.items.length === 0) {
+    return [
+      "Try a broader `remix_collab_memory_search` query or fewer `kinds` filters if this topic likely uses different wording.",
+      "Use `remix_collab_memory_timeline` if you need a bounded chronological scan instead of relevance-ranked search."
+    ];
+  }
+  const actions = [
+    "Review the top matched memory items before falling back to raw git history so you keep the reasoning context in view."
+  ];
+  const changeStepId = getFirstChangeStepId(result.items);
+  if (changeStepId) {
+    actions.push(
+      `Use \`remix_collab_memory_change_step_diff\` with \`changeStepId=${changeStepId}\` if you need the full stored diff for the most relevant change step.`
+    );
+  }
+  if (result.pagination.hasMore) {
+    actions.push("Narrow the search with `kinds`, `createdAfter`, or `createdBefore` if you need a tighter historical slice.");
+  }
+  return actions;
+}
+function buildTimelineNextActions(result) {
+  if (result.items.length === 0) {
+    return [
+      "Use `remix_collab_memory_summary` for current state, then retry `remix_collab_memory_timeline` with broader filters if needed."
+    ];
+  }
+  const actions = [
+    "Use `remix_collab_memory_search` if you need relevance-ranked results for a specific feature, bug, or design decision."
+  ];
+  const changeStepId = getFirstChangeStepId(result.items);
+  if (changeStepId) {
+    actions.push(
+      `Use \`remix_collab_memory_change_step_diff\` with \`changeStepId=${changeStepId}\` after the timeline identifies the change step you need to inspect.`
+    );
+  }
+  if (result.pagination.hasMore) {
+    actions.push("Apply `kinds`, `createdAfter`, or `createdBefore` filters to focus the timeline on a smaller historical window.");
+  }
+  return actions;
+}
+function buildChangeStepDiffNextActions(changeStepId) {
+  return [
+    `Inspect the stored diff for \`changeStepId=${changeStepId}\`, then use raw git only if you still need exact repository-level commit or ancestry details.`
+  ];
+}
+function unwrapResponseObject2(resp, label) {
+  const obj = resp?.responseObject;
+  if (obj === void 0 || obj === null) {
+    throw new Error(typeof resp?.message === "string" && resp.message.trim() ? resp.message : `Missing ${label} response`);
+  }
+  return obj;
+}
+function makeNotBoundError() {
+  const error = new Error("Repository is not bound to Remix.");
+  error.hint = "Run `remix_collab_init` in this repository, or pass `appId` explicitly for a direct memory read.";
+  return error;
+}
+async function maybeFindGitRoot(cwd) {
+  try {
+    return await findGitRoot2(cwd);
+  } catch {
+    return null;
+  }
+}
+async function resolveMemoryTarget(params) {
+  const explicitAppId = params.appId?.trim();
+  if (explicitAppId) {
+    return {
+      appId: explicitAppId,
+      repoRoot: await maybeFindGitRoot(params.cwd)
+    };
+  }
+  const repoRoot = await findGitRoot2(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw makeNotBoundError();
+  }
+  return {
+    appId: binding.currentAppId,
+    repoRoot
+  };
+}
+async function getMemorySummary(params) {
+  const target = await resolveMemoryTarget(params);
+  const api = await createApiClient();
+  const resp = await api.getAgentMemorySummary(target.appId);
+  const data = unwrapResponseObject2(resp, "agent memory summary");
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: buildSummaryNextActions(data),
+    logContext: target
+  };
+}
+async function searchMemory(params) {
+  const target = await resolveMemoryTarget(params);
+  const api = await createApiClient();
+  const resp = await api.searchAgentMemory(target.appId, {
+    q: params.query,
+    kinds: params.kinds,
+    limit: params.limit,
+    offset: params.offset,
+    createdAfter: params.createdAfter,
+    createdBefore: params.createdBefore
+  });
+  const data = unwrapResponseObject2(resp, "agent memory search");
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: buildSearchNextActions(data),
+    logContext: target
+  };
+}
+async function getMemoryTimeline(params) {
+  const target = await resolveMemoryTarget(params);
+  const api = await createApiClient();
+  const resp = await api.listAgentMemoryTimeline(target.appId, {
+    kinds: params.kinds,
+    limit: params.limit,
+    offset: params.offset,
+    createdAfter: params.createdAfter,
+    createdBefore: params.createdBefore
+  });
+  const data = unwrapResponseObject2(resp, "agent memory timeline");
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: buildTimelineNextActions(data),
+    logContext: target
+  };
+}
+async function getChangeStepDiff(params) {
+  const target = await resolveMemoryTarget(params);
+  const api = await createApiClient();
+  const resp = await api.getChangeStepDiff(target.appId, params.changeStepId);
+  const data = unwrapResponseObject2(resp, "change step diff");
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: buildChangeStepDiffNextActions(data.changeStepId),
+    logContext: target
+  };
+}
+
+// src/tools/memory/register.ts
+function getAnnotations2(access) {
+  return {
+    readOnlyHint: access === "read",
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  };
+}
+function buildSuccessEnvelope2(tool, requestId, result) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    ok: true,
+    tool,
+    requestId: requestId ?? null,
+    data: result.data,
+    warnings: result.warnings ?? [],
+    risks: result.risks ?? [],
+    recommendedNextActions: result.recommendedNextActions ?? []
+  };
+}
+function buildErrorEnvelope2(tool, requestId, error) {
+  const normalized = normalizeToolError(error);
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    ok: false,
+    tool,
+    requestId: requestId ?? null,
+    error: normalized,
+    warnings: [],
+    risks: deriveErrorRisks2(normalized),
+    recommendedNextActions: normalized.code === "AUTH_REQUIRED" ? ["Run `remix login` or set COMERGE_ACCESS_TOKEN, then retry."] : []
+  };
+}
+function deriveErrorRisks2(normalized) {
+  if (normalized.code === "DESTRUCTIVE_OPERATION_BLOCKED") {
+    return ["A policy guard blocked a disallowed operation."];
+  }
+  return [];
+}
+function registerTool2(server, context, params) {
+  const errorSchema = makeErrorSchema();
+  server.registerTool(
+    params.name,
+    {
+      title: params.name,
+      description: params.description,
+      inputSchema: params.inputSchema,
+      outputSchema: params.outputSchema,
+      annotations: getAnnotations2(params.access)
+    },
+    async (rawArgs) => {
+      const requestId = typeof rawArgs.requestId === "string" ? rawArgs.requestId : void 0;
+      const startedAt = Date.now();
+      try {
+        assertToolAccess(context.policy, params.access);
+        const result = await params.run(rawArgs);
+        const envelope = buildSuccessEnvelope2(params.name, requestId, result);
+        params.outputSchema.parse(envelope);
+        context.logger.log({
+          level: "info",
+          message: "tool_completed",
+          tool: params.name,
+          requestId: envelope.requestId,
+          durationMs: Date.now() - startedAt,
+          result: "success",
+          repoRoot: result.logContext?.repoRoot ?? null,
+          appId: result.logContext?.appId ?? null,
+          mrId: result.logContext?.mrId ?? null,
+          truncated: result.warnings?.some((warning) => warning.toLowerCase().includes("truncated")) ?? false
+        });
+        return makeSuccessResult(envelope);
+      } catch (error) {
+        const envelope = buildErrorEnvelope2(params.name, requestId, error);
+        errorSchema.parse(envelope);
+        context.logger.log({
+          level: "error",
+          message: "tool_failed",
+          tool: params.name,
+          requestId: envelope.requestId,
+          durationMs: Date.now() - startedAt,
+          result: "error",
+          errorCode: envelope.error.code
+        });
+        return makeErrorResult(envelope);
+      }
+    }
+  );
+}
+function registerMemoryTools(server, context) {
+  registerTool2(server, context, {
+    name: "remix_collab_memory_summary",
+    description: "First read for a bound app's current collaboration state, recent reasoning context, and merge or reconcile history before deeper inspection.",
+    access: "read",
+    inputSchema: memorySummaryInputSchema,
+    outputSchema: memorySummarySuccessSchema,
+    run: async (args) => {
+      const input = z5.object(memorySummaryInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return getMemorySummary({
+        cwd,
+        appId: input.appId
+      });
+    }
+  });
+  registerTool2(server, context, {
+    name: "remix_collab_memory_search",
+    description: "Default tool for why/history/failed-attempt/user-intent questions. Search prompts, diffs, merge activity, reconciles, and other historical context before using raw git history.",
+    access: "read",
+    inputSchema: memorySearchInputSchema,
+    outputSchema: memorySearchSuccessSchema,
+    run: async (args) => {
+      const input = z5.object(memorySearchInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return searchMemory({
+        cwd,
+        appId: input.appId,
+        query: input.query,
+        kinds: input.kinds,
+        limit: input.limit,
+        offset: input.offset,
+        createdAfter: input.createdAfter,
+        createdBefore: input.createdBefore
+      });
+    }
+  });
+  registerTool2(server, context, {
+    name: "remix_collab_memory_timeline",
+    description: "Chronological view of collaboration memory for understanding what happened and in what order, with optional filters for bounded historical inspection.",
+    access: "read",
+    inputSchema: memoryTimelineInputSchema,
+    outputSchema: memoryTimelineSuccessSchema,
+    run: async (args) => {
+      const input = z5.object(memoryTimelineInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return getMemoryTimeline({
+        cwd,
+        appId: input.appId,
+        kinds: input.kinds,
+        limit: input.limit,
+        offset: input.offset,
+        createdAfter: input.createdAfter,
+        createdBefore: input.createdBefore
+      });
+    }
+  });
+  registerTool2(server, context, {
+    name: "remix_collab_memory_change_step_diff",
+    description: "Second-hop expansion tool that fetches the full stored diff for a specific change step after memory search, timeline, or review work has identified the relevant `changeStepId`.",
+    access: "read",
+    inputSchema: changeStepDiffInputSchema,
+    outputSchema: changeStepDiffSuccessSchema,
+    run: async (args) => {
+      const input = z5.object(changeStepDiffInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return getChangeStepDiff({
+        cwd,
+        appId: input.appId,
+        changeStepId: input.changeStepId
+      });
+    }
+  });
+}
+
+// src/server.ts
+function createRemixMcpServer(params) {
+  const context = createServerContext({ version: params.version });
+  const server = new McpServer({
+    name: context.serverName,
+    version: context.version
+  });
+  registerCollabTools(server, context);
+  registerMemoryTools(server, context);
+  return { server, context };
+}
+async function startStdioServer(params) {
+  const { server } = createRemixMcpServer(params);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  createRemixMcpServer,
+  startStdioServer
+};
+//# sourceMappingURL=index.js.map