@comergehq/cli 0.1.9 → 0.1.10

package/dist/cli.js

@@ -2,61 +2,17 @@
 
 // src/cli.ts
 import { Command } from "commander";
-import pc10 from "picocolors";
+import pc12 from "picocolors";
 import { createRequire } from "module";
 
 // src/commands/login.ts
 import pc from "picocolors";
 
 // src/errors/cliError.ts
-var CliError = class extends Error {
-  exitCode;
-  hint;
-  constructor(message, opts) {
-    super(message);
-    this.name = "CliError";
-    this.exitCode = opts?.exitCode ?? 1;
-    this.hint = opts?.hint ?? null;
-  }
-};
+import { CliError, ComergeError } from "@comergehq/core/errors";
 
 // src/config/config.ts
-import { z } from "zod";
-var API_URL = "https://api.remix.one";
-var SUPABASE_URL = "https://xtfxwbckjpfmqubnsusu.supabase.co";
-var SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Inh0Znh3YmNranBmbXF1Ym5zdXN1Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjA2MDEyMzAsImV4cCI6MjA3NjE3NzIzMH0.dzWGAWrK4CvrmHVHzf8w7JlUZohdap0ZPnLZnABMV8s";
-function isValidUrl(value) {
-  try {
-    new URL(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var urlSchema = z.string().min(1).transform((s) => s.trim()).refine((s) => isValidUrl(s), "Invalid URL.").transform((s) => s.replace(/\/+$/, ""));
-var configSchema = z.object({
-  apiUrl: urlSchema,
-  supabaseUrl: urlSchema,
-  supabaseAnonKey: z.string().min(1)
-});
-var cachedConfig = null;
-async function resolveConfig(_opts) {
-  if (cachedConfig) return cachedConfig;
-  const cfgRaw = {
-    apiUrl: API_URL,
-    supabaseUrl: SUPABASE_URL,
-    supabaseAnonKey: SUPABASE_ANON_KEY
-  };
-  const parsedCfg = configSchema.safeParse(cfgRaw);
-  if (!parsedCfg.success) {
-    throw new CliError("Invalid CLI configuration.", {
-      exitCode: 1,
-      hint: parsedCfg.error.issues.map((i) => `${i.path.join(".") || "config"}: ${i.message}`).join("; ")
-    });
-  }
-  cachedConfig = parsedCfg.data;
-  return parsedCfg.data;
-}
+import { configSchema, resolveConfig } from "@comergehq/core/config";
 
 // src/services/oauthCallbackServer.ts
 import http from "http";
@@ -172,90 +128,13 @@ ${err?.message ?? String(err)}`
 }
 
 // src/clients/supabase.ts
-import { createClient } from "@supabase/supabase-js";
-function createInMemoryStorage() {
-  const map = /* @__PURE__ */ new Map();
-  return {
-    getItem: (k) => map.get(k) ?? null,
-    setItem: (k, v) => {
-      map.set(k, v);
-    },
-    removeItem: (k) => {
-      map.delete(k);
-    }
-  };
-}
-function createSupabaseClient(config, storage) {
-  return createClient(config.supabaseUrl, config.supabaseAnonKey, {
-    auth: {
-      flowType: "pkce",
-      persistSession: false,
-      autoRefreshToken: false,
-      detectSessionInUrl: false,
-      storage
-    },
-    global: {
-      headers: {
-        "X-Requested-By": "comerge-cli"
-      }
-    }
-  });
-}
-function toStoredSession(session) {
-  if (!session.access_token || !session.refresh_token || !session.expires_at) {
-    throw new CliError("Supabase session is missing required fields.", { exitCode: 1 });
-  }
-  return {
-    access_token: session.access_token,
-    refresh_token: session.refresh_token,
-    expires_at: session.expires_at,
-    token_type: session.token_type ?? void 0,
-    user: session.user ? { id: session.user.id, email: session.user.email ?? null } : void 0
-  };
-}
-function createSupabaseAuthHelpers(config) {
-  const storage = createInMemoryStorage();
-  const supabase = createSupabaseClient(config, storage);
-  return {
-    async startGoogleLogin(params) {
-      const { data, error } = await supabase.auth.signInWithOAuth({
-        provider: "google",
-        options: {
-          redirectTo: params.redirectTo,
-          skipBrowserRedirect: true,
-          queryParams: {
-            access_type: "offline",
-            prompt: "consent"
-          }
-        }
-      });
-      if (error) throw error;
-      if (!data?.url) throw new CliError("Supabase did not return an OAuth URL.", { exitCode: 1 });
-      return { url: data.url };
-    },
-    async exchangeCode(params) {
-      const { data, error } = await supabase.auth.exchangeCodeForSession(params.code);
-      if (error) throw error;
-      if (!data?.session) throw new CliError("Supabase did not return a session.", { exitCode: 1 });
-      return toStoredSession(data.session);
-    },
-    async refreshWithStoredSession(params) {
-      const { data, error } = await supabase.auth.setSession({
-        access_token: params.session.access_token,
-        refresh_token: params.session.refresh_token
-      });
-      if (error) throw error;
-      if (!data?.session) throw new CliError("No session returned after refresh.", { exitCode: 1 });
-      return toStoredSession(data.session);
-    }
-  };
-}
+import { createSupabaseAuthHelpers } from "@comergehq/core/auth";
 
 // src/services/sessionStore.ts
 import fs2 from "fs/promises";
 import os from "os";
 import path2 from "path";
-import { z as z2 } from "zod";
+import { storedSessionSchema } from "@comergehq/core/auth";
 
 // src/utils/fs.ts
 import fs from "fs/promises";
@@ -301,16 +180,6 @@ async function writeTextAtomic(filePath, contents) {
 }
 
 // src/services/sessionStore.ts
-var storedSessionSchema = z2.object({
-  access_token: z2.string().min(1),
-  refresh_token: z2.string().min(1),
-  expires_at: z2.number().int().positive(),
-  token_type: z2.string().min(1).optional(),
-  user: z2.object({
-    id: z2.string().min(1),
-    email: z2.string().email().optional().nullable()
-  }).optional()
-});
 var KEYTAR_SERVICE = "comerge-cli";
 var KEYTAR_ACCOUNT = "default";
 function xdgConfigHome() {
@@ -347,6 +216,11 @@ async function ensurePathPermissions(filePath) {
   } catch {
   }
 }
+async function writeSessionFileFallback(session) {
+  const fp = sessionFilePath();
+  await writeJsonAtomic(fp, session);
+  await ensurePathPermissions(fp);
+}
 async function getSession() {
   const keytar = await maybeLoadKeytar();
   if (keytar) {
@@ -380,17 +254,13 @@ async function setSession(session) {
   const keytar = await maybeLoadKeytar();
   if (keytar) {
     await keytar.setPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT, JSON.stringify(parsed.data));
-    return;
   }
-  const fp = sessionFilePath();
-  await writeJsonAtomic(fp, parsed.data);
-  await ensurePathPermissions(fp);
+  await writeSessionFileFallback(parsed.data);
 }
 async function clearSession() {
   const keytar = await maybeLoadKeytar();
   if (keytar) {
     await keytar.deletePassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT);
-    return;
   }
   const fp = sessionFilePath();
   await fs2.rm(fp, { force: true }).catch(() => {
@@ -398,110 +268,24 @@ async function clearSession() {
 }
 
 // src/clients/api.ts
-function shouldRefreshSoon(session, skewSeconds = 60) {
-  const nowSec = Math.floor(Date.now() / 1e3);
-  return session.expires_at <= nowSec + skewSeconds;
-}
-async function readJsonSafe(res) {
-  const ct = res.headers.get("content-type") ?? "";
-  if (!ct.toLowerCase().includes("application/json")) return null;
-  try {
-    return await res.json();
-  } catch {
-    return null;
-  }
-}
-async function getAuthToken(config) {
-  const envToken = process.env.COMERGE_ACCESS_TOKEN;
-  if (typeof envToken === "string" && envToken.trim().length > 0) {
-    return { token: envToken.trim(), session: null, fromEnv: true };
-  }
-  let session = await getSession();
-  if (!session) {
-    throw new CliError("Not signed in.", {
-      exitCode: 2,
-      hint: "Run `comerge login`, or set COMERGE_ACCESS_TOKEN for CI."
-    });
-  }
-  if (shouldRefreshSoon(session)) {
-    try {
-      const supabase = createSupabaseAuthHelpers(config);
-      session = await supabase.refreshWithStoredSession({ session });
-      await setSession(session);
-    } catch (err) {
-      void err;
-    }
-  }
-  return { token: session.access_token, session, fromEnv: false };
-}
+import {
+  createApiClient as createCoreApiClient,
+  createStoredSessionTokenProvider,
+  createSupabaseAuthHelpers as createSupabaseAuthHelpers2
+} from "@comergehq/core";
 function createApiClient(config, opts) {
-  const cfg = config;
-  const apiKey = (opts?.apiKey ?? "").trim();
-  const CLIENT_KEY_HEADER = "x-comerge-api-key";
-  async function request(path13, init) {
-    const { token, session, fromEnv } = await getAuthToken(cfg);
-    const url = new URL(path13, cfg.apiUrl).toString();
-    const doFetch = async (bearer) => {
-      const res2 = await fetch(url, {
-        ...init,
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/json",
-          ...init?.headers ?? {},
-          Authorization: `Bearer ${bearer}`,
-          ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
-        }
-      });
-      return res2;
-    };
-    let res = await doFetch(token);
-    if (res.status === 401 && !fromEnv && session?.refresh_token) {
-      const supabase = createSupabaseAuthHelpers(cfg);
-      const refreshed = await supabase.refreshWithStoredSession({ session });
-      await setSession(refreshed);
-      res = await doFetch(refreshed.access_token);
+  const tokenProvider = createStoredSessionTokenProvider({
+    config,
+    sessionStore: { getSession, setSession },
+    refreshStoredSession: async ({ config: refreshConfig, session }) => {
+      const supabase = createSupabaseAuthHelpers2(refreshConfig);
+      return supabase.refreshWithStoredSession({ session });
     }
-    if (!res.ok) {
-      const body = await readJsonSafe(res);
-      const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
-      throw new CliError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
-    }
-    const json = await readJsonSafe(res);
-    return json ?? null;
-  }
-  return {
-    getMe: () => request("/v1/me", { method: "GET" }),
-    listOrganizations: () => request("/v1/organizations", { method: "GET" }),
-    autoEnableDeveloper: () => request("/v1/developer/auto-enable", { method: "POST" }),
-    listClientApps: (params) => {
-      const qs = params?.orgId ? `?orgId=${encodeURIComponent(params.orgId)}` : "";
-      return request(`/v1/developer/client-apps${qs}`, { method: "GET" });
-    },
-    createClientApp: (payload) => request("/v1/developer/client-apps", { method: "POST", body: JSON.stringify(payload) }),
-    createClientAppKey: (clientAppId, payload) => request(`/v1/developer/client-apps/${encodeURIComponent(clientAppId)}/keys`, {
-      method: "POST",
-      body: JSON.stringify(payload ?? {})
-    }),
-    getApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}`, { 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) }),
-    initiateBundle: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles`, { method: "POST", body: JSON.stringify(payload) }),
-    getBundle: (appId, bundleId) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}`, { method: "GET" }),
-    getBundleDownloadUrl: (appId, bundleId, options) => request(
-      `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/download?redirect=${options?.redirect ?? false}`,
-      { method: "GET" }
-    ),
-    getBundleAssetsDownloadUrl: (appId, bundleId, options) => {
-      const qs = new URLSearchParams({
-        redirect: String(options?.redirect ?? false),
-        kind: options?.kind ?? "metro-assets"
-      });
-      return request(
-        `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/assets/download?${qs.toString()}`,
-        { method: "GET" }
-      );
-    }
-  };
+  });
+  return createCoreApiClient(config, {
+    apiKey: opts?.apiKey,
+    tokenProvider
+  });
 }
 
 // src/commands/login.ts
@@ -1478,9 +1262,11 @@ function isRetryableNetworkError(e) {
   const err = e;
   const code = typeof err?.code === "string" ? err.code : "";
   const message = typeof err?.message === "string" ? err.message : "";
-  if (code === "ERR_NETWORK" || code === "ECONNABORTED" || code === "ETIMEDOUT") return true;
+  if (code === "ERR_NETWORK" || code === "ECONNABORTED") return true;
   if (message.toLowerCase().includes("network error")) return true;
   if (message.toLowerCase().includes("timeout")) return true;
+  const status = typeof err?.response?.status === "number" ? err.response.status : void 0;
+  if (status && (status === 429 || status >= 500)) return true;
   return false;
 }
 async function withRetry(fn, opts) {
@@ -2236,6 +2022,1003 @@ function registerInitCommands(program) {
   });
 }
 
+// src/services/collab.ts
+import fs15 from "fs/promises";
+import path13 from "path";
+import pc10 from "picocolors";
+import {
+  collabAdd as collabAddCore,
+  collabRecordTurn as collabRecordTurnCore,
+  collabApprove as collabApproveCore,
+  collabInbox as collabInboxCore,
+  collabInit as collabInitCore,
+  collabInvite as collabInviteCore,
+  collabList as collabListCore,
+  collabReconcile as collabReconcileCore,
+  collabReject as collabRejectCore,
+  collabRemix as collabRemixCore,
+  collabRequestMerge as collabRequestMergeCore,
+  collabStatus as collabStatusCore,
+  collabSync as collabSyncCore,
+  collabSyncUpstream as collabSyncUpstreamCore,
+  collabView as collabViewCore
+} from "@comergehq/core/collab";
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function logMaybe(json, message) {
+  if (!json) console.log(message);
+}
+function collectResultWarnings(value) {
+  if (!value || typeof value !== "object") return [];
+  const warnings = value.warnings;
+  if (!Array.isArray(warnings)) return [];
+  return warnings.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function printResultWarnings(json, value) {
+  if (json) return;
+  for (const warning of collectResultWarnings(value)) {
+    console.log(pc10.yellow(warning));
+  }
+}
+async function createCollabApi(params) {
+  await ensureAuth({ yes: params.yes, json: params.json });
+  const cfg = await resolveConfig({ yes: params.yes });
+  return createApiClient(cfg);
+}
+async function resolveBoundCollabConfig(cwd) {
+  let current = path13.resolve(cwd);
+  while (true) {
+    const candidate = path13.join(current, ".comerge", "config.json");
+    try {
+      const raw = await fs15.readFile(candidate, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.schemaVersion === 1 && parsed.projectId && parsed.currentAppId) {
+        return {
+          schemaVersion: 1,
+          projectId: parsed.projectId,
+          currentAppId: parsed.currentAppId
+        };
+      }
+    } catch {
+    }
+    const parent = path13.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+async function resolveInviteTargetId(params) {
+  if (params.targetId?.trim()) return params.targetId.trim();
+  const binding = await resolveBoundCollabConfig(params.cwd);
+  if (!binding) {
+    throw new CliError("Repository is not bound to Comerge and no explicit target id was provided.", { exitCode: 2 });
+  }
+  if (params.scope === "project") return binding.projectId;
+  if (params.scope === "app") return binding.currentAppId;
+  const project = await params.api.getProject(binding.projectId);
+  const organizationId = project.responseObject?.organizationId ?? null;
+  if (!organizationId) {
+    throw new CliError("Could not resolve the organization for the current repository binding.", { exitCode: 2 });
+  }
+  return organizationId;
+}
+async function runInviteList(params) {
+  const response = params.scope === "organization" ? await params.api.listOrganizationInvites(params.targetId) : params.scope === "project" ? await params.api.listProjectInvites(params.targetId) : await params.api.listAppInvites(params.targetId);
+  return response.responseObject ?? response;
+}
+async function runInviteResend(params) {
+  const response = params.scope === "organization" ? await params.api.resendOrganizationInvite(params.targetId, params.inviteId, { ttlDays: params.ttlDays }) : params.scope === "project" ? await params.api.resendProjectInvite(params.targetId, params.inviteId, { ttlDays: params.ttlDays }) : await params.api.resendAppInvite(params.targetId, params.inviteId, { ttlDays: params.ttlDays });
+  return response.responseObject ?? response;
+}
+async function runInviteRevoke(params) {
+  const response = params.scope === "organization" ? await params.api.revokeOrganizationInvite(params.targetId, params.inviteId) : params.scope === "project" ? await params.api.revokeProjectInvite(params.targetId, params.inviteId) : await params.api.revokeAppInvite(params.targetId, params.inviteId);
+  return response.responseObject ?? response;
+}
+async function collabInit(params) {
+  const api = await createCollabApi(params);
+  const result = await collabInitCore({
+    api,
+    cwd: params.cwd,
+    appName: params.appName,
+    forceNew: params.forceNew
+  });
+  if (!params.json) {
+    if (result.reused) {
+      console.log(pc10.green(`Bound existing Comerge project. appId=${result.appId}`));
+    } else {
+      console.log(pc10.green(`Initialized repository in Comerge. appId=${result.appId}`));
+    }
+    printResultWarnings(params.json, result);
+  }
+  return result;
+}
+async function collabList(params) {
+  const api = await createCollabApi(params);
+  const result = await collabListCore({ api });
+  if (!params.json) {
+    for (const app of result.apps) {
+      console.log(`${app.id}  ${app.name}  status=${app.status}  project=${app.projectId}${app.forkedFromAppId ? `  forkOf=${app.forkedFromAppId}` : ""}`);
+    }
+  }
+  return result;
+}
+async function collabStatus(params) {
+  const localStatus = await collabStatusCore({
+    api: null,
+    cwd: params.cwd
+  });
+  let result = localStatus;
+  if (localStatus.repo.isGitRepo && localStatus.binding.isBound) {
+    try {
+      result = await collabStatusCore({
+        api: await createCollabApi(params),
+        cwd: params.cwd
+      });
+    } catch (err) {
+      const detail = err instanceof CliError ? [err.message, err.hint].filter(Boolean).join("\n\n") || "Remote collab checks are unavailable." : err instanceof Error ? err.message || "Remote collab checks are unavailable." : "Remote collab checks are unavailable.";
+      result = {
+        ...localStatus,
+        remote: {
+          ...localStatus.remote,
+          error: detail
+        },
+        sync: {
+          ...localStatus.sync,
+          error: detail,
+          blockedReasons: Array.from(/* @__PURE__ */ new Set([...localStatus.sync.blockedReasons, "remote_error"]))
+        },
+        reconcile: {
+          ...localStatus.reconcile,
+          error: detail,
+          blockedReasons: Array.from(/* @__PURE__ */ new Set([...localStatus.reconcile.blockedReasons, "remote_error"]))
+        },
+        recommendedAction: "no_action",
+        warnings: Array.from(new Set([...localStatus.warnings, detail].filter(Boolean)))
+      };
+    }
+  }
+  if (!params.json) {
+    printCollabStatus(result);
+  }
+  return result;
+}
+function printCollabStatus(result) {
+  if (!result.repo.isGitRepo) {
+    console.log(pc10.yellow("Repository: not inside a git repository"));
+    return;
+  }
+  console.log(pc10.bold("Repository"));
+  console.log(`${result.repo.repoRoot}`);
+  console.log(`branch=${result.repo.branch ?? "(detached)"}`);
+  console.log(`branchMismatch=${result.repo.branchMismatch ? "yes" : "no"}`);
+  console.log(`head=${result.repo.headCommitHash ?? "unknown"}`);
+  console.log(
+    `worktree=${result.repo.worktree.isClean ? "clean" : "dirty"} entries=${result.repo.worktree.entryCount} tracked=${result.repo.worktree.hasTrackedChanges ? "yes" : "no"} untracked=${result.repo.worktree.hasUntrackedFiles ? "yes" : "no"}`
+  );
+  console.log("");
+  console.log(pc10.bold("Binding"));
+  if (!result.binding.isBound) {
+    console.log("bound=no");
+  } else {
+    console.log(`bound=yes appId=${result.binding.currentAppId} projectId=${result.binding.projectId}`);
+    console.log(`remix=${result.binding.isRemix ? "yes" : "no"} upstreamAppId=${result.binding.upstreamAppId}`);
+    console.log(`preferredBranch=${result.binding.preferredBranch ?? "(unset)"} defaultBranch=${result.binding.defaultBranch ?? "(unknown)"}`);
+  }
+  console.log("");
+  console.log(pc10.bold("Remote"));
+  console.log(`appStatus=${result.remote.appStatus ?? "unknown"}`);
+  console.log(
+    `incomingOpenMergeRequests=${result.remote.incomingOpenMergeRequestCount ?? "unknown"} outgoingOpenMergeRequests=${result.remote.outgoingOpenMergeRequestCount ?? "unknown"}`
+  );
+  console.log("");
+  console.log(pc10.bold("Preflight"));
+  console.log(
+    `sync.status=${result.sync.status} canApply=${result.sync.canApply ? "yes" : "no"} blocked=${result.sync.blockedReasons.join(",") || "none"}`
+  );
+  console.log(
+    `reconcile.status=${result.reconcile.status} canApply=${result.reconcile.canApply ? "yes" : "no"} blocked=${result.reconcile.blockedReasons.join(",") || "none"}`
+  );
+  console.log("");
+  console.log(pc10.bold("Recommendation"));
+  console.log(result.recommendedAction);
+  if (result.warnings.length > 0) {
+    console.log("");
+    console.log(pc10.bold("Warnings"));
+    for (const warning of result.warnings) {
+      console.log(`- ${warning}`);
+    }
+  }
+}
+async function collabRemix(params) {
+  const api = await createCollabApi(params);
+  const result = await collabRemixCore({
+    api,
+    cwd: params.cwd,
+    outputDir: params.outputDir ?? null,
+    appId: params.appId,
+    name: params.name
+  });
+  if (!params.json) console.log(pc10.green(`Created remix. appId=${result.appId} path=${result.repoRoot}`));
+  return result;
+}
+async function collabAdd(params) {
+  if (params.promptStdin && params.diffStdin) {
+    throw new CliError("Cannot read both prompt and diff from stdin in one invocation.", {
+      exitCode: 2,
+      hint: "Use `--prompt-file` or `--diff-file` for one of the inputs."
+    });
+  }
+  let prompt = params.prompt?.trim() || "";
+  if (params.promptFile) prompt = (await fs15.readFile(path13.resolve(params.promptFile), "utf8")).trim();
+  if (params.promptStdin) prompt = (await readStdin()).trim();
+  if (!prompt) throw new CliError("Prompt is required.", { exitCode: 2 });
+  let assistantResponse = params.assistantResponse?.trim() || "";
+  if (params.assistantResponseFile) {
+    assistantResponse = (await fs15.readFile(path13.resolve(params.assistantResponseFile), "utf8")).trim();
+  }
+  let diff = null;
+  let diffSource = "worktree";
+  if (params.diffFile) {
+    diff = await fs15.readFile(path13.resolve(params.diffFile), "utf8");
+    diffSource = "external";
+  } else if (params.diffStdin) {
+    diff = await readStdin();
+    diffSource = "external";
+  }
+  const api = await createCollabApi(params);
+  const result = await collabAddCore({
+    api,
+    cwd: params.cwd,
+    prompt,
+    assistantResponse: assistantResponse || null,
+    diff,
+    diffSource,
+    sync: params.sync,
+    allowBranchMismatch: params.allowBranchMismatch,
+    idempotencyKey: params.idempotencyKey,
+    actor: {
+      type: process.env.COMERGE_AGENT_TYPE || "agent",
+      name: process.env.COMERGE_AGENT_NAME || void 0,
+      version: process.env.COMERGE_AGENT_VERSION || void 0,
+      provider: process.env.COMERGE_AGENT_PROVIDER || void 0
+    }
+  });
+  if (!params.json) {
+    console.log(pc10.green(`Recorded change step. id=${result.id}`));
+    if (params.sync !== false && diffSource === "external") {
+      console.log(
+        pc10.yellow(
+          "Skipping automatic local discard+sync because the submitted diff came from --diff-file/--diff-stdin and may not match the current worktree."
+        )
+      );
+    }
+    printResultWarnings(params.json, result);
+  }
+  return result;
+}
+async function collabRecordTurn(params) {
+  let prompt = params.prompt?.trim() || "";
+  if (params.promptFile) prompt = (await fs15.readFile(path13.resolve(params.promptFile), "utf8")).trim();
+  if (params.promptStdin) prompt = (await readStdin()).trim();
+  if (!prompt) throw new CliError("Prompt is required.", { exitCode: 2 });
+  let assistantResponse = params.assistantResponse?.trim() || "";
+  if (params.assistantResponseFile) {
+    assistantResponse = (await fs15.readFile(path13.resolve(params.assistantResponseFile), "utf8")).trim();
+  }
+  if (!assistantResponse) {
+    throw new CliError("Assistant response is required.", {
+      exitCode: 2,
+      hint: "Pass `--assistant-response` or `--assistant-response-file`."
+    });
+  }
+  const api = await createCollabApi(params);
+  const result = await collabRecordTurnCore({
+    api,
+    cwd: params.cwd,
+    prompt,
+    assistantResponse,
+    allowBranchMismatch: params.allowBranchMismatch,
+    idempotencyKey: params.idempotencyKey,
+    actor: {
+      type: process.env.COMERGE_AGENT_TYPE || "agent",
+      name: process.env.COMERGE_AGENT_NAME || void 0,
+      version: process.env.COMERGE_AGENT_VERSION || void 0,
+      provider: process.env.COMERGE_AGENT_PROVIDER || void 0
+    }
+  });
+  if (!params.json) {
+    console.log(pc10.green(`Recorded collaboration turn. id=${result.id}`));
+  }
+  return result;
+}
+async function collabSync(params) {
+  const api = await createCollabApi(params);
+  const result = await collabSyncCore({
+    api,
+    cwd: params.cwd,
+    dryRun: params.dryRun,
+    allowBranchMismatch: params.allowBranchMismatch
+  });
+  if (!params.json) {
+    if (result.status === "up_to_date") {
+      logMaybe(params.json, pc10.green(`Already in sync. head=${result.targetCommitHash}`));
+    } else if (result.dryRun) {
+      logMaybe(
+        params.json,
+        pc10.green(
+          `Fast-forward preview ready. target=${result.targetCommitHash} files=${result.stats.changedFilesCount} +${result.stats.insertions} -${result.stats.deletions}`
+        )
+      );
+    } else if (result.applied) {
+      logMaybe(
+        params.json,
+        pc10.green(
+          `Fast-forward synced local repository. branch=${result.branch} head=${result.localCommitHash} files=${result.stats.changedFilesCount}`
+        )
+      );
+    }
+    printResultWarnings(params.json, result);
+  }
+  return result;
+}
+async function collabSyncUpstream(params) {
+  const api = await createCollabApi(params);
+  const result = await collabSyncUpstreamCore({
+    api,
+    cwd: params.cwd
+  });
+  if (!params.json) {
+    if (result.status === "up-to-date") {
+      logMaybe(params.json, pc10.green("Upstream is already synced for the current remix."));
+    } else {
+      logMaybe(
+        params.json,
+        pc10.green(
+          `Upstream sync completed for remix. appId=${result.appId} mergeRequestId=${result.mergeRequestId ?? "unknown"}`
+        )
+      );
+    }
+    printResultWarnings(params.json, result);
+  }
+  return result;
+}
+async function collabReconcile(params) {
+  const api = await createCollabApi(params);
+  const result = await collabReconcileCore({
+    api,
+    cwd: params.cwd,
+    dryRun: params.dryRun,
+    allowBranchMismatch: params.allowBranchMismatch
+  });
+  if (!params.json) {
+    if (result.status === "ready_to_reconcile" && result.dryRun) {
+      logMaybe(params.json, pc10.green(`Reconcile preview ready. target=${result.targetHeadCommitHash} local=${result.localHeadCommitHash}`));
+    } else if (result.status === "succeeded" && result.applied) {
+      logMaybe(
+        params.json,
+        pc10.green(
+          `Reconciled local repository. branch=${result.branch} head=${result.localCommitHash} backup=${result.backupBranchName}`
+        )
+      );
+    } else if (result.targetCommitHash && !result.dryRun && result.applied) {
+      logMaybe(
+        params.json,
+        pc10.green(
+          `Fast-forward synced local repository. branch=${result.branch} head=${result.localCommitHash} files=${result.stats.changedFilesCount}`
+        )
+      );
+    }
+    printResultWarnings(params.json, result);
+  }
+  return result;
+}
+async function collabRequestMerge(params) {
+  const api = await createCollabApi(params);
+  const result = await collabRequestMergeCore({
+    api,
+    cwd: params.cwd
+  });
+  if (!params.json) console.log(pc10.green(`Opened merge request. id=${result.id}`));
+  return result;
+}
+async function collabInbox(params) {
+  const api = await createCollabApi(params);
+  const result = await collabInboxCore({ api });
+  if (!params.json) {
+    const items = Array.isArray(result.mergeRequests) ? result.mergeRequests : result.mergeRequests ? Object.values(result.mergeRequests).flat() : [];
+    for (const mr of items) {
+      console.log(`${mr.id}  ${mr.status}  ${mr.title ?? "(untitled)"}`);
+    }
+  }
+  return result;
+}
+async function collabView(params) {
+  const api = await createCollabApi(params);
+  const result = await collabViewCore({
+    api,
+    mrId: params.mrId
+  });
+  if (!params.json) {
+    console.log(pc10.bold(`${result.mergeRequest?.title ?? "Merge request"} (${result.mergeRequest?.status ?? "unknown"})`));
+    console.log(result.unifiedDiff ?? "");
+  }
+  return result;
+}
+async function collabApprove(params) {
+  const mode = params.remoteOnly === params.syncTargetRepo ? null : params.remoteOnly ? "remote-only" : "sync-target-repo";
+  if (!mode) {
+    throw new CliError("Choose exactly one approval mode.", {
+      exitCode: 2,
+      hint: "Pass either `--remote-only` or `--sync-target-repo`."
+    });
+  }
+  const api = await createCollabApi(params);
+  const result = await collabApproveCore({
+    api,
+    mrId: params.mrId,
+    mode,
+    cwd: params.cwd,
+    allowBranchMismatch: params.allowBranchMismatch
+  });
+  if (!params.json) {
+    if (result.mode === "remote-only") {
+      console.log(pc10.green(`Merge approval completed remotely. id=${result.mergeRequestId} status=${result.terminalStatus}`));
+    } else {
+      console.log(
+        pc10.green(
+          `Merge approval completed and synced local repo. id=${result.mergeRequestId} branch=${result.localSync?.branch} head=${result.localSync?.localCommitHash}`
+        )
+      );
+    }
+    printResultWarnings(params.json, result);
+  }
+  return result;
+}
+async function collabReject(params) {
+  const api = await createCollabApi(params);
+  const result = await collabRejectCore({
+    api,
+    mrId: params.mrId
+  });
+  if (!params.json) console.log(pc10.green(`Rejected merge request. id=${result.id}`));
+  return result;
+}
+async function collabInvite(params) {
+  const api = await createCollabApi(params);
+  const result = await collabInviteCore({
+    api,
+    cwd: params.cwd,
+    email: params.email,
+    role: params.role,
+    ttlDays: params.ttlDays,
+    scope: params.scope ?? "project",
+    targetId: params.targetId ?? null
+  });
+  if (!params.json) {
+    const inviteId = result.id ?? "unknown";
+    console.log(pc10.green(`Created ${result.scopeType} invite. id=${inviteId}`));
+  }
+  return result;
+}
+async function collabInviteList(params) {
+  const api = await createCollabApi(params);
+  const targetId = await resolveInviteTargetId({
+    api,
+    cwd: params.cwd,
+    scope: params.scope,
+    targetId: params.targetId
+  });
+  const result = await runInviteList({
+    api,
+    scope: params.scope,
+    targetId
+  });
+  if (!params.json && Array.isArray(result)) {
+    for (const invite of result) {
+      console.log(
+        `${String(invite.id ?? "")}  ${String(invite.email ?? "")}  role=${String(invite.role ?? "")}  state=${String(
+          invite.state ?? ""
+        )}`
+      );
+    }
+  }
+  return result;
+}
+async function collabInviteResend(params) {
+  const api = await createCollabApi(params);
+  const targetId = await resolveInviteTargetId({
+    api,
+    cwd: params.cwd,
+    scope: params.scope,
+    targetId: params.targetId
+  });
+  const result = await runInviteResend({
+    api,
+    scope: params.scope,
+    targetId,
+    inviteId: params.inviteId,
+    ttlDays: params.ttlDays
+  });
+  if (!params.json) console.log(pc10.green(`Resent ${params.scope} invite. id=${params.inviteId}`));
+  return result;
+}
+async function collabInviteRevoke(params) {
+  const api = await createCollabApi(params);
+  const targetId = await resolveInviteTargetId({
+    api,
+    cwd: params.cwd,
+    scope: params.scope,
+    targetId: params.targetId
+  });
+  const result = await runInviteRevoke({
+    api,
+    scope: params.scope,
+    targetId,
+    inviteId: params.inviteId
+  });
+  if (!params.json) console.log(pc10.green(`Revoked ${params.scope} invite. id=${params.inviteId}`));
+  return result;
+}
+
+// src/services/memory.ts
+import pc11 from "picocolors";
+import { readCollabBinding } from "@comergehq/core/binding";
+import { findGitRoot } from "@comergehq/core/repo";
+async function createMemoryApi(params) {
+  await ensureAuth({ yes: params.yes, json: params.json });
+  const cfg = await resolveConfig({ yes: params.yes });
+  return createApiClient(cfg);
+}
+function unwrapResponseObject3(resp, label) {
+  const obj = resp?.responseObject;
+  if (obj === void 0 || obj === null) {
+    throw new CliError(typeof resp?.message === "string" && resp.message.trim() ? resp.message : `Missing ${label} response.`, {
+      exitCode: 1
+    });
+  }
+  return obj;
+}
+async function maybeFindGitRoot(cwd) {
+  try {
+    return await findGitRoot(cwd);
+  } catch {
+    return null;
+  }
+}
+async function resolveMemoryTarget(params) {
+  const explicitAppId = params.appId?.trim();
+  if (explicitAppId) {
+    return {
+      appId: explicitAppId,
+      repoRoot: await maybeFindGitRoot(params.cwd)
+    };
+  }
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new CliError("Repository is not bound to Comerge.", {
+      exitCode: 2,
+      hint: "Run `comerge collab init` in this repository, or pass `--app-id` for a direct memory read."
+    });
+  }
+  return {
+    appId: binding.currentAppId,
+    repoRoot
+  };
+}
+function truncateText(value, maxChars = 180) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  return `${normalized.slice(0, maxChars - 3)}...`;
+}
+function compactJson(value, maxChars = 180) {
+  try {
+    return truncateText(JSON.stringify(value));
+  } catch {
+    return "[unserializable preview]";
+  }
+}
+function previewSummary(preview) {
+  const candidateKeys = ["title", "summary", "prompt", "assistantResponse", "description", "statusError", "message"];
+  for (const key of candidateKeys) {
+    const value = preview[key];
+    if (typeof value === "string" && value.trim()) {
+      return truncateText(value);
+    }
+  }
+  if (Object.keys(preview).length === 0) return null;
+  return compactJson(preview);
+}
+function lineageSummary(item) {
+  const pairs = [
+    ["thread", item.threadId],
+    ["commit", item.lineage.commitId],
+    ["mergeRequest", item.lineage.mergeRequestId],
+    ["branch", item.lineage.branch]
+  ].filter(([, value]) => typeof value === "string" && value);
+  if (pairs.length === 0) return null;
+  return pairs.map(([label, value]) => `${label}=${value}`).join(" ");
+}
+function printMemoryItems(items, opts) {
+  if (items.length === 0) {
+    console.log(pc11.dim("No memory items found."));
+    return;
+  }
+  for (const item of items) {
+    const search = "search" in item ? item.search : null;
+    const score = opts?.includeScore && search ? ` score=${search.score.toFixed(4)}` : "";
+    console.log(
+      `${pc11.bold(item.kind)}  id=${item.id}  status=${item.status ?? "unknown"}  createdAt=${item.createdAt}${score}`
+    );
+    const preview = previewSummary(item.preview);
+    if (preview) console.log(`preview=${preview}`);
+    const lineage = lineageSummary(item);
+    if (lineage) console.log(lineage);
+    if (search && search.matchedOn.length > 0) console.log(`matchedOn=${search.matchedOn.join(",")}`);
+    console.log("");
+  }
+}
+function printSummary(summary, target) {
+  console.log(pc11.bold("App"));
+  console.log(`appId=${summary.app.id}`);
+  console.log(`status=${summary.app.status ?? "unknown"} threadId=${summary.app.threadId ?? "none"}`);
+  console.log(`headCommitId=${summary.app.headCommitId ?? "none"} headCommitHash=${summary.app.headCommitHash ?? "none"}`);
+  if (target.repoRoot) console.log(`repoRoot=${target.repoRoot}`);
+  console.log("");
+  console.log(pc11.bold("Source"));
+  if (!summary.source) {
+    console.log("none");
+  } else {
+    console.log(`remoteUrl=${summary.source.remoteUrl ?? "none"}`);
+    console.log(`defaultBranch=${summary.source.defaultBranch ?? "none"} repoFingerprint=${summary.source.repoFingerprint ?? "none"}`);
+    console.log(`sourceType=${summary.source.sourceType ?? "none"} updatedAt=${summary.source.updatedAt}`);
+  }
+  console.log("");
+  console.log(pc11.bold("Counts"));
+  console.log(
+    `collabTurns=${summary.counts.collabTurnCount} changeSteps=${summary.counts.changeStepCount} mergeRequests=${summary.counts.mergeRequestCount} reconciles=${summary.counts.reconcileCount}`
+  );
+  console.log(
+    `openMergeRequests=${summary.counts.openMergeRequestCount} pendingChangeSteps=${summary.counts.pendingChangeStepCount} failedChangeSteps=${summary.counts.failedChangeStepCount}`
+  );
+  console.log("");
+  console.log(pc11.bold("Latest Reconcile"));
+  if (!summary.latestReconcile) {
+    console.log("none");
+  } else {
+    console.log(`id=${summary.latestReconcile.id} status=${summary.latestReconcile.status ?? "unknown"} createdAt=${summary.latestReconcile.createdAt}`);
+  }
+  console.log("");
+  console.log(pc11.bold("Recent"));
+  console.log(`collabTurns=${summary.recent.collabTurns.length}`);
+  console.log(`changeSteps=${summary.recent.changeSteps.length}`);
+  console.log(`mergeRequests=${summary.recent.mergeRequests.length}`);
+  console.log(`reconciles=${summary.recent.reconciles.length}`);
+}
+function printPagination(pagination) {
+  console.log(pc11.dim(`limit=${pagination.limit} offset=${pagination.offset} hasMore=${pagination.hasMore ? "yes" : "no"}`));
+}
+async function memorySummary(params) {
+  const target = await resolveMemoryTarget(params);
+  const api = await createMemoryApi(params);
+  const resp = await api.getAgentMemorySummary(target.appId);
+  const result = unwrapResponseObject3(resp, "agent memory summary");
+  if (!params.json) {
+    printSummary(result, target);
+  }
+  return result;
+}
+async function memorySearch(params) {
+  const target = await resolveMemoryTarget(params);
+  const api = await createMemoryApi(params);
+  const resp = await api.searchAgentMemory(target.appId, {
+    q: params.query,
+    kinds: params.kinds,
+    limit: params.limit,
+    offset: params.offset,
+    createdAfter: params.createdAfter ?? void 0,
+    createdBefore: params.createdBefore ?? void 0
+  });
+  const result = unwrapResponseObject3(resp, "agent memory search");
+  if (!params.json) {
+    printMemoryItems(result.items, { includeScore: true });
+    printPagination(result.pagination);
+  }
+  return result;
+}
+async function memoryTimeline(params) {
+  const target = await resolveMemoryTarget(params);
+  const api = await createMemoryApi(params);
+  const resp = await api.listAgentMemoryTimeline(target.appId, {
+    kinds: params.kinds,
+    limit: params.limit,
+    offset: params.offset,
+    createdAfter: params.createdAfter ?? void 0,
+    createdBefore: params.createdBefore ?? void 0
+  });
+  const result = unwrapResponseObject3(resp, "agent memory timeline");
+  if (!params.json) {
+    printMemoryItems(result.items);
+    printPagination(result.pagination);
+  }
+  return result;
+}
+async function memoryDiff(params) {
+  const target = await resolveMemoryTarget(params);
+  const api = await createMemoryApi(params);
+  const resp = await api.getChangeStepDiff(target.appId, params.changeStepId);
+  const result = unwrapResponseObject3(resp, "change step diff");
+  if (!params.json) {
+    console.log(pc11.bold("Change Step Diff"));
+    console.log(`changeStepId=${result.changeStepId} appId=${result.appId}`);
+    console.log(`diffSha256=${result.diffSha256} encoding=${result.encoding} contentType=${result.contentType}`);
+    console.log("");
+    process.stdout.write(result.diff.endsWith("\n") ? result.diff : `${result.diff}
+`);
+  }
+  return result;
+}
+
+// src/commands/collab.ts
+function parseInteger(value, label) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`${label} must be a non-negative integer.`);
+  }
+  return parsed;
+}
+function collectKinds(value, previous) {
+  return [...previous, String(value)];
+}
+function toKinds(values) {
+  if (!Array.isArray(values) || values.length === 0) return void 0;
+  return values.map((value) => String(value));
+}
+function parseInviteScope(value) {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "org" || normalized === "organization") return "organization";
+  if (normalized === "project") return "project";
+  if (normalized === "app") return "app";
+  throw new Error("scope must be one of: organization, project, app");
+}
+function registerCollabCommands(program) {
+  const collab = program.command("collab").description("Generic collaboration workflow for any software repository");
+  const memory = collab.command("memory").description("Inspect collaboration memory for the current bound repository or an explicit app");
+  collab.command("init").description("Import the current repository into Comerge").option("--name <name>", "Override the imported app name").option("--cwd <path>", "Working directory for repository detection").option("--force-new", "Create a new binding even if a matching project exists", false).option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await collabInit({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      appName: opts.name ? String(opts.name) : null,
+      forceNew: Boolean(opts.forceNew),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("list").description("List apps available in Comerge").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await collabList({ json: Boolean(opts.json), yes: Boolean(opts.yes || opts.nonInteractive) });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("status").description("Summarize binding, worktree, merge request, and sync/reconcile readiness").option("--cwd <path>", "Working directory for repository detection").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await collabStatus({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  memory.command("summary").description("Summarize app memory state and recent collaboration activity").option("--cwd <path>", "Working directory for repository detection").option("--app-id <id>", "Read memory for a specific app instead of the current bound repository").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await memorySummary({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      appId: opts.appId ? String(opts.appId) : null,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  memory.command("search <query...>").description("Search collaboration memory for historical context").option("--cwd <path>", "Working directory for repository detection").option("--app-id <id>", "Read memory for a specific app instead of the current bound repository").option("--kind <kind>", "Filter by memory kind", collectKinds, []).option("--limit <n>", "Maximum number of results", (value) => parseInteger(value, "limit")).option("--offset <n>", "Pagination offset", (value) => parseInteger(value, "offset")).option("--created-after <iso8601>", "Only include items created at or after this timestamp").option("--created-before <iso8601>", "Only include items created at or before this timestamp").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (query, opts) => {
+    const result = await memorySearch({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      appId: opts.appId ? String(opts.appId) : null,
+      query: Array.isArray(query) ? query.join(" ") : String(query),
+      kinds: toKinds(opts.kind),
+      limit: typeof opts.limit === "number" ? opts.limit : void 0,
+      offset: typeof opts.offset === "number" ? opts.offset : void 0,
+      createdAfter: opts.createdAfter ? String(opts.createdAfter) : null,
+      createdBefore: opts.createdBefore ? String(opts.createdBefore) : null,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  memory.command("timeline").description("List recent collaboration memory items chronologically").option("--cwd <path>", "Working directory for repository detection").option("--app-id <id>", "Read memory for a specific app instead of the current bound repository").option("--kind <kind>", "Filter by memory kind", collectKinds, []).option("--limit <n>", "Maximum number of results", (value) => parseInteger(value, "limit")).option("--offset <n>", "Pagination offset", (value) => parseInteger(value, "offset")).option("--created-after <iso8601>", "Only include items created at or after this timestamp").option("--created-before <iso8601>", "Only include items created at or before this timestamp").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await memoryTimeline({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      appId: opts.appId ? String(opts.appId) : null,
+      kinds: toKinds(opts.kind),
+      limit: typeof opts.limit === "number" ? opts.limit : void 0,
+      offset: typeof opts.offset === "number" ? opts.offset : void 0,
+      createdAfter: opts.createdAfter ? String(opts.createdAfter) : null,
+      createdBefore: opts.createdBefore ? String(opts.createdBefore) : null,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  memory.command("diff <changeStepId>").description("Fetch the full stored diff for a specific change step").option("--cwd <path>", "Working directory for repository detection").option("--app-id <id>", "Read memory for a specific app instead of the current bound repository").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (changeStepId, opts) => {
+    const result = await memoryDiff({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      appId: opts.appId ? String(opts.appId) : null,
+      changeStepId: String(changeStepId),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("remix <appId>").description("Create a remix/fork and materialize a new local checkout").option("--name <name>", "Optional name for the remix").option("--output-dir <path>", "Exact destination path for the new remix checkout").option("--cwd <path>", "Parent directory where the new remix checkout will be created when --output-dir is not provided").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (appId, opts) => {
+    const result = await collabRemix({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      outputDir: opts.outputDir ? String(opts.outputDir) : null,
+      appId: appId ? String(appId) : null,
+      name: opts.name ? String(opts.name) : null,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("add [prompt...]").description("Record one collaboration change step").option("--assistant-response <text>", "Attach the final assistant response to the change step").option("--assistant-response-file <path>", "Read the assistant response from a file").option("--prompt-file <path>", "Read the prompt from a file").option("--prompt-stdin", "Read the prompt from stdin", false).option("--diff-file <path>", "Read the unified diff from a file").option("--diff-stdin", "Read the unified diff from stdin", false).option("--no-sync", "Do not auto-discard local tracked changes and sync after a successful add").option("--allow-branch-mismatch", "Allow running from a branch that does not match the checkout's preferred Comerge branch", false).option("--cwd <path>", "Working directory for repository detection").option("--idempotency-key <key>", "Idempotency key for safe retries").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (prompt, opts) => {
+    const result = await collabAdd({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      prompt: Array.isArray(prompt) ? prompt.join(" ") : prompt ? String(prompt) : null,
+      assistantResponse: opts.assistantResponse ? String(opts.assistantResponse) : null,
+      assistantResponseFile: opts.assistantResponseFile ? String(opts.assistantResponseFile) : null,
+      promptFile: opts.promptFile ? String(opts.promptFile) : null,
+      promptStdin: Boolean(opts.promptStdin),
+      diffFile: opts.diffFile ? String(opts.diffFile) : null,
+      diffStdin: Boolean(opts.diffStdin),
+      sync: Boolean(opts.sync),
+      allowBranchMismatch: Boolean(opts.allowBranchMismatch),
+      idempotencyKey: opts.idempotencyKey ? String(opts.idempotencyKey) : null,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("record-turn [prompt...]").description("Record one no-diff collaboration turn with prompt and assistant response").option("--assistant-response <text>", "Assistant response text").option("--assistant-response-file <path>", "Read the assistant response from a file").option("--prompt-file <path>", "Read the prompt from a file").option("--prompt-stdin", "Read the prompt from stdin", false).option("--allow-branch-mismatch", "Allow running from a branch that does not match the checkout's preferred Comerge branch", false).option("--cwd <path>", "Working directory for repository detection").option("--idempotency-key <key>", "Idempotency key for safe retries").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (prompt, opts) => {
+    const result = await collabRecordTurn({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      prompt: Array.isArray(prompt) ? prompt.join(" ") : prompt ? String(prompt) : null,
+      assistantResponse: opts.assistantResponse ? String(opts.assistantResponse) : null,
+      assistantResponseFile: opts.assistantResponseFile ? String(opts.assistantResponseFile) : null,
+      promptFile: opts.promptFile ? String(opts.promptFile) : null,
+      promptStdin: Boolean(opts.promptStdin),
+      allowBranchMismatch: Boolean(opts.allowBranchMismatch),
+      idempotencyKey: opts.idempotencyKey ? String(opts.idempotencyKey) : null,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("sync").description("Sync the current local repository to the bound Comerge app state").option("--cwd <path>", "Working directory for repository detection").option("--dry-run", "Preview sync status without applying changes", false).option("--allow-branch-mismatch", "Allow running from a branch that does not match the checkout's preferred Comerge branch", false).option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await collabSync({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      dryRun: Boolean(opts.dryRun),
+      allowBranchMismatch: Boolean(opts.allowBranchMismatch),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("reconcile").description("Reconcile divergent local history against the bound Comerge app").option("--cwd <path>", "Working directory for repository detection").option("--dry-run", "Preview reconcile readiness without applying changes", false).option("--allow-branch-mismatch", "Allow running from a branch that does not match the checkout's preferred Comerge branch", false).option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await collabReconcile({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      dryRun: Boolean(opts.dryRun),
+      allowBranchMismatch: Boolean(opts.allowBranchMismatch),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("sync-upstream").description("Sync upstream changes into the current remix and update the local checkout").option("--cwd <path>", "Working directory for repository detection").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await collabSyncUpstream({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("request-merge").description("Open a merge request from the current remix to its upstream app").option("--yes", "Run non-interactively", false).option("--cwd <path>", "Working directory for repository detection").option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await collabRequestMerge({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("inbox").description("List open merge requests available for review").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await collabInbox({ json: Boolean(opts.json), yes: Boolean(opts.yes || opts.nonInteractive) });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("view <mrId>").description("View merge request prompts and diffs").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (mrId, opts) => {
+    const result = await collabView({
+      mrId: String(mrId),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("approve <mrId>").description("Approve a merge request").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--remote-only", "Approve remotely and wait for merge completion without touching the local repo", false).option("--sync-target-repo", "Approve, wait for merge completion, and sync the current target repo checkout", false).option("--allow-branch-mismatch", "Allow syncing the target repo from a branch that does not match the checkout's preferred Comerge branch", false).option("--json", "Output JSON", false).action(async (mrId, opts) => {
+    const result = await collabApprove({
+      mrId: String(mrId),
+      cwd: process.cwd(),
+      remoteOnly: Boolean(opts.remoteOnly),
+      syncTargetRepo: Boolean(opts.syncTargetRepo),
+      allowBranchMismatch: Boolean(opts.allowBranchMismatch),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("reject <mrId>").description("Reject a merge request").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (mrId, opts) => {
+    const result = await collabReject({
+      mrId: String(mrId),
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  collab.command("invite <email>").description("Invite a collaborator to an organization, project, or app").option("--scope <scope>", "Invitation scope (organization|project|app)", parseInviteScope, "project").option("--target-id <id>", "Explicit organization/project/app id instead of using the current repository binding").option("--role <role>", "Role for the invite").option("--ttl-days <days>", "Invitation lifetime in days", (value) => parseInteger(value, "ttl-days")).option("--cwd <path>", "Working directory for repository detection").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (email, opts) => {
+    const result = await collabInvite({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      email: String(email),
+      role: opts.role ? String(opts.role) : null,
+      ttlDays: typeof opts.ttlDays === "number" ? opts.ttlDays : void 0,
+      scope: parseInviteScope(String(opts.scope ?? "project")),
+      targetId: opts.targetId ? String(opts.targetId) : null,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  const inviteAdmin = collab.command("invites").description("List, resend, or revoke invitations");
+  inviteAdmin.command("list").description("List invitations for an organization, project, or app").option("--scope <scope>", "Invitation scope (organization|project|app)", parseInviteScope, "project").option("--target-id <id>", "Explicit organization/project/app id instead of using the current repository binding").option("--cwd <path>", "Working directory for repository detection").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const result = await collabInviteList({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      scope: parseInviteScope(String(opts.scope ?? "project")),
+      targetId: opts.targetId ? String(opts.targetId) : null,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  inviteAdmin.command("resend <inviteId>").description("Resend an invitation").option("--scope <scope>", "Invitation scope (organization|project|app)", parseInviteScope, "project").option("--target-id <id>", "Explicit organization/project/app id instead of using the current repository binding").option("--ttl-days <days>", "Invitation lifetime in days", (value) => parseInteger(value, "ttl-days")).option("--cwd <path>", "Working directory for repository detection").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (inviteId, opts) => {
+    const result = await collabInviteResend({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      scope: parseInviteScope(String(opts.scope ?? "project")),
+      inviteId: String(inviteId),
+      targetId: opts.targetId ? String(opts.targetId) : null,
+      ttlDays: typeof opts.ttlDays === "number" ? opts.ttlDays : void 0,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+  inviteAdmin.command("revoke <inviteId>").description("Revoke an invitation").option("--scope <scope>", "Invitation scope (organization|project|app)", parseInviteScope, "project").option("--target-id <id>", "Explicit organization/project/app id instead of using the current repository binding").option("--cwd <path>", "Working directory for repository detection").option("--yes", "Run non-interactively", false).option("--non-interactive", "Run non-interactively", false).option("--json", "Output JSON", false).action(async (inviteId, opts) => {
+    const result = await collabInviteRevoke({
+      cwd: opts.cwd ? String(opts.cwd) : process.cwd(),
+      scope: parseInviteScope(String(opts.scope ?? "project")),
+      inviteId: String(inviteId),
+      targetId: opts.targetId ? String(opts.targetId) : null,
+      json: Boolean(opts.json),
+      yes: Boolean(opts.yes || opts.nonInteractive)
+    });
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+  });
+}
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -2246,20 +3029,21 @@ async function main(argv) {
   registerWhoamiCommand(program);
   registerLogoutCommand(program);
   registerInitCommands(program);
+  registerCollabCommands(program);
   program.configureOutput({
-    outputError: (str, write) => write(pc10.red(str))
+    outputError: (str, write) => write(pc12.red(str))
   });
   try {
     await program.parseAsync(argv);
   } catch (err) {
     const e = err;
     if (e instanceof CliError) {
-      console.error(pc10.red(`Error: ${e.message}`));
-      if (e.hint) console.error(pc10.dim(e.hint));
+      console.error(pc12.red(`Error: ${e.message}`));
+      if (e.hint) console.error(pc12.dim(e.hint));
       process.exitCode = e.exitCode;
       return;
     }
-    console.error(pc10.red(`Unexpected error: ${e?.message ?? String(e)}`));
+    console.error(pc12.red(`Unexpected error: ${e?.message ?? String(e)}`));
     process.exitCode = 1;
   }
 }