@remixhq/claude-plugin 0.1.12 → 0.1.14

package/dist/mcp-server.cjs

@@ -21513,7 +21513,7 @@ var RemixError = class extends Error {
   }
 };
 
-// node_modules/@remixhq/core/dist/chunk-4276ARDF.js
+// node_modules/@remixhq/core/dist/chunk-XC2FV57P.js
 async function readJsonSafe(res) {
   const ct = res.headers.get("content-type") ?? "";
   if (!ct.toLowerCase().includes("application/json")) return null;
@@ -21628,10 +21628,29 @@ function createApiClient(config2, opts) {
       if (params?.projectId) qs.set("projectId", params.projectId);
       if (params?.organizationId) qs.set("organizationId", params.organizationId);
       if (params?.forked) qs.set("forked", params.forked);
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
       const suffix = qs.toString() ? `?${qs.toString()}` : "";
       return request(`/v1/apps${suffix}`, { method: "GET" });
     },
     getApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}`, { method: "GET" }),
+    getAppContext: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/context`, { method: "GET" }),
+    getAppOverview: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/overview`, { method: "GET" }),
+    listAppTimeline: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (params?.cursor) qs.set("cursor", params.cursor);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/timeline${suffix}`, { method: "GET" });
+    },
+    getAppTimelineEvent: (appId, eventId) => request(`/v1/apps/${encodeURIComponent(appId)}/timeline/${encodeURIComponent(eventId)}`, { method: "GET" }),
+    listAppEditQueue: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/edit-queue${suffix}`, { method: "GET" });
+    },
     getMergeRequest: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "GET" }),
     presignImportUpload: (payload) => request("/v1/apps/import/upload/presign", { method: "POST", body: JSON.stringify(payload) }),
     importFromUpload: (payload) => request("/v1/apps/import/upload", { method: "POST", body: JSON.stringify(payload) }),
@@ -21713,6 +21732,8 @@ function createApiClient(config2, opts) {
         qs.set("status", params.status);
       }
       if (params?.kind) qs.set("kind", params.kind);
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
       const suffix = qs.toString() ? `?${qs.toString()}` : "";
       return request(`/v1/merge-requests${suffix}`, { method: "GET" });
     },
@@ -21731,24 +21752,60 @@ function createApiClient(config2, opts) {
       method: "POST",
       body: JSON.stringify(payload)
     }),
-    listOrganizationMembers: (orgId) => request(`/v1/organizations/${encodeURIComponent(orgId)}/members`, { method: "GET" }),
+    listOrganizationMembers: (orgId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/organizations/${encodeURIComponent(orgId)}/members${suffix}`, { method: "GET" });
+    },
     updateOrganizationMember: (orgId, userId, payload) => request(`/v1/organizations/${encodeURIComponent(orgId)}/members/${encodeURIComponent(userId)}`, {
       method: "PATCH",
       body: JSON.stringify(payload)
     }),
-    listProjectMembers: (projectId) => request(`/v1/projects/${encodeURIComponent(projectId)}/members`, { method: "GET" }),
+    listProjectMembers: (projectId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/projects/${encodeURIComponent(projectId)}/members${suffix}`, { method: "GET" });
+    },
     updateProjectMember: (projectId, userId, payload) => request(`/v1/projects/${encodeURIComponent(projectId)}/members/${encodeURIComponent(userId)}`, {
       method: "PATCH",
       body: JSON.stringify(payload)
     }),
-    listAppMembers: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/members`, { method: "GET" }),
+    listAppMembers: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/members${suffix}`, { method: "GET" });
+    },
     updateAppMember: (appId, userId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/members/${encodeURIComponent(userId)}`, {
       method: "PATCH",
       body: JSON.stringify(payload)
     }),
-    listOrganizationInvites: (orgId) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations`, { method: "GET" }),
-    listProjectInvites: (projectId) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations`, { method: "GET" }),
-    listAppInvites: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations`, { method: "GET" }),
+    listOrganizationInvites: (orgId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations${suffix}`, { method: "GET" });
+    },
+    listProjectInvites: (projectId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/projects/${encodeURIComponent(projectId)}/invitations${suffix}`, { method: "GET" });
+    },
+    listAppInvites: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/invitations${suffix}`, { method: "GET" });
+    },
     resendOrganizationInvite: (orgId, inviteId, payload) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations/${encodeURIComponent(inviteId)}/resend`, {
       method: "POST",
       body: JSON.stringify(payload ?? {})
@@ -21770,6 +21827,7 @@ function createApiClient(config2, opts) {
     revokeAppInvite: (appId, inviteId) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations/${encodeURIComponent(inviteId)}`, {
       method: "DELETE"
     }),
+    acceptInvitation: (payload) => request("/v1/invitations/accept", { method: "POST", body: JSON.stringify(payload) }),
     syncUpstreamApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/sync-upstream`, {
       method: "POST",
       body: JSON.stringify({})
@@ -21805,7 +21863,31 @@ function createApiClient(config2, opts) {
         `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/assets/download?${qs.toString()}`,
         { method: "GET" }
       );
-    }
+    },
+    listAgentRuns: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      if (params?.status) qs.set("status", params.status);
+      if (params?.currentPhase) qs.set("currentPhase", params.currentPhase);
+      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/agent-runs${suffix}`, { method: "GET" });
+    },
+    getAgentRun: (appId, runId) => request(`/v1/apps/${encodeURIComponent(appId)}/agent-runs/${encodeURIComponent(runId)}`, { method: "GET" }),
+    listAgentRunEvents: (appId, runId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/agent-runs/${encodeURIComponent(runId)}/events${suffix}`, {
+        method: "GET"
+      });
+    },
+    getSandboxStatus: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/sandbox/status`, { method: "GET" })
   };
 }
 
@@ -41707,7 +41789,7 @@ var REMIX_ERROR_CODES = {
 // node_modules/@remixhq/mcp/dist/index.js
 var import_path11 = __toESM(require("path"), 1);
 
-// node_modules/@remixhq/core/dist/chunk-FAZUMWBS.js
+// node_modules/@remixhq/core/dist/chunk-GEHSFPCD.js
 var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_path2 = __toESM(require("path"), 1);
 var import_promises3 = __toESM(require("fs/promises"), 1);
@@ -41785,7 +41867,7 @@ async function writeCollabBinding(repoRoot, binding) {
   return filePath;
 }
 
-// node_modules/@remixhq/core/dist/chunk-RREREIGW.js
+// node_modules/@remixhq/core/dist/chunk-J3J4PBQ7.js
 var import_promises15 = __toESM(require("fs/promises"), 1);
 var import_crypto = require("crypto");
 var import_os2 = __toESM(require("os"), 1);
@@ -48566,7 +48648,7 @@ var {
   getCancelSignal: getCancelSignal2
 } = getIpcExport();
 
-// node_modules/@remixhq/core/dist/chunk-RREREIGW.js
+// node_modules/@remixhq/core/dist/chunk-J3J4PBQ7.js
 var GIT_REMOTE_PROTOCOL_RE = /^(https?|ssh):\/\//i;
 var SCP_LIKE_GIT_REMOTE_RE = /^(?<user>[^@\s]+)@(?<host>[^:\s]+):(?<path>[^\\\s]+)$/;
 var CANONICAL_GIT_REMOTE_RE = /^(?<host>(?:localhost|[a-z0-9.-]+))\/(?<path>[^\\\s]+)$/i;
@@ -48813,6 +48895,13 @@ async function listUntrackedFiles(cwd) {
     return [];
   }
 }
+async function getWorkspaceDiff(cwd) {
+  const snapshot = await getWorkspaceSnapshot(cwd);
+  return {
+    diff: snapshot.diff,
+    includedUntrackedPaths: snapshot.includedUntrackedPaths
+  };
+}
 async function getWorkspaceSnapshot(cwd) {
   const headCommitHash = await getHeadCommitHash(cwd);
   if (!headCommitHash) {
@@ -49252,6 +49341,26 @@ function unwrapResponseObject(resp, label) {
   }
   return obj;
 }
+var DEFAULT_PAGINATION_LIMIT = 25;
+var MAX_PAGINATION_LIMIT = 50;
+function normalizePagination(params) {
+  const rawLimit = typeof params?.limit === "number" && Number.isFinite(params.limit) ? Math.trunc(params.limit) : DEFAULT_PAGINATION_LIMIT;
+  const rawOffset = typeof params?.offset === "number" && Number.isFinite(params.offset) ? Math.trunc(params.offset) : 0;
+  return {
+    limit: Math.max(1, Math.min(MAX_PAGINATION_LIMIT, rawLimit)),
+    offset: Math.max(0, rawOffset)
+  };
+}
+function paginateOverfetchedItems(items, params) {
+  const pagination = normalizePagination(params);
+  return {
+    items: items.slice(0, pagination.limit),
+    pagination: {
+      ...pagination,
+      hasMore: items.length > pagination.limit
+    }
+  };
+}
 function unwrapMergeRequest(resp) {
   return unwrapResponseObject(resp, "merge request");
 }
@@ -50201,6 +50310,7 @@ async function collabAdd(params) {
     }
     const { backupPath } = await writeTempUnifiedDiffBackup(diff, "remix-add");
     try {
+      await pollAppReady(params.api, binding.currentAppId);
       if (submissionSnapshot) {
         await assertRepoSnapshotUnchanged(repoRoot, submissionSnapshot, {
           operation: "`remix collab add` auto-sync",
@@ -50345,6 +50455,105 @@ async function collabRecordTurn(params) {
   });
   return unwrapResponseObject(resp, "collab turn");
 }
+function collectWarnings(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+async function collabFinalizeTurn(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new RemixError("Repository is not bound to Remix.", {
+      exitCode: 2,
+      hint: "Run `remix collab init` first."
+    });
+  }
+  const prompt = params.prompt.trim();
+  const assistantResponse = params.assistantResponse.trim();
+  if (!prompt) throw new RemixError("Prompt is required.", { exitCode: 2 });
+  if (!assistantResponse) throw new RemixError("Assistant response is required.", { exitCode: 2 });
+  const diffSource = params.diffSource ?? (params.diff ? "external" : "worktree");
+  const externalDiff = params.diff?.trim() ?? "";
+  const workspaceDiff = diffSource === "worktree" ? await getWorkspaceDiff(repoRoot) : null;
+  const hasChangedTurn = diffSource === "external" ? externalDiff.length > 0 : Boolean(workspaceDiff?.diff.trim());
+  const currentHeadCommitHash = await getHeadCommitHash(repoRoot);
+  const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
+    kind: "collab_finalize_turn_v1",
+    appId: binding.currentAppId,
+    upstreamAppId: binding.upstreamAppId,
+    headCommitHash: currentHeadCommitHash,
+    modeHint: hasChangedTurn ? "changed_turn" : "no_diff_turn",
+    prompt,
+    assistantResponse,
+    externalDiff: diffSource === "external" ? externalDiff : null
+  });
+  if (diffSource === "external" && !hasChangedTurn) {
+    throw new RemixError("External diff is empty.", {
+      exitCode: 2,
+      hint: "Pass a non-empty diff when using external diff submission, or omit the external diff so finalize-turn can inspect the live worktree."
+    });
+  }
+  if (hasChangedTurn) {
+    const localHeadBefore = currentHeadCommitHash;
+    const capturedUntrackedPathsCandidate = diffSource === "worktree" ? await listUntrackedFiles(repoRoot) : [];
+    const changeStep = await collabAdd({
+      api: params.api,
+      cwd: repoRoot,
+      prompt,
+      assistantResponse,
+      diff: diffSource === "external" ? externalDiff : null,
+      diffSource,
+      sync: params.sync,
+      allowBranchMismatch: params.allowBranchMismatch,
+      idempotencyKey,
+      actor: params.actor
+    });
+    const localHeadAfter = await getHeadCommitHash(repoRoot);
+    const warnings = [
+      ...collectWarnings(changeStep.warnings),
+      ...diffSource === "external" && params.sync !== false ? [
+        "Automatic local discard+sync was skipped because the diff came from an external source and may not match the current worktree."
+      ] : []
+    ];
+    const autoSyncRequested = params.sync !== false;
+    const autoSyncEligible = diffSource === "worktree";
+    return {
+      mode: "changed_turn",
+      idempotencyKey,
+      changeStep,
+      collabTurn: null,
+      autoSync: {
+        requested: autoSyncRequested,
+        eligible: autoSyncEligible,
+        attempted: autoSyncRequested && autoSyncEligible,
+        applied: autoSyncRequested && autoSyncEligible,
+        trackedChangesDiscarded: autoSyncRequested && autoSyncEligible,
+        capturedUntrackedPathsCandidate,
+        localHeadBefore,
+        localHeadAfter,
+        localRepoMutated: autoSyncRequested && autoSyncEligible && localHeadBefore !== localHeadAfter
+      },
+      warnings
+    };
+  }
+  const collabTurn = await collabRecordTurn({
+    api: params.api,
+    cwd: repoRoot,
+    prompt,
+    assistantResponse,
+    allowBranchMismatch: params.allowBranchMismatch,
+    idempotencyKey,
+    actor: params.actor
+  });
+  return {
+    mode: "no_diff_turn",
+    idempotencyKey,
+    changeStep: null,
+    collabTurn,
+    autoSync: null,
+    warnings: []
+  };
+}
 async function collabApprove(params) {
   if (params.mode === "sync-target-repo") {
     if (!params.cwd?.trim()) {
@@ -50602,17 +50811,22 @@ async function collabListMergeRequests(params) {
     appId: params.appId,
     queue: params.queue
   });
+  const pageRequest = normalizePagination(params);
   const resp = await params.api.listMergeRequests({
     queue: params.queue,
     appId,
     status: params.status,
-    kind: params.kind ?? "merge"
+    kind: params.kind ?? "merge",
+    limit: pageRequest.limit + 1,
+    offset: pageRequest.offset
   });
   const mergeRequests = unwrapResponseObject(resp, "merge requests");
+  const page = paginateOverfetchedItems(mergeRequests, params);
   return {
     queue: params.queue,
     appId: appId ?? null,
-    mergeRequests
+    mergeRequests: page.items,
+    pagination: page.pagination
   };
 }
 async function resolveScopeTarget(params) {
@@ -50651,12 +50865,24 @@ async function collabListMembers(params) {
     scope: params.scope,
     targetId: params.targetId
   });
-  const resp = params.scope === "organization" ? await params.api.listOrganizationMembers(targetId) : params.scope === "project" ? await params.api.listProjectMembers(targetId) : await params.api.listAppMembers(targetId);
+  const pageRequest = normalizePagination(params);
+  const resp = params.scope === "organization" ? await params.api.listOrganizationMembers(targetId, {
+    limit: pageRequest.limit + 1,
+    offset: pageRequest.offset
+  }) : params.scope === "project" ? await params.api.listProjectMembers(targetId, {
+    limit: pageRequest.limit + 1,
+    offset: pageRequest.offset
+  }) : await params.api.listAppMembers(targetId, {
+    limit: pageRequest.limit + 1,
+    offset: pageRequest.offset
+  });
   const members = params.scope === "organization" ? unwrapResponseObject(resp, "members") : params.scope === "project" ? unwrapResponseObject(resp, "members") : unwrapResponseObject(resp, "members");
+  const page = paginateOverfetchedItems(members, params);
   return {
     scopeType: params.scope,
     targetId,
-    members
+    members: page.items,
+    pagination: page.pagination
   };
 }
 async function collabUpdateMemberRole(params) {
@@ -50850,6 +51076,20 @@ async function collabInvite(params) {
     targetId
   };
 }
+async function collabList(params) {
+  const pageRequest = normalizePagination(params);
+  const resp = await params.api.listApps({
+    forked: params.forked ?? "all",
+    limit: pageRequest.limit + 1,
+    offset: pageRequest.offset
+  });
+  const apps = unwrapResponseObject(resp, "apps");
+  const page = paginateOverfetchedItems(apps, params);
+  return {
+    apps: page.items,
+    pagination: page.pagination
+  };
+}
 async function collabReconcile(params) {
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await readCollabBinding(repoRoot);
@@ -51465,6 +51705,8 @@ var ERROR_CODES = {
   METADATA_CONFLICT: "METADATA_CONFLICT",
   DESTRUCTIVE_OPERATION_BLOCKED: "DESTRUCTIVE_OPERATION_BLOCKED",
   CONFIG_INVALID: "CONFIG_INVALID",
+  ACCESS_DENIED: "ACCESS_DENIED",
+  RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
   INTERNAL_ERROR: "INTERNAL_ERROR"
 };
 var RemixMcpError = class extends Error {
@@ -51480,6 +51722,15 @@ function toStringOrNull(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
 }
+function parseJsonObject(value) {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
 function makeNormalized(params) {
   return {
     code: params.code,
@@ -51493,6 +51744,8 @@ function normalizeByMessage(err) {
   const code = toStringOrNull(err.code);
   const message = toStringOrNull(err.message) ?? "Unexpected error.";
   const hint = toStringOrNull(err.hint);
+  const hintBody = parseJsonObject(hint);
+  const statusCode = typeof hintBody?.statusCode === "number" ? hintBody.statusCode : typeof hintBody?.statusCode === "string" ? Number(hintBody.statusCode) : null;
   if (code === ERROR_CODES.REPO_LOCK_HELD) {
     return makeNormalized({
       code: ERROR_CODES.REPO_LOCK_HELD,
@@ -51593,6 +51846,22 @@ function normalizeByMessage(err) {
       category: "remote_state"
     });
   }
+  if (statusCode === 403) {
+    return makeNormalized({
+      code: ERROR_CODES.ACCESS_DENIED,
+      message,
+      hint,
+      category: "remote_state"
+    });
+  }
+  if (statusCode === 404) {
+    return makeNormalized({
+      code: ERROR_CODES.RESOURCE_NOT_FOUND,
+      message,
+      hint,
+      category: "remote_state"
+    });
+  }
   if (message.includes("Timed out") || message.includes("failed") || message.includes("error state")) {
     return makeNormalized({
       code: ERROR_CODES.REMOTE_ERROR,
@@ -51770,6 +52039,11 @@ function makeErrorResult(envelope) {
 }
 var genericRecordSchema = external_exports.record(external_exports.string(), external_exports.unknown());
 var genericArraySchema = external_exports.array(genericRecordSchema);
+var paginationSchema = external_exports.object({
+  limit: external_exports.number().int().positive(),
+  offset: external_exports.number().int().nonnegative(),
+  hasMore: external_exports.boolean()
+});
 var mergeRequestQueueSchema = external_exports.enum([
   "reviewable",
   "created_by_me",
@@ -51791,7 +52065,9 @@ var initInputSchema = {
 var listInputSchema = {
   requestId: external_exports.string().trim().min(1).optional(),
   outputMode: external_exports.enum(["summary", "full"]).optional(),
-  forked: external_exports.enum(["only", "exclude", "all"]).optional()
+  forked: external_exports.enum(["only", "exclude", "all"]).optional(),
+  limit: external_exports.number().int().positive().max(50).optional(),
+  offset: external_exports.number().int().nonnegative().optional()
 };
 var remixInputSchema = {
   ...commonRequestFieldsSchema,
@@ -51820,6 +52096,16 @@ var recordTurnInputSchema = {
   allowBranchMismatch: external_exports.boolean().optional(),
   idempotencyKey: external_exports.string().trim().min(1).optional()
 };
+var finalizeTurnInputSchema = {
+  ...commonRequestFieldsSchema,
+  prompt: external_exports.string().trim().min(1),
+  assistantResponse: external_exports.string().trim().min(1),
+  diffSource: external_exports.enum(["worktree", "external"]).optional(),
+  externalDiff: external_exports.string().optional(),
+  sync: external_exports.boolean().optional(),
+  allowBranchMismatch: external_exports.boolean().optional(),
+  idempotencyKey: external_exports.string().trim().min(1).optional()
+};
 var previewInputSchema = {
   ...commonRequestFieldsSchema
 };
@@ -51835,20 +52121,26 @@ var reviewQueueInputSchema = {
   requestId: external_exports.string().trim().min(1).optional(),
   outputMode: external_exports.enum(["summary", "full"]).optional(),
   status: external_exports.string().trim().min(1).optional(),
-  kind: external_exports.enum(["merge", "sync", "all"]).optional()
+  kind: external_exports.enum(["merge", "sync", "all"]).optional(),
+  limit: external_exports.number().int().positive().max(50).optional(),
+  offset: external_exports.number().int().nonnegative().optional()
 };
 var myMergeRequestsInputSchema = {
   requestId: external_exports.string().trim().min(1).optional(),
   outputMode: external_exports.enum(["summary", "full"]).optional(),
   status: external_exports.string().trim().min(1).optional(),
-  kind: external_exports.enum(["merge", "sync", "all"]).optional()
+  kind: external_exports.enum(["merge", "sync", "all"]).optional(),
+  limit: external_exports.number().int().positive().max(50).optional(),
+  offset: external_exports.number().int().nonnegative().optional()
 };
 var appMergeRequestsInputSchema = {
   ...commonRequestFieldsSchema,
   queue: appScopedMergeRequestQueueSchema,
   appId: external_exports.string().trim().min(1).optional(),
   status: external_exports.string().trim().min(1).optional(),
-  kind: external_exports.enum(["merge", "sync", "all"]).optional()
+  kind: external_exports.enum(["merge", "sync", "all"]).optional(),
+  limit: external_exports.number().int().positive().max(50).optional(),
+  offset: external_exports.number().int().nonnegative().optional()
 };
 var viewMergeRequestInputSchema = {
   requestId: external_exports.string().trim().min(1).optional(),
@@ -51879,6 +52171,38 @@ var inviteInputSchema = {
 var listMembersInputSchema = {
   ...commonRequestFieldsSchema,
   scope: memberScopeSchema,
+  targetId: external_exports.string().trim().min(1).optional(),
+  limit: external_exports.number().int().positive().max(50).optional(),
+  offset: external_exports.number().int().nonnegative().optional()
+};
+var listInvitesInputSchema = {
+  ...commonRequestFieldsSchema,
+  scope: memberScopeSchema.optional(),
+  targetId: external_exports.string().trim().min(1).optional(),
+  limit: external_exports.number().int().positive().max(50).optional(),
+  offset: external_exports.number().int().nonnegative().optional()
+};
+var resendInviteInputSchema = {
+  ...commonRequestFieldsSchema,
+  scope: memberScopeSchema.optional(),
+  targetId: external_exports.string().trim().min(1).optional(),
+  inviteId: external_exports.string().trim().min(1),
+  ttlDays: external_exports.number().int().positive().max(30).optional()
+};
+var revokeInviteInputSchema = {
+  ...commonRequestFieldsSchema,
+  scope: memberScopeSchema.optional(),
+  targetId: external_exports.string().trim().min(1).optional(),
+  inviteId: external_exports.string().trim().min(1),
+  confirm: external_exports.boolean()
+};
+var acceptInvitationInputSchema = {
+  requestId: external_exports.string().trim().min(1).optional(),
+  token: external_exports.string().trim().min(20)
+};
+var accessDebugInputSchema = {
+  ...commonRequestFieldsSchema,
+  scope: memberScopeSchema.optional(),
   targetId: external_exports.string().trim().min(1).optional()
 };
 var updateMemberRoleInputSchema = {
@@ -51902,7 +52226,8 @@ var initDataSchema = external_exports.object({
   repoRoot: external_exports.string()
 });
 var listDataSchema = external_exports.object({
-  apps: genericArraySchema
+  apps: genericArraySchema,
+  pagination: paginationSchema
 });
 var remixDataSchema = external_exports.object({
   appId: external_exports.string(),
@@ -51925,12 +52250,21 @@ var addDataSchema = external_exports.object({
   autoSync: genericRecordSchema
 });
 var recordTurnDataSchema = genericRecordSchema;
+var finalizeTurnDataSchema = external_exports.object({
+  mode: external_exports.enum(["changed_turn", "no_diff_turn"]),
+  idempotencyKey: external_exports.string().min(1),
+  changeStep: genericRecordSchema.nullable(),
+  collabTurn: genericRecordSchema.nullable(),
+  autoSync: genericRecordSchema.nullable(),
+  warnings: external_exports.array(external_exports.string())
+});
 var syncDataSchema = genericRecordSchema;
 var requestMergeDataSchema = genericRecordSchema;
 var mergeRequestQueueDataSchema = external_exports.object({
   queue: mergeRequestQueueSchema,
   appId: external_exports.string().nullable(),
-  mergeRequests: external_exports.array(genericRecordSchema)
+  mergeRequests: external_exports.array(genericRecordSchema),
+  pagination: paginationSchema
 });
 var viewMergeRequestDataSchema = genericRecordSchema;
 var approveDataSchema = genericRecordSchema;
@@ -51942,7 +52276,49 @@ var memberRecordSchema = genericRecordSchema;
 var listMembersDataSchema = external_exports.object({
   scopeType: memberScopeSchema,
   targetId: external_exports.string(),
-  members: external_exports.array(memberRecordSchema)
+  members: external_exports.array(memberRecordSchema),
+  pagination: paginationSchema
+});
+var listInvitesDataSchema = external_exports.object({
+  scopeType: memberScopeSchema,
+  targetId: external_exports.string(),
+  invites: external_exports.array(genericRecordSchema),
+  pagination: paginationSchema
+});
+var resendInviteDataSchema = genericRecordSchema;
+var revokeInviteDataSchema = external_exports.object({
+  scopeType: memberScopeSchema,
+  targetId: external_exports.string(),
+  inviteId: external_exports.string(),
+  revoked: external_exports.boolean()
+});
+var acceptInvitationDataSchema = genericRecordSchema;
+var accessDebugDataSchema = external_exports.object({
+  viewer: genericRecordSchema,
+  scope: external_exports.object({
+    scopeType: memberScopeSchema,
+    targetId: external_exports.string()
+  }),
+  entities: external_exports.object({
+    organization: genericRecordSchema.nullable(),
+    project: genericRecordSchema.nullable(),
+    app: genericRecordSchema.nullable()
+  }),
+  binding: external_exports.object({
+    repoRoot: external_exports.string().nullable(),
+    binding: genericRecordSchema.nullable()
+  }),
+  access: external_exports.object({
+    appContext: genericRecordSchema.nullable(),
+    viewerMember: genericRecordSchema.nullable(),
+    viewerProjectMember: genericRecordSchema.nullable(),
+    inviteForViewerEmail: genericRecordSchema.nullable(),
+    effectiveAppAccess: genericRecordSchema.nullable()
+  }),
+  members: external_exports.array(genericRecordSchema),
+  membersPageInfo: paginationSchema,
+  invites: external_exports.array(genericRecordSchema),
+  invitesPageInfo: paginationSchema
 });
 var updateMemberRoleDataSchema = external_exports.object({
   scopeType: memberScopeSchema,
@@ -51956,6 +52332,7 @@ var remixSuccessSchema = makeSuccessSchema(remixDataSchema);
 var checkoutSuccessSchema = makeSuccessSchema(checkoutDataSchema);
 var addSuccessSchema = makeSuccessSchema(addDataSchema);
 var recordTurnSuccessSchema = makeSuccessSchema(recordTurnDataSchema);
+var finalizeTurnSuccessSchema = makeSuccessSchema(finalizeTurnDataSchema);
 var syncSuccessSchema = makeSuccessSchema(syncDataSchema);
 var requestMergeSuccessSchema = makeSuccessSchema(requestMergeDataSchema);
 var mergeRequestQueueSuccessSchema = makeSuccessSchema(mergeRequestQueueDataSchema);
@@ -51966,14 +52343,12 @@ var syncUpstreamSuccessSchema = makeSuccessSchema(syncUpstreamDataSchema);
 var reconcileSuccessSchema = makeSuccessSchema(reconcileDataSchema);
 var inviteSuccessSchema = makeSuccessSchema(inviteDataSchema);
 var listMembersSuccessSchema = makeSuccessSchema(listMembersDataSchema);
+var listInvitesSuccessSchema = makeSuccessSchema(listInvitesDataSchema);
+var resendInviteSuccessSchema = makeSuccessSchema(resendInviteDataSchema);
+var revokeInviteSuccessSchema = makeSuccessSchema(revokeInviteDataSchema);
+var acceptInvitationSuccessSchema = makeSuccessSchema(acceptInvitationDataSchema);
+var accessDebugSuccessSchema = makeSuccessSchema(accessDebugDataSchema);
 var updateMemberRoleSuccessSchema = makeSuccessSchema(updateMemberRoleDataSchema);
-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 getRiskLevel(status) {
   if (status.recommendedAction === "reconcile") return "high";
   if (status.recommendedAction === "sync" || status.remote.incomingOpenMergeRequestCount) return "medium";
@@ -51999,12 +52374,12 @@ function getRecommendedNextActions(status) {
       return [];
   }
 }
-function collectWarnings(value) {
+function collectWarnings2(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);
+  return collectWarnings2(value.warnings);
 }
 function truncateText(value, maxChars) {
   if (value.length <= maxChars) {
@@ -52060,13 +52435,17 @@ async function initCollab(params) {
   };
 }
 async function listApps(params) {
-  const api = await createApiClient2();
-  const resp = await api.listApps({ forked: params.forked ?? "all" });
-  const apps = unwrapResponseObject2(resp, "apps");
+  const api = await createCollabApiClient();
+  const result = await collabList({
+    api,
+    forked: params.forked,
+    limit: params.limit,
+    offset: params.offset
+  });
   return {
-    data: { apps },
+    data: result,
     warnings: [],
-    recommendedNextActions: [],
+    recommendedNextActions: result.pagination.hasMore ? [`Pass offset=${result.pagination.offset + result.pagination.limit} to load the next page.`] : [],
     logContext: {}
   };
 }
@@ -52107,70 +52486,28 @@ async function checkoutCollab(params) {
     }
   };
 }
-async function addCollabStep(params) {
+async function finalizeCollabTurn(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 collabAdd({
+  const result = await collabFinalizeTurn({
     api,
     cwd: params.cwd,
     prompt: params.prompt,
-    assistantResponse: params.assistantResponse ?? null,
+    assistantResponse: params.assistantResponse,
     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 collabRecordTurn({
-    api,
-    cwd: params.cwd,
-    prompt: params.prompt,
-    assistantResponse: params.assistantResponse,
+    sync: params.sync,
     allowBranchMismatch: params.allowBranchMismatch ?? false,
     idempotencyKey: params.idempotencyKey ?? null,
     actor: params.agent
   });
   return {
     data: result,
-    warnings: [],
+    warnings: result.warnings,
     recommendedNextActions: [],
     logContext: {
-      repoRoot: params.cwd,
-      appId: result.appId
+      repoRoot,
+      appId: result.changeStep?.appId ?? result.collabTurn?.appId ?? null
     }
   };
 }
@@ -52212,16 +52549,19 @@ async function reviewQueue(params) {
     api,
     queue: "reviewable",
     status: params.status ?? "open",
-    kind: params.kind ?? "merge"
+    kind: params.kind ?? "merge",
+    limit: params.limit,
+    offset: params.offset
   });
   return {
     data: {
       queue: result.queue,
       appId: result.appId,
-      mergeRequests: result.mergeRequests
+      mergeRequests: result.mergeRequests,
+      pagination: result.pagination
     },
     warnings: [],
-    recommendedNextActions: [],
+    recommendedNextActions: result.pagination.hasMore ? [`Pass offset=${result.pagination.offset + result.pagination.limit} to load the next page.`] : [],
     logContext: {}
   };
 }
@@ -52231,16 +52571,19 @@ async function myMergeRequests(params) {
     api,
     queue: "created_by_me",
     status: params.status ?? "open",
-    kind: params.kind ?? "merge"
+    kind: params.kind ?? "merge",
+    limit: params.limit,
+    offset: params.offset
   });
   return {
     data: {
       queue: result.queue,
       appId: result.appId,
-      mergeRequests: result.mergeRequests
+      mergeRequests: result.mergeRequests,
+      pagination: result.pagination
     },
     warnings: [],
-    recommendedNextActions: [],
+    recommendedNextActions: result.pagination.hasMore ? [`Pass offset=${result.pagination.offset + result.pagination.limit} to load the next page.`] : [],
     logContext: {}
   };
 }
@@ -52252,16 +52595,19 @@ async function listAppMergeRequests(params) {
     appId: params.appId,
     queue: params.queue,
     status: params.status ?? "open",
-    kind: params.kind ?? "merge"
+    kind: params.kind ?? "merge",
+    limit: params.limit,
+    offset: params.offset
   });
   return {
     data: {
       queue: result.queue,
       appId: result.appId,
-      mergeRequests: result.mergeRequests
+      mergeRequests: result.mergeRequests,
+      pagination: result.pagination
     },
     warnings: [],
-    recommendedNextActions: [],
+    recommendedNextActions: result.pagination.hasMore ? [`Pass offset=${result.pagination.offset + result.pagination.limit} to load the next page.`] : [],
     logContext: {
       appId: result.appId
     }
@@ -52354,7 +52700,7 @@ async function reconcile(params) {
   });
   return {
     data: result,
-    warnings: collectWarnings(result.warnings),
+    warnings: collectWarnings2(result.warnings),
     recommendedNextActions: params.dryRun ? ["Run remix_collab_reconcile_apply with confirm=true only if the preview is acceptable. Do not replace this with raw git history-rewrite commands."] : [],
     risks: params.dryRun ? ["Reconcile apply rewrites local history and creates a backup branch."] : [],
     logContext: {
@@ -52386,12 +52732,14 @@ async function listMembers(params) {
     api,
     cwd: params.cwd,
     scope: params.scope,
-    targetId: params.targetId ?? null
+    targetId: params.targetId ?? null,
+    limit: params.limit,
+    offset: params.offset
   });
   return {
     data: result,
     warnings: [],
-    recommendedNextActions: [],
+    recommendedNextActions: result.pagination.hasMore ? [`Pass offset=${result.pagination.offset + result.pagination.limit} to load the next page.`] : [],
     logContext: {}
   };
 }
@@ -52412,35 +52760,517 @@ async function updateMemberRole(params) {
     logContext: {}
   };
 }
-function getAnnotations(access) {
-  if (access === "read") {
-    return {
-      readOnlyHint: true,
-      idempotentHint: true,
-      openWorldHint: false
-    };
+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;
+}
+async function maybeFindGitRoot(cwd) {
+  try {
+    return await findGitRoot(cwd);
+  } catch {
+    return null;
   }
+}
+async function loadBindingContext(cwd) {
+  if (!cwd) return { repoRoot: null, binding: null };
+  const repoRoot = await maybeFindGitRoot(cwd);
+  if (!repoRoot) return { repoRoot: null, binding: null };
+  const binding = await readCollabBinding(repoRoot);
   return {
-    readOnlyHint: false,
-    destructiveHint: access === "local_write",
-    idempotentHint: false,
-    openWorldHint: false
+    repoRoot,
+    binding
   };
 }
-function buildSuccessEnvelope(tool, requestId, result) {
-  return {
-    schemaVersion: SCHEMA_VERSION,
-    ok: true,
-    tool,
-    requestId: requestId ?? null,
-    data: result.data,
-    warnings: result.warnings ?? [],
+function makeNotBoundError(message = "Repository is not bound to Remix.", hint) {
+  const error2 = new Error(message);
+  error2.hint = hint ?? "Run `remix_collab_init` in this repository, or pass the explicit id for a direct read.";
+  return error2;
+}
+function parseJsonObject2(value) {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function getBackendStatusCode(error2) {
+  if (!error2 || typeof error2 !== "object") return null;
+  const hint = "hint" in error2 && typeof error2.hint === "string" ? error2.hint : null;
+  const body = parseJsonObject2(hint);
+  if (typeof body?.statusCode === "number") return body.statusCode;
+  if (typeof body?.statusCode === "string") {
+    const parsed = Number(body.statusCode);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function isBackendForbidden(error2) {
+  return getBackendStatusCode(error2) === 403;
+}
+function isBackendNotFound(error2) {
+  return getBackendStatusCode(error2) === 404;
+}
+function createAccessDeniedError(message, hint) {
+  return new RemixMcpError({
+    code: ERROR_CODES.ACCESS_DENIED,
+    message,
+    hint: hint ?? null,
+    retryable: false,
+    category: "remote_state"
+  });
+}
+var MEMBERSHIP_PAGE_SIZE = 100;
+function normalizePagination2(params) {
+  const rawLimit = typeof params?.limit === "number" ? Math.trunc(params.limit) : 25;
+  const rawOffset = typeof params?.offset === "number" ? Math.trunc(params.offset) : 0;
+  return {
+    limit: Math.max(1, Math.min(50, rawLimit)),
+    offset: Math.max(0, rawOffset)
+  };
+}
+async function resolveScopeTarget2(api, params) {
+  const explicitTargetId = params.targetId?.trim();
+  const bindingContext = await loadBindingContext(params.cwd);
+  if (explicitTargetId) {
+    return {
+      scopeType: params.scope,
+      targetId: explicitTargetId,
+      repoRoot: bindingContext.repoRoot
+    };
+  }
+  if (!bindingContext.binding) {
+    throw makeNotBoundError("Scope target was not provided and the current repository is not bound to Remix.");
+  }
+  if (params.scope === "app") {
+    return {
+      scopeType: "app",
+      targetId: bindingContext.binding.currentAppId,
+      repoRoot: bindingContext.repoRoot
+    };
+  }
+  const appContext = unwrapResponseObject2(
+    await api.getAppContext(bindingContext.binding.currentAppId),
+    "bound app context"
+  );
+  if (params.scope === "project") {
+    if (!appContext.readableScopes.project) {
+      throw createAccessDeniedError(
+        "The bound app's project is not readable to the current user.",
+        "Use `scope=app` for app-level diagnostics, or pass an explicit readable project id."
+      );
+    }
+    return {
+      scopeType: "project",
+      targetId: appContext.projectId,
+      repoRoot: bindingContext.repoRoot
+    };
+  }
+  if (!appContext.readableScopes.organization) {
+    throw createAccessDeniedError(
+      "The bound app's organization is not readable to the current user.",
+      "Use `scope=app` or `scope=project` for narrower diagnostics, or pass an explicit readable organization id."
+    );
+  }
+  return {
+    scopeType: "organization",
+    targetId: appContext.organizationId,
+    repoRoot: bindingContext.repoRoot
+  };
+}
+async function getScopeEntity(api, scopeType, targetId) {
+  if (scopeType === "organization") {
+    return {
+      organization: unwrapResponseObject2(await api.getOrganization(targetId), "organization"),
+      project: null,
+      app: null
+    };
+  }
+  if (scopeType === "project") {
+    const project2 = unwrapResponseObject2(await api.getProject(targetId), "project");
+    const organizationId2 = typeof project2.organizationId === "string" ? project2.organizationId : null;
+    return {
+      organization: organizationId2 == null ? null : unwrapResponseObject2(await api.getOrganization(organizationId2), "organization"),
+      project: project2,
+      app: null
+    };
+  }
+  const app = unwrapResponseObject2(await api.getApp(targetId), "app");
+  const projectId = typeof app.projectId === "string" ? app.projectId : null;
+  const project = projectId == null ? null : unwrapResponseObject2(await api.getProject(projectId), "project");
+  const organizationId = typeof project?.organizationId === "string" ? project.organizationId : null;
+  return {
+    organization: organizationId == null ? null : unwrapResponseObject2(await api.getOrganization(organizationId), "organization"),
+    project,
+    app
+  };
+}
+function mapProjectRoleToAppRole(role) {
+  switch (role) {
+    case "owner":
+    case "maintainer":
+      return "maintainer";
+    case "editor":
+      return "editor";
+    case "viewer":
+      return "viewer";
+    default:
+      return null;
+  }
+}
+function strongestRole(...roles) {
+  if (roles.includes("owner")) return "owner";
+  if (roles.includes("maintainer")) return "maintainer";
+  if (roles.includes("editor")) return "editor";
+  if (roles.includes("viewer")) return "viewer";
+  return null;
+}
+function resolveAppAccessSource(params) {
+  if (params.directAppRole && params.inheritedProjectRole) return "both";
+  if (params.directAppRole) return "direct_app_membership";
+  if (params.inheritedProjectRole) return "project_membership";
+  return "none";
+}
+function buildEffectiveAppAccess(params) {
+  const directAppRole = params.directAppRole ?? null;
+  const inheritedProjectRole = mapProjectRoleToAppRole(params.projectRole);
+  const effectiveRole = strongestRole(directAppRole, inheritedProjectRole);
+  return {
+    effectiveRole,
+    directAppRole,
+    projectRole: params.projectRole,
+    inheritedProjectRole,
+    accessSource: resolveAppAccessSource({ directAppRole, inheritedProjectRole }),
+    canReadWorkflow: effectiveRole !== null,
+    canEdit: effectiveRole === "owner" || effectiveRole === "maintainer" || effectiveRole === "editor",
+    canManage: effectiveRole === "owner" || effectiveRole === "maintainer",
+    isOwner: directAppRole === "owner"
+  };
+}
+async function listMembersForScope(api, scopeType, targetId, params) {
+  if (scopeType === "organization") {
+    return unwrapResponseObject2(await api.listOrganizationMembers(targetId, params), "organization members");
+  }
+  if (scopeType === "project") {
+    return unwrapResponseObject2(await api.listProjectMembers(targetId, params), "project members");
+  }
+  return unwrapResponseObject2(await api.listAppMembers(targetId, params), "app members");
+}
+async function loadFirstPageSample(fetchPage) {
+  const items = await fetchPage(MEMBERSHIP_PAGE_SIZE, 0);
+  const hasMore = items.length < MEMBERSHIP_PAGE_SIZE ? false : (await fetchPage(1, MEMBERSHIP_PAGE_SIZE)).length > 0;
+  return {
+    items,
+    pageInfo: {
+      limit: MEMBERSHIP_PAGE_SIZE,
+      offset: 0,
+      hasMore
+    }
+  };
+}
+function emptyFirstPageSample() {
+  return {
+    items: [],
+    pageInfo: {
+      limit: MEMBERSHIP_PAGE_SIZE,
+      offset: 0,
+      hasMore: false
+    }
+  };
+}
+async function listInvitesForScope(api, scopeType, targetId, params) {
+  if (scopeType === "organization") {
+    return unwrapResponseObject2(
+      await api.listOrganizationInvites(targetId, params),
+      "organization invites"
+    );
+  }
+  if (scopeType === "project") {
+    return unwrapResponseObject2(
+      await api.listProjectInvites(targetId, params),
+      "project invites"
+    );
+  }
+  return unwrapResponseObject2(await api.listAppInvites(targetId, params), "app invites");
+}
+function getSelfMember(meId, members) {
+  return meId == null ? null : members.find((member) => member.userId === meId || member.user_id === meId) ?? null;
+}
+async function findPendingInviteForEmailForScope(api, scopeType, targetId, email2) {
+  if (email2 == null) return null;
+  let offset = 0;
+  for (; ; ) {
+    const invites = await listInvitesForScope(api, scopeType, targetId, {
+      limit: MEMBERSHIP_PAGE_SIZE,
+      offset
+    });
+    const match = invites.find((invite) => invite.email.toLowerCase() === email2 && invite.state === "pending") ?? null;
+    if (match) return match;
+    if (invites.length < MEMBERSHIP_PAGE_SIZE) return null;
+    offset += MEMBERSHIP_PAGE_SIZE;
+  }
+}
+async function findSelfMemberForScope(api, scopeType, targetId, meId) {
+  if (meId == null) return null;
+  let offset = 0;
+  for (; ; ) {
+    const members = scopeType === "organization" ? unwrapResponseObject2(
+      await api.listOrganizationMembers(targetId, { limit: MEMBERSHIP_PAGE_SIZE, offset }),
+      "organization members"
+    ) : scopeType === "project" ? unwrapResponseObject2(
+      await api.listProjectMembers(targetId, { limit: MEMBERSHIP_PAGE_SIZE, offset }),
+      "project members"
+    ) : unwrapResponseObject2(
+      await api.listAppMembers(targetId, { limit: MEMBERSHIP_PAGE_SIZE, offset }),
+      "app members"
+    );
+    const match = getSelfMember(meId, members);
+    if (match) return match;
+    if (members.length < MEMBERSHIP_PAGE_SIZE) return null;
+    offset += MEMBERSHIP_PAGE_SIZE;
+  }
+}
+async function listInvites(params) {
+  const api = await createApiClient2();
+  const target = await resolveScopeTarget2(api, {
+    scope: params.scope ?? "project",
+    targetId: params.targetId,
+    cwd: params.cwd
+  });
+  const pagination = normalizePagination2(params);
+  const invites = await listInvitesForScope(api, target.scopeType, target.targetId, {
+    limit: pagination.limit + 1,
+    offset: pagination.offset
+  });
+  return {
+    data: {
+      scopeType: target.scopeType,
+      targetId: target.targetId,
+      invites: invites.slice(0, pagination.limit),
+      pagination: {
+        ...pagination,
+        hasMore: invites.length > pagination.limit
+      }
+    },
+    warnings: [],
+    recommendedNextActions: invites.length > pagination.limit ? [`Pass offset=${pagination.offset + pagination.limit} to load the next page.`] : invites.length > 0 ? ["Use `remix_collab_resend_invite` or `remix_collab_revoke_invite` for lifecycle actions on a selected invite id."] : ["Use `remix_collab_invite` if you need to create a new invitation for this scope."],
+    logContext: {
+      repoRoot: target.repoRoot
+    }
+  };
+}
+async function resendInvite(params) {
+  const api = await createApiClient2();
+  const target = await resolveScopeTarget2(api, {
+    scope: params.scope ?? "project",
+    targetId: params.targetId,
+    cwd: params.cwd
+  });
+  const response = target.scopeType === "organization" ? await api.resendOrganizationInvite(target.targetId, params.inviteId, { ttlDays: params.ttlDays }) : target.scopeType === "project" ? await api.resendProjectInvite(target.targetId, params.inviteId, { ttlDays: params.ttlDays }) : await api.resendAppInvite(target.targetId, params.inviteId, { ttlDays: params.ttlDays });
+  return {
+    data: unwrapResponseObject2(response, "resent invite"),
+    warnings: [],
+    recommendedNextActions: ["Use `remix_collab_list_invites` to confirm the refreshed expiry and delivery state."],
+    logContext: {
+      repoRoot: target.repoRoot
+    }
+  };
+}
+async function revokeInvite(params) {
+  const api = await createApiClient2();
+  const target = await resolveScopeTarget2(api, {
+    scope: params.scope ?? "project",
+    targetId: params.targetId,
+    cwd: params.cwd
+  });
+  if (target.scopeType === "organization") {
+    await api.revokeOrganizationInvite(target.targetId, params.inviteId);
+  } else if (target.scopeType === "project") {
+    await api.revokeProjectInvite(target.targetId, params.inviteId);
+  } else {
+    await api.revokeAppInvite(target.targetId, params.inviteId);
+  }
+  return {
+    data: {
+      scopeType: target.scopeType,
+      targetId: target.targetId,
+      inviteId: params.inviteId,
+      revoked: true
+    },
+    warnings: [],
+    recommendedNextActions: ["Use `remix_collab_list_invites` to confirm the invite state is now `revoked`."],
+    logContext: {
+      repoRoot: target.repoRoot
+    }
+  };
+}
+async function acceptInvitation(params) {
+  const api = await createApiClient2();
+  const result = unwrapResponseObject2(await api.acceptInvitation({ token: params.token }), "accepted invitation");
+  return {
+    data: result,
+    warnings: [],
+    recommendedNextActions: result.redirectPath ? [`The invitation is accepted. Use the returned redirect metadata to continue with the newly granted Remix scope.`] : [],
+    logContext: {}
+  };
+}
+async function accessDebug(params) {
+  const api = await createApiClient2();
+  const target = await resolveScopeTarget2(api, {
+    scope: params.scope ?? "project",
+    targetId: params.targetId,
+    cwd: params.cwd
+  });
+  const bindingContext = await loadBindingContext(params.cwd);
+  const viewer = unwrapResponseObject2(await api.getMe(), "current user");
+  const viewerId = typeof viewer.id === "string" ? viewer.id : null;
+  const viewerEmail = typeof viewer.email === "string" ? viewer.email.toLowerCase() : null;
+  const warnings = [...bindingContext.binding ? [] : ["No local Remix binding was detected for the provided cwd."]];
+  let entities;
+  let appContext = null;
+  let membersPage = emptyFirstPageSample();
+  let invitesPage = emptyFirstPageSample();
+  let viewerMember = null;
+  let viewerProjectMember = null;
+  let inviteForViewerEmail = null;
+  let effectiveAppAccess = null;
+  if (target.scopeType !== "app") {
+    [entities, membersPage, invitesPage] = await Promise.all([
+      getScopeEntity(api, target.scopeType, target.targetId),
+      loadFirstPageSample((limit, offset) => listMembersForScope(api, target.scopeType, target.targetId, { limit, offset })),
+      loadFirstPageSample((limit, offset) => listInvitesForScope(api, target.scopeType, target.targetId, { limit, offset }))
+    ]);
+    viewerMember = await findSelfMemberForScope(api, target.scopeType, target.targetId, viewerId);
+    inviteForViewerEmail = await findPendingInviteForEmailForScope(api, target.scopeType, target.targetId, viewerEmail);
+  } else {
+    const [app, loadedAppContext] = await Promise.all([
+      unwrapResponseObject2(await api.getApp(target.targetId), "app"),
+      unwrapResponseObject2(await api.getAppContext(target.targetId), "app context")
+    ]);
+    appContext = loadedAppContext;
+    entities = {
+      organization: null,
+      project: null,
+      app
+    };
+    if (appContext.readableScopes.project) {
+      try {
+        entities.project = unwrapResponseObject2(await api.getProject(appContext.projectId), "project");
+      } catch (error2) {
+        if (!isBackendForbidden(error2) && !isBackendNotFound(error2)) throw error2;
+        warnings.push("The app is readable, but its project/workspace metadata is not currently readable to the current user.");
+      }
+    } else {
+      warnings.push("The app is readable, but its project/workspace is not readable to the current user.");
+    }
+    if (appContext.readableScopes.organization) {
+      try {
+        entities.organization = unwrapResponseObject2(await api.getOrganization(appContext.organizationId), "organization");
+      } catch (error2) {
+        if (!isBackendForbidden(error2) && !isBackendNotFound(error2)) throw error2;
+        warnings.push("The app is readable, but its organization metadata is not currently readable to the current user.");
+      }
+    } else {
+      warnings.push("The app's organization is not readable to the current user.");
+    }
+    effectiveAppAccess = {
+      ...buildEffectiveAppAccess({
+        directAppRole: appContext.roles.appRole,
+        projectRole: appContext.roles.projectRole
+      }),
+      accessPath: appContext.accessPath,
+      readableScopes: appContext.readableScopes,
+      visibility: appContext.visibility,
+      organizationRole: appContext.roles.organizationRole ?? null
+    };
+    if (appContext.capabilities.canReadWorkflow) {
+      membersPage = await loadFirstPageSample((limit, offset) => listMembersForScope(api, "app", target.targetId, { limit, offset }));
+      viewerMember = await findSelfMemberForScope(api, "app", target.targetId, viewerId);
+      if (appContext.readableScopes.project) {
+        viewerProjectMember = await findSelfMemberForScope(api, "project", appContext.projectId, viewerId);
+      }
+      try {
+        invitesPage = await loadFirstPageSample((limit, offset) => listInvitesForScope(api, "app", target.targetId, { limit, offset }));
+        inviteForViewerEmail = await findPendingInviteForEmailForScope(api, "app", target.targetId, viewerEmail);
+      } catch (error2) {
+        if (!isBackendForbidden(error2) && !isBackendNotFound(error2)) throw error2;
+        warnings.push("App invite data is not readable to the current user, so invite diagnostics are partial.");
+      }
+    } else {
+      warnings.push("The current viewer can read the app, but cannot read workflow-scoped app membership data.");
+    }
+  }
+  if (membersPage.pageInfo.hasMore) {
+    warnings.push("The `members` array is a first-page sample only; use the scope member list tool to inspect the remaining entries.");
+  }
+  if (invitesPage.pageInfo.hasMore) {
+    warnings.push("The `invites` array is a first-page sample only; use the invite list tool with pagination to inspect the remaining entries.");
+  }
+  return {
+    data: {
+      viewer,
+      scope: {
+        scopeType: target.scopeType,
+        targetId: target.targetId
+      },
+      entities,
+      binding: {
+        repoRoot: bindingContext.repoRoot,
+        binding: bindingContext.binding
+      },
+      access: {
+        appContext,
+        viewerMember,
+        viewerProjectMember,
+        inviteForViewerEmail,
+        effectiveAppAccess: effectiveAppAccess ?? null
+      },
+      members: membersPage.items,
+      membersPageInfo: membersPage.pageInfo,
+      invites: invitesPage.items,
+      invitesPageInfo: invitesPage.pageInfo
+    },
+    warnings,
+    recommendedNextActions: inviteForViewerEmail ? ["A pending invite exists for the current viewer email. Use `remix_collab_accept_invitation` if the viewer should accept it."] : target.scopeType === "app" ? ["Use `access.appContext` and `access.effectiveAppAccess` together to explain app-level visibility versus workspace-level visibility."] : ["Use the member and invite lists above to explain missing access, role mismatches, or stale invite state."],
+    logContext: {
+      repoRoot: target.repoRoot,
+      appId: entities.app?.id ?? bindingContext.binding?.currentAppId ?? null
+    }
+  };
+}
+function getAnnotations(access, options) {
+  if (access === "read") {
+    return {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    };
+  }
+  return {
+    readOnlyHint: false,
+    destructiveHint: access === "local_write",
+    idempotentHint: options?.idempotent ?? 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" || tool === "remix_collab_add_change_step") && normalized.message === "Change step succeeded remotely, but automatic local sync failed.") {
+  if (isFinalizeTurnLocalSyncFailure(tool, normalized)) {
     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") {
@@ -52454,9 +53284,16 @@ function deriveErrorRisks(tool, normalized) {
   }
   return [];
 }
+function isFinalizeTurnLocalSyncFailure(tool, normalized) {
+  return tool === "remix_collab_finalize_turn" && normalized.message === "Change step succeeded remotely, but automatic local sync failed.";
+}
 function buildErrorEnvelope(tool, requestId, error2) {
   const normalized = normalizeToolError(error2);
-  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."] : [];
+  const recommendedNextActions = isFinalizeTurnLocalSyncFailure(tool, normalized) ? [
+    "Run `remix_collab_status` to confirm the bound repo state before attempting recovery.",
+    "Run `remix_collab_sync_preview` next, then `remix_collab_sync_apply` with `confirm=true` if the preview looks correct.",
+    "Inspect `error.hint` for any preserved diff backup path before retrying local recovery, and do not rerun `remix_collab_finalize_turn` immediately."
+  ] : 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,
@@ -52477,7 +53314,7 @@ function registerTool(server, context, params) {
       description: params.description,
       inputSchema: params.inputSchema,
       outputSchema: params.outputSchema,
-      annotations: getAnnotations(params.access)
+      annotations: params.annotations ?? getAnnotations(params.access)
     },
     async (rawArgs) => {
       const requestId = typeof rawArgs.requestId === "string" ? rawArgs.requestId : void 0;
@@ -52557,7 +53394,11 @@ function registerCollabTools(server, context) {
     outputSchema: listSuccessSchema,
     run: async (args) => {
       const input = external_exports.object(listInputSchema).parse(args);
-      return listApps({ forked: input.forked });
+      return listApps({
+        forked: input.forked,
+        limit: input.limit,
+        offset: input.offset
+      });
     }
   });
   registerTool(server, context, {
@@ -52594,89 +53435,25 @@ function registerCollabTools(server, context) {
     }
   });
   registerTool(server, context, {
-    name: "remix_collab_add",
-    description: "Authoritative way to record completed code changes for the current bound repository, using the live worktree diff by default instead of raw git commit or push.",
-    access: "local_write",
-    inputSchema: addInputSchema,
-    outputSchema: addSuccessSchema,
-    run: async (args) => {
-      const input = external_exports.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_add_change_step",
-    description: "Alias of remix_collab_add with a more explicit name: record a code-diff change step for the current bound repository.",
+    name: "remix_collab_finalize_turn",
+    description: "Primary turn recorder for the current bound repository. Call this exactly once before the final response; it records a changed turn when the worktree has a diff, records a no-diff turn when it does not, and can accept an explicit external diff when needed.",
     access: "local_write",
-    inputSchema: addInputSchema,
-    outputSchema: addSuccessSchema,
+    inputSchema: finalizeTurnInputSchema,
+    outputSchema: finalizeTurnSuccessSchema,
+    annotations: getAnnotations("local_write", { idempotent: true }),
     run: async (args) => {
-      const input = external_exports.object(addInputSchema).parse(args);
+      const input = external_exports.object(finalizeTurnInputSchema).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);
+      if ((input.diffSource ?? "worktree") === "external" || typeof input.externalDiff === "string") {
+        assertDiffWithinLimit(context.policy, input.externalDiff ?? "");
       }
-      return addCollabStep({
+      return finalizeCollabTurn({
         cwd,
         prompt: input.prompt,
         assistantResponse: input.assistantResponse,
-        diffSource,
+        diffSource: input.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. This is for prompt/response history only and will fail if the worktree has code changes.",
-    access: "remote_write",
-    inputSchema: recordTurnInputSchema,
-    outputSchema: recordTurnSuccessSchema,
-    run: async (args) => {
-      const input = external_exports.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_record_no_diff_turn",
-    description: "Alias of remix_collab_record_turn with a more explicit name: record a prompt/response turn only when the worktree has no code diff.",
-    access: "remote_write",
-    inputSchema: recordTurnInputSchema,
-    outputSchema: recordTurnSuccessSchema,
-    run: async (args) => {
-      const input = external_exports.object(recordTurnInputSchema).parse(args);
-      const cwd = resolvePolicyCwd(context.policy, input.cwd);
-      return recordCollabTurn({
-        cwd,
-        prompt: input.prompt,
-        assistantResponse: input.assistantResponse,
+        sync: input.sync,
         allowBranchMismatch: input.allowBranchMismatch ?? false,
         idempotencyKey: input.idempotencyKey,
         agent: context.agentMetadata
@@ -52728,7 +53505,12 @@ function registerCollabTools(server, context) {
     outputSchema: mergeRequestQueueSuccessSchema,
     run: async (args) => {
       const input = external_exports.object(reviewQueueInputSchema).parse(args);
-      return reviewQueue({ status: input.status, kind: input.kind });
+      return reviewQueue({
+        status: input.status,
+        kind: input.kind,
+        limit: input.limit,
+        offset: input.offset
+      });
     }
   });
   registerTool(server, context, {
@@ -52739,7 +53521,12 @@ function registerCollabTools(server, context) {
     outputSchema: mergeRequestQueueSuccessSchema,
     run: async (args) => {
       const input = external_exports.object(myMergeRequestsInputSchema).parse(args);
-      return myMergeRequests({ status: input.status, kind: input.kind });
+      return myMergeRequests({
+        status: input.status,
+        kind: input.kind,
+        limit: input.limit,
+        offset: input.offset
+      });
     }
   });
   registerTool(server, context, {
@@ -52756,7 +53543,9 @@ function registerCollabTools(server, context) {
         appId: input.appId,
         queue: input.queue,
         status: input.status,
-        kind: input.kind
+        kind: input.kind,
+        limit: input.limit,
+        offset: input.offset
       });
     }
   });
@@ -52890,33 +53679,665 @@ function registerCollabTools(server, context) {
       return listMembers({
         cwd,
         scope: input.scope,
-        targetId: input.targetId
+        targetId: input.targetId,
+        limit: input.limit,
+        offset: input.offset
       });
     }
   });
   registerTool(server, context, {
-    name: "remix_collab_update_member_role",
-    description: "Update an organization, project, or app member role, using the current repository binding unless targetId is provided.",
+    name: "remix_collab_list_invites",
+    description: "List invitations for an organization, project, or app, using the current repository binding unless targetId is provided.",
+    access: "read",
+    inputSchema: listInvitesInputSchema,
+    outputSchema: listInvitesSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(listInvitesInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return listInvites({
+        cwd,
+        scope: input.scope ?? "project",
+        targetId: input.targetId,
+        limit: input.limit,
+        offset: input.offset
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_resend_invite",
+    description: "Resend an existing invitation for an organization, project, or app, using the current repository binding unless targetId is provided.",
     access: "remote_write",
-    inputSchema: updateMemberRoleInputSchema,
-    outputSchema: updateMemberRoleSuccessSchema,
+    inputSchema: resendInviteInputSchema,
+    outputSchema: resendInviteSuccessSchema,
     run: async (args) => {
-      const input = external_exports.object(updateMemberRoleInputSchema).parse(args);
-      const cwd = resolvePolicyCwd(context.policy, input.cwd);
-      return updateMemberRole({
+      const input = external_exports.object(resendInviteInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return resendInvite({
         cwd,
-        scope: input.scope,
+        scope: input.scope ?? "project",
         targetId: input.targetId,
-        userId: input.userId,
-        role: input.role
+        inviteId: input.inviteId,
+        ttlDays: input.ttlDays
       });
     }
   });
-}
-var genericRecordSchema2 = external_exports.record(external_exports.string(), external_exports.unknown());
+  registerTool(server, context, {
+    name: "remix_collab_revoke_invite",
+    description: "Revoke an existing invitation for an organization, project, or app, using the current repository binding unless targetId is provided.",
+    access: "remote_write",
+    inputSchema: revokeInviteInputSchema,
+    outputSchema: revokeInviteSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(revokeInviteInputSchema).parse(args);
+      assertConfirm(input.confirm, "remix_collab_revoke_invite");
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return revokeInvite({
+        cwd,
+        scope: input.scope ?? "project",
+        targetId: input.targetId,
+        inviteId: input.inviteId
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_accept_invitation",
+    description: "Accept an invitation token for the currently authenticated Remix user.",
+    access: "remote_write",
+    inputSchema: acceptInvitationInputSchema,
+    outputSchema: acceptInvitationSuccessSchema,
+    annotations: getAnnotations("remote_write", { idempotent: true }),
+    run: async (args) => {
+      const input = external_exports.object(acceptInvitationInputSchema).parse(args);
+      return acceptInvitation({
+        token: input.token
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_access_debug",
+    description: "Explain why the current user does or does not have access to an organization, project, or app by composing binding, membership, invite, and scope context.",
+    access: "read",
+    inputSchema: accessDebugInputSchema,
+    outputSchema: accessDebugSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(accessDebugInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return accessDebug({
+        cwd,
+        scope: input.scope ?? "project",
+        targetId: input.targetId
+      });
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_update_member_role",
+    description: "Update an organization, project, or app member role, using the current repository binding unless targetId is provided.",
+    access: "remote_write",
+    inputSchema: updateMemberRoleInputSchema,
+    outputSchema: updateMemberRoleSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(updateMemberRoleInputSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      return updateMemberRole({
+        cwd,
+        scope: input.scope,
+        targetId: input.targetId,
+        userId: input.userId,
+        role: input.role
+      });
+    }
+  });
+}
+var genericRecordSchema2 = external_exports.record(external_exports.string(), external_exports.unknown());
 var genericArraySchema2 = external_exports.array(genericRecordSchema2);
+var paginationSchema2 = external_exports.object({
+  limit: external_exports.number().int().positive(),
+  offset: external_exports.number().int().nonnegative(),
+  hasMore: external_exports.boolean()
+});
+var whoamiInputSchema = {
+  ...commonRequestFieldsSchema
+};
+var directoryOrganizationInputSchema = {
+  ...commonRequestFieldsSchema,
+  organizationId: external_exports.string().trim().min(1).optional()
+};
+var directoryListProjectsInputSchema = {
+  ...commonRequestFieldsSchema,
+  organizationId: external_exports.string().trim().min(1).optional(),
+  clientAppId: external_exports.string().trim().min(1).optional()
+};
+var directoryProjectInputSchema = {
+  ...commonRequestFieldsSchema,
+  projectId: external_exports.string().trim().min(1).optional()
+};
+var directoryListAppsInputSchema = {
+  ...commonRequestFieldsSchema,
+  projectId: external_exports.string().trim().min(1).optional(),
+  organizationId: external_exports.string().trim().min(1).optional(),
+  forked: external_exports.enum(["only", "exclude", "all"]).optional(),
+  limit: external_exports.number().int().positive().max(50).optional(),
+  offset: external_exports.number().int().nonnegative().optional()
+};
+var directoryAppInputSchema = {
+  ...commonRequestFieldsSchema,
+  appId: external_exports.string().trim().min(1).optional()
+};
+var whoamiDataSchema = external_exports.object({
+  id: external_exports.string().nullable(),
+  name: external_exports.string().nullable(),
+  email: external_exports.string().nullable(),
+  organizationId: external_exports.string().nullable(),
+  roles: genericRecordSchema2,
+  binding: genericRecordSchema2.nullable()
+});
+var listOrganizationsDataSchema = external_exports.object({
+  organizations: genericArraySchema2
+});
+var getOrganizationDataSchema = external_exports.object({
+  organization: genericRecordSchema2
+});
+var listProjectsDataSchema = external_exports.object({
+  organizationId: external_exports.string().nullable(),
+  projects: genericArraySchema2
+});
+var getProjectDataSchema = external_exports.object({
+  project: genericRecordSchema2
+});
+var listAppsDataSchema = external_exports.object({
+  apps: genericArraySchema2,
+  pagination: paginationSchema2,
+  filters: external_exports.object({
+    projectId: external_exports.string().nullable(),
+    organizationId: external_exports.string().nullable(),
+    forked: external_exports.enum(["only", "exclude", "all"])
+  })
+});
+var getAppDataSchema = external_exports.object({
+  app: genericRecordSchema2
+});
+var whoamiSuccessSchema = makeSuccessSchema(whoamiDataSchema);
+var listOrganizationsSuccessSchema = makeSuccessSchema(listOrganizationsDataSchema);
+var getOrganizationSuccessSchema = makeSuccessSchema(getOrganizationDataSchema);
+var listProjectsSuccessSchema = makeSuccessSchema(listProjectsDataSchema);
+var getProjectSuccessSchema = makeSuccessSchema(getProjectDataSchema);
+var listAppsSuccessSchema = makeSuccessSchema(listAppsDataSchema);
+var getAppSuccessSchema = makeSuccessSchema(getAppDataSchema);
+function normalizePagination22(params) {
+  const rawLimit = typeof params?.limit === "number" ? Math.trunc(params.limit) : 25;
+  const rawOffset = typeof params?.offset === "number" ? Math.trunc(params.offset) : 0;
+  return {
+    limit: Math.max(1, Math.min(50, rawLimit)),
+    offset: Math.max(0, rawOffset)
+  };
+}
+async function resolveOrganizationId(api, params) {
+  const explicitId = params.organizationId?.trim();
+  if (explicitId) return explicitId;
+  const bindingContext = await loadBindingContext(params.cwd);
+  if (!bindingContext.binding) {
+    throw makeNotBoundError("Organization id was not provided and the current repository is not bound to Remix.");
+  }
+  const appContext = unwrapResponseObject2(
+    await api.getAppContext(bindingContext.binding.currentAppId),
+    "bound app context"
+  );
+  if (!appContext.readableScopes.organization) {
+    throw createAccessDeniedError(
+      "The bound app's organization is not readable to the current user.",
+      "Use an explicit organization id you can access, or inspect the bound app with `remix_directory_get_app` / `remix_access_debug` for app-level context."
+    );
+  }
+  return appContext.organizationId;
+}
+async function resolveProjectId(api, params) {
+  const explicitId = params.projectId?.trim();
+  if (explicitId) {
+    const bindingContext2 = await loadBindingContext(params.cwd);
+    return { projectId: explicitId, repoRoot: bindingContext2.repoRoot };
+  }
+  const bindingContext = await loadBindingContext(params.cwd);
+  if (!bindingContext.binding) {
+    throw makeNotBoundError("Project id was not provided and the current repository is not bound to Remix.");
+  }
+  const appContext = unwrapResponseObject2(
+    await api.getAppContext(bindingContext.binding.currentAppId),
+    "bound app context"
+  );
+  if (!appContext.readableScopes.project) {
+    throw createAccessDeniedError(
+      "The bound app's project is not readable to the current user.",
+      "Use `remix_directory_get_app` or `remix_access_debug` for app-level diagnostics, or pass an explicit project id you can access."
+    );
+  }
+  return {
+    projectId: appContext.projectId,
+    repoRoot: bindingContext.repoRoot
+  };
+}
+async function resolveAppId(params) {
+  const explicitId = params.appId?.trim();
+  if (explicitId) {
+    const bindingContext2 = await loadBindingContext(params.cwd);
+    return { appId: explicitId, repoRoot: bindingContext2.repoRoot };
+  }
+  const bindingContext = await loadBindingContext(params.cwd);
+  if (!bindingContext.binding) {
+    throw makeNotBoundError("App id was not provided and the current repository is not bound to Remix.");
+  }
+  return {
+    appId: bindingContext.binding.currentAppId,
+    repoRoot: bindingContext.repoRoot
+  };
+}
+function toEffectiveAppRole(role) {
+  switch (role) {
+    case "owner":
+    case "maintainer":
+    case "editor":
+    case "viewer":
+      return role;
+    default:
+      return null;
+  }
+}
+function resolveAppAccessSource2(params) {
+  if (params.directAppRole && params.inheritedProjectRole) return "both";
+  if (params.directAppRole) return "direct_app_membership";
+  if (params.inheritedProjectRole) return "project_membership";
+  return "none";
+}
+function emptySelfRoles() {
+  return {
+    organizationRole: null,
+    projectRole: null,
+    appRole: null,
+    directAppRole: null,
+    inheritedProjectRole: null,
+    appAccessSource: "none"
+  };
+}
+function resolveSelfRolesFromAppContext(appContext) {
+  if (!appContext) return emptySelfRoles();
+  const directAppRole = toEffectiveAppRole(appContext.roles.appRole);
+  const inheritedProjectRole = toEffectiveAppRole(appContext.roles.inheritedProjectRole);
+  return {
+    organizationRole: appContext.roles.organizationRole ?? null,
+    projectRole: appContext.roles.projectRole ?? null,
+    appRole: toEffectiveAppRole(appContext.roles.effectiveAppRole),
+    directAppRole,
+    inheritedProjectRole,
+    appAccessSource: resolveAppAccessSource2({ directAppRole, inheritedProjectRole })
+  };
+}
+async function whoAmI(params) {
+  const api = await createApiClient2();
+  const bindingContext = await loadBindingContext(params.cwd);
+  const me = unwrapResponseObject2(await api.getMe(), "current user");
+  const warnings = bindingContext.binding ? [] : ["No local Remix binding was detected for the provided cwd."];
+  let boundAppContext = null;
+  let boundProject = null;
+  let boundApp = null;
+  if (bindingContext.binding) {
+    try {
+      boundAppContext = unwrapResponseObject2(
+        await api.getAppContext(bindingContext.binding.currentAppId),
+        "bound app context"
+      );
+    } catch (error2) {
+      if (!isBackendForbidden(error2) && !isBackendNotFound(error2)) throw error2;
+      warnings.push(
+        "The bound app context could not be loaded. The local binding may be stale, or the current user may no longer be able to read that app."
+      );
+    }
+    try {
+      boundApp = unwrapResponseObject2(await api.getApp(bindingContext.binding.currentAppId), "app");
+    } catch (error2) {
+      if (!isBackendForbidden(error2) && !isBackendNotFound(error2)) throw error2;
+      warnings.push("The bound app metadata could not be loaded for the current user.");
+    }
+    if (boundAppContext?.readableScopes.project) {
+      try {
+        boundProject = unwrapResponseObject2(await api.getProject(boundAppContext.projectId), "project");
+      } catch (error2) {
+        if (!isBackendForbidden(error2) && !isBackendNotFound(error2)) throw error2;
+        warnings.push("The bound app is readable, but its project metadata is not currently readable to the current user.");
+      }
+    } else if (boundAppContext) {
+      warnings.push("The bound app is readable, but its project/workspace is not readable to the current user.");
+    }
+  }
+  const roles = resolveSelfRolesFromAppContext(boundAppContext);
+  return {
+    data: {
+      id: me.id ?? null,
+      name: me.name ?? null,
+      email: me.email ?? null,
+      organizationId: me.organizationId ?? null,
+      roles,
+      binding: bindingContext.binding == null ? null : {
+        repoRoot: bindingContext.repoRoot,
+        ...bindingContext.binding,
+        projectId: boundAppContext?.projectId ?? bindingContext.binding.projectId,
+        organizationId: boundAppContext?.organizationId ?? null,
+        visibility: boundAppContext?.visibility ?? null,
+        accessPath: boundAppContext?.accessPath ?? null,
+        readableScopes: boundAppContext?.readableScopes ?? null,
+        projectName: boundProject?.name ?? null,
+        appName: boundApp?.name ?? null
+      }
+    },
+    warnings,
+    recommendedNextActions: bindingContext.binding ? ["Use `remix_access_debug` next when you need to explain repository binding or membership issues in this workspace."] : ["Use `remix_directory_list_organizations` to inspect visible tenancy context, or run `remix_collab_init` in a repository to create a local binding."],
+    logContext: {
+      repoRoot: bindingContext.repoRoot,
+      appId: bindingContext.binding?.currentAppId ?? null
+    }
+  };
+}
+async function listOrganizations() {
+  const api = await createApiClient2();
+  const organizations = unwrapResponseObject2(await api.listOrganizations(), "organizations");
+  return {
+    data: { organizations },
+    warnings: [],
+    recommendedNextActions: organizations.length ? ["Use `remix_directory_get_organization` for one organization, or `remix_directory_list_projects` to inspect projects under a chosen organization."] : [],
+    logContext: {}
+  };
+}
+async function getOrganization(params) {
+  const api = await createApiClient2();
+  const organizationId = await resolveOrganizationId(api, params);
+  const bindingContext = await loadBindingContext(params.cwd);
+  const organization = unwrapResponseObject2(await api.getOrganization(organizationId), "organization");
+  return {
+    data: { organization },
+    warnings: [],
+    recommendedNextActions: ["Use `remix_directory_list_projects` with this organization id to inspect its project directory."],
+    logContext: {
+      repoRoot: bindingContext.repoRoot
+    }
+  };
+}
+async function listProjects(params) {
+  const api = await createApiClient2();
+  const bindingContext = await loadBindingContext(params.cwd);
+  const organizationId = params.organizationId !== void 0 ? await resolveOrganizationId(api, { organizationId: params.organizationId, cwd: params.cwd }) : null;
+  const projects = unwrapResponseObject2(
+    await api.listProjects({
+      organizationId: organizationId ?? void 0,
+      clientAppId: params.clientAppId
+    }),
+    "projects"
+  );
+  return {
+    data: {
+      projects,
+      organizationId
+    },
+    warnings: [],
+    recommendedNextActions: projects.length ? ["Use `remix_directory_get_project` for one project, or `remix_directory_list_apps` to inspect apps under a chosen project or organization."] : [],
+    logContext: {
+      repoRoot: bindingContext.repoRoot,
+      appId: bindingContext.binding?.currentAppId ?? null
+    }
+  };
+}
+async function getProject(params) {
+  const api = await createApiClient2();
+  const target = await resolveProjectId(api, params);
+  const project = unwrapResponseObject2(await api.getProject(target.projectId), "project");
+  return {
+    data: { project },
+    warnings: [],
+    recommendedNextActions: ["Use `remix_directory_list_apps` with this project id to inspect apps under the project."],
+    logContext: {
+      repoRoot: target.repoRoot
+    }
+  };
+}
+async function listApps2(params) {
+  const api = await createApiClient2();
+  const bindingContext = await loadBindingContext(params.cwd);
+  const pagination = normalizePagination22(params);
+  const apps = unwrapResponseObject2(
+    await api.listApps({
+      projectId: params.projectId,
+      organizationId: params.organizationId,
+      forked: params.forked,
+      limit: pagination.limit + 1,
+      offset: pagination.offset
+    }),
+    "apps"
+  );
+  return {
+    data: {
+      apps: apps.slice(0, pagination.limit),
+      pagination: {
+        ...pagination,
+        hasMore: apps.length > pagination.limit
+      },
+      filters: {
+        projectId: params.projectId ?? null,
+        organizationId: params.organizationId ?? null,
+        forked: params.forked ?? "all"
+      }
+    },
+    warnings: [],
+    recommendedNextActions: apps.length > pagination.limit ? [`Pass offset=${pagination.offset + pagination.limit} to load the next page.`] : ["Use `remix_directory_get_app` for one app, or `remix_context_get_app_overview` for operational context on a chosen app."],
+    logContext: {
+      repoRoot: bindingContext.repoRoot,
+      appId: bindingContext.binding?.currentAppId ?? null
+    }
+  };
+}
+async function getApp(params) {
+  const api = await createApiClient2();
+  const target = await resolveAppId(params);
+  const app = unwrapResponseObject2(await api.getApp(target.appId), "app");
+  return {
+    data: { app },
+    warnings: [],
+    recommendedNextActions: ["Use `remix_context_get_app_overview` for status and capability context, or `remix_ops_list_timeline` for bounded historical activity."],
+    logContext: {
+      repoRoot: target.repoRoot,
+      appId: target.appId
+    }
+  };
+}
+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 deriveErrorRisks2(normalized) {
+  if (normalized.code === "DESTRUCTIVE_OPERATION_BLOCKED") {
+    return ["A policy guard blocked a disallowed operation."];
+  }
+  return [];
+}
+function buildErrorEnvelope2(tool, requestId, error2) {
+  const normalized = normalizeToolError(error2);
+  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 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
+        });
+        return makeSuccessResult2(envelope);
+      } catch (error2) {
+        const envelope = buildErrorEnvelope2(params.name, requestId, error2);
+        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 registerIdentityTools(server, context) {
+  registerTool2(server, context, {
+    name: "remix_identity_whoami",
+    description: "Show the authenticated Remix user and, when cwd is provided, the current local binding and any immediately derivable roles for that bound workspace.",
+    access: "read",
+    inputSchema: whoamiInputSchema,
+    outputSchema: whoamiSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(whoamiInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return whoAmI({ cwd });
+    }
+  });
+  registerTool2(server, context, {
+    name: "remix_directory_list_organizations",
+    description: "List organizations visible to the authenticated Remix user.",
+    access: "read",
+    inputSchema: whoamiInputSchema,
+    outputSchema: listOrganizationsSuccessSchema,
+    run: async () => listOrganizations()
+  });
+  registerTool2(server, context, {
+    name: "remix_directory_get_organization",
+    description: "Fetch one organization by id, or infer the bound repository's organization from cwd when possible.",
+    access: "read",
+    inputSchema: directoryOrganizationInputSchema,
+    outputSchema: getOrganizationSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(directoryOrganizationInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return getOrganization({
+        organizationId: input.organizationId,
+        cwd
+      });
+    }
+  });
+  registerTool2(server, context, {
+    name: "remix_directory_list_projects",
+    description: "List projects visible to the authenticated user, optionally narrowed to one organization or client app.",
+    access: "read",
+    inputSchema: directoryListProjectsInputSchema,
+    outputSchema: listProjectsSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(directoryListProjectsInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return listProjects({
+        organizationId: input.organizationId,
+        clientAppId: input.clientAppId,
+        cwd
+      });
+    }
+  });
+  registerTool2(server, context, {
+    name: "remix_directory_get_project",
+    description: "Fetch one project by id, or infer the bound repository's project from cwd when possible.",
+    access: "read",
+    inputSchema: directoryProjectInputSchema,
+    outputSchema: getProjectSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(directoryProjectInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return getProject({
+        projectId: input.projectId,
+        cwd
+      });
+    }
+  });
+  registerTool2(server, context, {
+    name: "remix_directory_list_apps",
+    description: "List apps visible to the authenticated user, with optional organization or project filters and built-in pagination.",
+    access: "read",
+    inputSchema: directoryListAppsInputSchema,
+    outputSchema: listAppsSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(directoryListAppsInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return listApps2({
+        projectId: input.projectId,
+        organizationId: input.organizationId,
+        forked: input.forked,
+        limit: input.limit,
+        offset: input.offset,
+        cwd
+      });
+    }
+  });
+  registerTool2(server, context, {
+    name: "remix_directory_get_app",
+    description: "Fetch one app by id, or infer the bound repository's current app from cwd when possible.",
+    access: "read",
+    inputSchema: directoryAppInputSchema,
+    outputSchema: getAppSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(directoryAppInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return getApp({
+        appId: input.appId,
+        cwd
+      });
+    }
+  });
+}
+var genericRecordSchema3 = external_exports.record(external_exports.string(), external_exports.unknown());
+var genericArraySchema3 = external_exports.array(genericRecordSchema3);
 var memoryKindSchema = external_exports.enum(["collab_turn", "change_step", "merge_request", "reconcile"]);
-var paginationSchema = external_exports.object({
+var paginationSchema3 = external_exports.object({
   limit: external_exports.number().int().nonnegative(),
   offset: external_exports.number().int().nonnegative(),
   hasMore: external_exports.boolean()
@@ -52949,14 +54370,14 @@ var changeStepDiffInputSchema = {
   appId: external_exports.string().trim().min(1).optional(),
   changeStepId: external_exports.string().trim().min(1)
 };
-var memorySummaryDataSchema = genericRecordSchema2;
+var memorySummaryDataSchema = genericRecordSchema3;
 var memorySearchDataSchema = external_exports.object({
-  items: genericArraySchema2,
-  pagination: paginationSchema
+  items: genericArraySchema3,
+  pagination: paginationSchema3
 });
 var memoryTimelineDataSchema = external_exports.object({
-  items: genericArraySchema2,
-  pagination: paginationSchema
+  items: genericArraySchema3,
+  pagination: paginationSchema3
 });
 var changeStepDiffDataSchema = external_exports.object({
   changeStepId: external_exports.string(),
@@ -53044,12 +54465,12 @@ function unwrapResponseObject22(resp, label) {
   }
   return obj;
 }
-function makeNotBoundError() {
+function makeNotBoundError2() {
   const error2 = new Error("Repository is not bound to Remix.");
   error2.hint = "Run `remix_collab_init` in this repository, or pass `appId` explicitly for a direct memory read.";
   return error2;
 }
-async function maybeFindGitRoot(cwd) {
+async function maybeFindGitRoot2(cwd) {
   try {
     return await findGitRoot(cwd);
   } catch {
@@ -53061,13 +54482,13 @@ async function resolveMemoryTarget(params) {
   if (explicitAppId) {
     return {
       appId: explicitAppId,
-      repoRoot: await maybeFindGitRoot(params.cwd)
+      repoRoot: await maybeFindGitRoot2(params.cwd)
     };
   }
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await readCollabBinding(repoRoot);
   if (!binding) {
-    throw makeNotBoundError();
+    throw makeNotBoundError2();
   }
   return {
     appId: binding.currentAppId,
@@ -53135,7 +54556,7 @@ async function getChangeStepDiff(params) {
     logContext: target
   };
 }
-function getAnnotations2(access) {
+function getAnnotations3(access) {
   return {
     readOnlyHint: access === "read",
     destructiveHint: false,
@@ -53143,7 +54564,7 @@ function getAnnotations2(access) {
     openWorldHint: false
   };
 }
-function buildSuccessEnvelope2(tool, requestId, result) {
+function buildSuccessEnvelope3(tool, requestId, result) {
   return {
     schemaVersion: SCHEMA_VERSION,
     ok: true,
@@ -53155,7 +54576,7 @@ function buildSuccessEnvelope2(tool, requestId, result) {
     recommendedNextActions: result.recommendedNextActions ?? []
   };
 }
-function buildErrorEnvelope2(tool, requestId, error2) {
+function buildErrorEnvelope3(tool, requestId, error2) {
   const normalized = normalizeToolError(error2);
   return {
     schemaVersion: SCHEMA_VERSION,
@@ -53164,17 +54585,17 @@ function buildErrorEnvelope2(tool, requestId, error2) {
     requestId: requestId ?? null,
     error: normalized,
     warnings: [],
-    risks: deriveErrorRisks2(normalized),
+    risks: deriveErrorRisks3(normalized),
     recommendedNextActions: normalized.code === "AUTH_REQUIRED" ? ["Run `remix login` or set COMERGE_ACCESS_TOKEN, then retry."] : []
   };
 }
-function deriveErrorRisks2(normalized) {
+function deriveErrorRisks3(normalized) {
   if (normalized.code === "DESTRUCTIVE_OPERATION_BLOCKED") {
     return ["A policy guard blocked a disallowed operation."];
   }
   return [];
 }
-function registerTool2(server, context, params) {
+function registerTool3(server, context, params) {
   const errorSchema = makeErrorSchema();
   server.registerTool(
     params.name,
@@ -53183,7 +54604,7 @@ function registerTool2(server, context, params) {
       description: params.description,
       inputSchema: params.inputSchema,
       outputSchema: params.outputSchema,
-      annotations: getAnnotations2(params.access)
+      annotations: getAnnotations3(params.access)
     },
     async (rawArgs) => {
       const requestId = typeof rawArgs.requestId === "string" ? rawArgs.requestId : void 0;
@@ -53191,7 +54612,7 @@ function registerTool2(server, context, params) {
       try {
         assertToolAccess(context.policy, params.access);
         const result = await params.run(rawArgs);
-        const envelope = buildSuccessEnvelope2(params.name, requestId, result);
+        const envelope = buildSuccessEnvelope3(params.name, requestId, result);
         params.outputSchema.parse(envelope);
         context.logger.log({
           level: "info",
@@ -53207,7 +54628,7 @@ function registerTool2(server, context, params) {
         });
         return makeSuccessResult2(envelope);
       } catch (error2) {
-        const envelope = buildErrorEnvelope2(params.name, requestId, error2);
+        const envelope = buildErrorEnvelope3(params.name, requestId, error2);
         errorSchema.parse(envelope);
         context.logger.log({
           level: "error",
@@ -53224,7 +54645,7 @@ function registerTool2(server, context, params) {
   );
 }
 function registerMemoryTools(server, context) {
-  registerTool2(server, context, {
+  registerTool3(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 or any raw git history lookup.",
     access: "read",
@@ -53239,7 +54660,7 @@ function registerMemoryTools(server, context) {
       });
     }
   });
-  registerTool2(server, context, {
+  registerTool3(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 for exact repository facts.",
     access: "read",
@@ -53260,7 +54681,7 @@ function registerMemoryTools(server, context) {
       });
     }
   });
-  registerTool2(server, context, {
+  registerTool3(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 before any exact-facts raw git follow-up.",
     access: "read",
@@ -53280,7 +54701,7 @@ function registerMemoryTools(server, context) {
       });
     }
   });
-  registerTool2(server, context, {
+  registerTool3(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`, keeping historical inspection inside Remix before raw git fallback.",
     access: "read",
@@ -53297,13 +54718,441 @@ function registerMemoryTools(server, context) {
     }
   });
 }
+var genericRecordSchema4 = external_exports.record(external_exports.string(), external_exports.unknown());
+var appScopedInputSchema = {
+  ...commonRequestFieldsSchema,
+  appId: external_exports.string().trim().min(1).optional()
+};
+var editQueueInputSchema = {
+  ...appScopedInputSchema,
+  limit: external_exports.number().int().positive().max(100).optional(),
+  offset: external_exports.number().int().nonnegative().optional()
+};
+var bundleInputSchema = {
+  ...appScopedInputSchema,
+  bundleId: external_exports.string().trim().min(1)
+};
+var timelineInputSchema = {
+  ...appScopedInputSchema,
+  limit: external_exports.number().int().positive().max(100).optional(),
+  cursor: external_exports.string().trim().min(1).optional()
+};
+var agentRunsInputSchema = {
+  ...appScopedInputSchema,
+  limit: external_exports.number().int().positive().max(100).optional(),
+  offset: external_exports.number().int().nonnegative().optional(),
+  status: external_exports.string().trim().min(1).optional(),
+  currentPhase: external_exports.string().trim().min(1).optional(),
+  createdAfter: external_exports.string().datetime().optional(),
+  createdBefore: external_exports.string().datetime().optional()
+};
+var agentRunInputSchema = {
+  ...appScopedInputSchema,
+  runId: external_exports.string().trim().min(1)
+};
+var agentRunEventsInputSchema = {
+  ...appScopedInputSchema,
+  runId: external_exports.string().trim().min(1),
+  limit: external_exports.number().int().positive().max(100).optional(),
+  offset: external_exports.number().int().nonnegative().optional(),
+  createdAfter: external_exports.string().datetime().optional(),
+  createdBefore: external_exports.string().datetime().optional()
+};
+var appOverviewSuccessSchema = makeSuccessSchema(genericRecordSchema4);
+var editQueueSuccessSchema = makeSuccessSchema(genericRecordSchema4);
+var bundleSuccessSchema = makeSuccessSchema(genericRecordSchema4);
+var timelineSuccessSchema = makeSuccessSchema(genericRecordSchema4);
+var agentRunsSuccessSchema = makeSuccessSchema(genericRecordSchema4);
+var agentRunSuccessSchema = makeSuccessSchema(genericRecordSchema4);
+var agentRunEventsSuccessSchema = makeSuccessSchema(genericRecordSchema4);
+var sandboxStatusSuccessSchema = makeSuccessSchema(genericRecordSchema4);
+async function resolveAppTarget(_api, params) {
+  const explicitAppId = params.appId?.trim();
+  const bindingContext = await loadBindingContext(params.cwd);
+  if (explicitAppId) {
+    return {
+      appId: explicitAppId,
+      repoRoot: bindingContext.repoRoot
+    };
+  }
+  if (!bindingContext.binding) {
+    throw makeNotBoundError("App id was not provided and the current repository is not bound to Remix.");
+  }
+  return {
+    appId: bindingContext.binding.currentAppId,
+    repoRoot: bindingContext.repoRoot
+  };
+}
+async function getAppOverview(params) {
+  const api = await createApiClient2();
+  const target = await resolveAppTarget(api, params);
+  const data = unwrapResponseObject2(await api.getAppOverview(target.appId), "app overview");
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: [
+      "Use `remix_ops_list_timeline`, `remix_ops_list_agent_runs`, `remix_ops_get_edit_queue`, or `remix_ops_get_sandbox_status` for the next operational drill-down on this app."
+    ],
+    logContext: target
+  };
+}
+async function getEditQueue(params) {
+  const api = await createApiClient2();
+  const target = await resolveAppTarget(api, params);
+  const data = unwrapResponseObject2(
+    await api.listAppEditQueue(target.appId, {
+      limit: params.limit,
+      offset: params.offset
+    }),
+    "edit queue"
+  );
+  const pageInfo = typeof data.pageInfo === "object" && data.pageInfo ? data.pageInfo : null;
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: pageInfo?.hasMore === true && typeof pageInfo.limit === "number" && typeof pageInfo.offset === "number" ? [`Pass offset=${pageInfo.offset + pageInfo.limit} to load the next edit queue page.`] : [],
+    logContext: target
+  };
+}
+async function getBundle(params) {
+  const api = await createApiClient2();
+  const target = await resolveAppTarget(api, params);
+  const data = unwrapResponseObject2(await api.getBundle(target.appId, params.bundleId), "bundle");
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: ["Use the bundle download-url client methods only when you need the actual artifact, not just metadata inspection."],
+    logContext: target
+  };
+}
+async function listTimeline(params) {
+  const api = await createApiClient2();
+  const target = await resolveAppTarget(api, params);
+  const data = unwrapResponseObject2(
+    await api.listAppTimeline(target.appId, {
+      limit: params.limit,
+      cursor: params.cursor
+    }),
+    "app timeline"
+  );
+  const pageInfo = typeof data.pageInfo === "object" && data.pageInfo ? data.pageInfo : null;
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: pageInfo?.hasMore === true && typeof pageInfo.nextCursor === "string" ? [`Pass cursor=${pageInfo.nextCursor} to load the next timeline page.`] : [],
+    logContext: target
+  };
+}
+async function listAgentRuns(params) {
+  const api = await createApiClient2();
+  const target = await resolveAppTarget(api, params);
+  const data = unwrapResponseObject2(
+    await api.listAgentRuns(target.appId, {
+      limit: params.limit,
+      offset: params.offset,
+      status: params.status,
+      currentPhase: params.currentPhase,
+      createdAfter: params.createdAfter,
+      createdBefore: params.createdBefore
+    }),
+    "agent runs"
+  );
+  const pageInfo = typeof data.pageInfo === "object" && data.pageInfo ? data.pageInfo : null;
+  const items = Array.isArray(data.items) ? data.items : [];
+  const firstRunId = items.length > 0 && items[0] && typeof items[0] === "object" && typeof items[0].id === "string" ? items[0].id : null;
+  const recommendedNextActions = [];
+  if (firstRunId) {
+    recommendedNextActions.push(
+      `Use \`remix_ops_get_agent_run\` with \`runId=${firstRunId}\` for the top listed run, then \`remix_ops_list_agent_run_events\` if you need its event stream.`
+    );
+  }
+  if (pageInfo?.hasMore === true && typeof pageInfo.limit === "number" && typeof pageInfo.offset === "number") {
+    recommendedNextActions.push(`Pass offset=${pageInfo.offset + pageInfo.limit} to load the next agent-runs page.`);
+  }
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions,
+    logContext: target
+  };
+}
+async function getAgentRun(params) {
+  const api = await createApiClient2();
+  const target = await resolveAppTarget(api, params);
+  const data = unwrapResponseObject2(await api.getAgentRun(target.appId, params.runId), "agent run");
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: [`Use \`remix_ops_list_agent_run_events\` with \`runId=${params.runId}\` for the event stream behind this run.`],
+    logContext: target
+  };
+}
+async function listAgentRunEvents(params) {
+  const api = await createApiClient2();
+  const target = await resolveAppTarget(api, params);
+  const data = unwrapResponseObject2(
+    await api.listAgentRunEvents(target.appId, params.runId, {
+      limit: params.limit,
+      offset: params.offset,
+      createdAfter: params.createdAfter,
+      createdBefore: params.createdBefore
+    }),
+    "agent run events"
+  );
+  const pageInfo = typeof data.pageInfo === "object" && data.pageInfo ? data.pageInfo : null;
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: pageInfo?.hasMore === true && typeof pageInfo.limit === "number" && typeof pageInfo.offset === "number" ? [`Pass offset=${pageInfo.offset + pageInfo.limit} to load the next event page.`] : [],
+    logContext: target
+  };
+}
+async function getSandboxStatus(params) {
+  const api = await createApiClient2();
+  const target = await resolveAppTarget(api, params);
+  const data = unwrapResponseObject2(await api.getSandboxStatus(target.appId), "sandbox status");
+  return {
+    data,
+    warnings: [],
+    recommendedNextActions: ["Use the sandbox metadata here to decide whether a resume is plausible before attempting any write-side sandbox action."],
+    logContext: target
+  };
+}
+function getAnnotations4(access) {
+  return {
+    readOnlyHint: access === "read",
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  };
+}
+function buildSuccessEnvelope4(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 deriveErrorRisks4(normalized) {
+  if (normalized.code === "DESTRUCTIVE_OPERATION_BLOCKED") {
+    return ["A policy guard blocked a disallowed operation."];
+  }
+  return [];
+}
+function buildErrorEnvelope4(tool, requestId, error2) {
+  const normalized = normalizeToolError(error2);
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    ok: false,
+    tool,
+    requestId: requestId ?? null,
+    error: normalized,
+    warnings: [],
+    risks: deriveErrorRisks4(normalized),
+    recommendedNextActions: normalized.code === "AUTH_REQUIRED" ? ["Run `remix login` or set COMERGE_ACCESS_TOKEN, then retry."] : []
+  };
+}
+function registerTool4(server, context, params) {
+  const errorSchema = makeErrorSchema();
+  server.registerTool(
+    params.name,
+    {
+      title: params.name,
+      description: params.description,
+      inputSchema: params.inputSchema,
+      outputSchema: params.outputSchema,
+      annotations: getAnnotations4(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 = buildSuccessEnvelope4(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
+        });
+        return makeSuccessResult2(envelope);
+      } catch (error2) {
+        const envelope = buildErrorEnvelope4(params.name, requestId, error2);
+        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 registerOpsTools(server, context) {
+  registerTool4(server, context, {
+    name: "remix_context_get_app_overview",
+    description: "Read the current app's overview, capabilities, and workflow readiness without mutating state.",
+    access: "read",
+    inputSchema: appScopedInputSchema,
+    outputSchema: appOverviewSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(appScopedInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return getAppOverview({
+        appId: input.appId,
+        cwd
+      });
+    }
+  });
+  registerTool4(server, context, {
+    name: "remix_ops_get_edit_queue",
+    description: "Inspect the pending edit queue for one app with bounded pagination.",
+    access: "read",
+    inputSchema: editQueueInputSchema,
+    outputSchema: editQueueSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(editQueueInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return getEditQueue({
+        appId: input.appId,
+        cwd,
+        limit: input.limit,
+        offset: input.offset
+      });
+    }
+  });
+  registerTool4(server, context, {
+    name: "remix_ops_get_bundle",
+    description: "Inspect one app bundle by id without downloading the artifact payload.",
+    access: "read",
+    inputSchema: bundleInputSchema,
+    outputSchema: bundleSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(bundleInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return getBundle({
+        appId: input.appId,
+        cwd,
+        bundleId: input.bundleId
+      });
+    }
+  });
+  registerTool4(server, context, {
+    name: "remix_ops_list_timeline",
+    description: "List bounded timeline events for one app using the backend cursor pagination model.",
+    access: "read",
+    inputSchema: timelineInputSchema,
+    outputSchema: timelineSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(timelineInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return listTimeline({
+        appId: input.appId,
+        cwd,
+        limit: input.limit,
+        cursor: input.cursor
+      });
+    }
+  });
+  registerTool4(server, context, {
+    name: "remix_ops_get_agent_run",
+    description: "Fetch one stored agent run for an app, including status, phase, and summary metadata.",
+    access: "read",
+    inputSchema: agentRunInputSchema,
+    outputSchema: agentRunSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(agentRunInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return getAgentRun({
+        appId: input.appId,
+        cwd,
+        runId: input.runId
+      });
+    }
+  });
+  registerTool4(server, context, {
+    name: "remix_ops_list_agent_runs",
+    description: "List paginated agent runs for one app so run ids can be discovered before deeper inspection.",
+    access: "read",
+    inputSchema: agentRunsInputSchema,
+    outputSchema: agentRunsSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(agentRunsInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return listAgentRuns({
+        appId: input.appId,
+        cwd,
+        limit: input.limit,
+        offset: input.offset,
+        status: input.status,
+        currentPhase: input.currentPhase,
+        createdAfter: input.createdAfter,
+        createdBefore: input.createdBefore
+      });
+    }
+  });
+  registerTool4(server, context, {
+    name: "remix_ops_list_agent_run_events",
+    description: "List paginated agent-run events for one stored run, with optional time bounds.",
+    access: "read",
+    inputSchema: agentRunEventsInputSchema,
+    outputSchema: agentRunEventsSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(agentRunEventsInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return listAgentRunEvents({
+        appId: input.appId,
+        cwd,
+        runId: input.runId,
+        limit: input.limit,
+        offset: input.offset,
+        createdAfter: input.createdAfter,
+        createdBefore: input.createdBefore
+      });
+    }
+  });
+  registerTool4(server, context, {
+    name: "remix_ops_get_sandbox_status",
+    description: "Read safe sandbox metadata and the latest migration status for one app without exposing execution handles or secrets.",
+    access: "read",
+    inputSchema: appScopedInputSchema,
+    outputSchema: sandboxStatusSuccessSchema,
+    run: async (args) => {
+      const input = external_exports.object(appScopedInputSchema).parse(args);
+      const cwd = input.cwd ? resolvePolicyCwd(context.policy, input.cwd) : void 0;
+      return getSandboxStatus({
+        appId: input.appId,
+        cwd
+      });
+    }
+  });
+}
 function createRemixMcpServer(params) {
   const context = createServerContext({ version: params.version });
   const server = new McpServer({
     name: context.serverName,
     version: context.version
   });
+  registerIdentityTools(server, context);
   registerCollabTools(server, context);
+  registerOpsTools(server, context);
   registerMemoryTools(server, context);
   return { server, context };
 }
@@ -53450,7 +55299,7 @@ async function listPendingTurnStateSummaries() {
 // package.json
 var package_default = {
   name: "@remixhq/claude-plugin",
-  version: "0.1.12",
+  version: "0.1.14",
   description: "Claude Code plugin for Remix collaboration workflows",
   homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
   license: "MIT",
@@ -53481,8 +55330,8 @@ var package_default = {
     prepack: "npm run build"
   },
   dependencies: {
-    "@remixhq/core": "^0.1.8",
-    "@remixhq/mcp": "^0.1.8"
+    "@remixhq/core": "^0.1.9",
+    "@remixhq/mcp": "^0.1.9"
   },
   devDependencies: {
     "@types/node": "^25.4.0",
@@ -53575,7 +55424,7 @@ var outputSchema = external_exports.object({
       toolName: external_exports.string().nullable(),
       repoRoot: external_exports.string().nullable(),
       message: external_exports.string().nullable(),
-      fields: external_exports.record(external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean(), external_exports.null()]))
+      fields: external_exports.record(external_exports.string(), external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean(), external_exports.null()]))
     })
   ),
   pendingStates: external_exports.array(