ai-browser-bridge 0.4.0 → 0.5.1

package/dist/bridge.js

@@ -257,9 +257,9 @@ var ProviderConfig = Config.string("BRIDGE_PROVIDER").pipe(
 
 // src/features/terminal/cliOperations.ts
 import { execFile as execFile3 } from "child_process";
-import { mkdir as mkdir7, readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
-import { basename as basename3, dirname as dirname3, extname as extname2, isAbsolute as isAbsolute2, join as join11, relative as relative3, resolve as resolve7 } from "path";
-import { Schema as Schema8 } from "effect";
+import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import { basename as basename3, dirname as dirname4, extname as extname2, isAbsolute as isAbsolute3, join as join12, relative as relative3, resolve as resolve8 } from "path";
+import { Schema as Schema9 } from "effect";
 import { render } from "ink";
 import React from "react";
 
@@ -289,89 +289,6 @@ var isSameChatGptConversation = (pageUrl, targetIdOrUrl) => {
   return targetId === currentId;
 };
 
-// src/features/providers/chatgpt/chatgptPage.ts
-import { mkdir, readFile, stat, writeFile } from "fs/promises";
-import { homedir } from "os";
-import path from "path";
-
-// src/features/providers/providerErrors.ts
-import { Data } from "effect";
-var UnknownProviderError = class extends Data.TaggedError("UnknownProviderError") {
-  get message() {
-    return `Unknown provider "${this.value}". Valid providers: ${this.validProviders.join(", ")}.`;
-  }
-};
-var GuestSessionError = class extends Data.TaggedError("GuestSessionError") {
-  get message() {
-    return `${this.providerId} is not signed in: ${this.reason}`;
-  }
-};
-
-// src/features/providers/renderStallWatchdog.ts
-var stallReloadWatchdogFor = (options = {}) => {
-  const stallMs = options.stallMs === void 0 ? RENDER_STALL_RELOAD_MS : options.stallMs;
-  const maxReloads = options.maxReloads === void 0 ? MAX_STALL_RELOADS : options.maxReloads;
-  const now = options.now === void 0 ? Date.now : options.now;
-  let lastProgressAt = now();
-  let reloadsUsed = 0;
-  return {
-    noteProgress() {
-      lastProgressAt = now();
-    },
-    async maybeReload(page) {
-      if (reloadsUsed >= maxReloads) return false;
-      if (now() - lastProgressAt < stallMs) return false;
-      try {
-        await page.reload({ waitUntil: "domcontentloaded" });
-      } catch {
-      }
-      if (options.waitAfterReload !== void 0) {
-        try {
-          await options.waitAfterReload(page);
-        } catch {
-        }
-      }
-      reloadsUsed += 1;
-      lastProgressAt = now();
-      if (options.onReload !== void 0) {
-        options.onReload(reloadsUsed);
-      }
-      return true;
-    }
-  };
-};
-
-// src/features/providers/streamingGuard.ts
-var IDLE_POLL_MS = 300;
-var IDLE_CONFIRMATIONS = 2;
-var DEFAULT_IDLE_TIMEOUT_MS = 3e5;
-var isResponseGenerating = async (page, stopSelector) => {
-  if (stopSelector.length === 0) return false;
-  try {
-    return await page.locator(stopSelector).first().isVisible();
-  } catch {
-    return false;
-  }
-};
-var waitForResponseIdle = async (page, stopSelector, timeoutMs = DEFAULT_IDLE_TIMEOUT_MS) => {
-  if (stopSelector.length === 0) return;
-  const startedAt = Date.now();
-  let clearStreak = 0;
-  while (Date.now() - startedAt < timeoutMs) {
-    if (await isResponseGenerating(page, stopSelector)) {
-      clearStreak = 0;
-    } else {
-      clearStreak += 1;
-      if (clearStreak >= IDLE_CONFIRMATIONS) return;
-    }
-    try {
-      await page.waitForTimeout(IDLE_POLL_MS);
-    } catch {
-    }
-  }
-  throw new Error("Timed out waiting for the current response to finish before sending.");
-};
-
 // src/features/providers/chatgpt/chatgptConversationSearch.ts
 var CHATGPT_SEARCH = {
   trigger: 'button[aria-label="Search"]',
@@ -420,19 +337,40 @@ var openChatSearch = async (page) => {
   return dialog;
 };
 var searchEntriesIn = async (dialog) => {
-  const links = await dialog.locator(CHATGPT_SEARCH.resultLink).all();
-  const entries = [];
-  for (const link of links) {
-    const href = await link.getAttribute("href");
-    if (href === null) continue;
-    const title = await link.locator(CHATGPT_SEARCH.resultTitle).first().innerText();
-    entries.push({ href, title });
-  }
-  return entries;
+  return dialog.locator(CHATGPT_SEARCH.resultLink).evaluateAll(
+    (links, titleSelector) => links.flatMap((link) => {
+      const href = link.getAttribute("href");
+      if (href === null) return [];
+      const titleNode = link.querySelector(titleSelector);
+      const fallbackTitle = link instanceof HTMLElement ? link.innerText.split("\n")[0] : "";
+      let rawTitle = fallbackTitle;
+      if (titleNode !== null && titleNode.textContent !== null) rawTitle = titleNode.textContent;
+      if (rawTitle === void 0) rawTitle = "";
+      const title = rawTitle.trim();
+      return title ? [{ href, title }] : [];
+    }),
+    CHATGPT_SEARCH.resultTitle
+  );
 };
 var searchEntriesSignature = async (dialog) => {
   return JSON.stringify(await searchEntriesIn(dialog));
 };
+var acknowledgeChatGptHistoryRateLimit = async (page) => {
+  if (page.isClosed()) return false;
+  const modal = page.locator(CHATGPT_SEARCH.rateLimit).first();
+  if (!await modal.isVisible()) return false;
+  const acknowledge = modal.getByRole("button", { name: "Got it", exact: true }).first();
+  if (await acknowledge.isVisible()) {
+    await acknowledge.evaluate((button) => {
+      if (button instanceof HTMLElement) button.click();
+    });
+  }
+  try {
+    await modal.waitFor({ state: "hidden", timeout: 3e3 });
+  } catch {
+  }
+  return true;
+};
 var assertSearchAvailable = async (page) => {
   if (!await page.locator(CHATGPT_SEARCH.rateLimit).isVisible()) return;
   throw new Error(
@@ -528,6 +466,89 @@ var searchChatGptConversations = async (page, input) => {
   }
 };
 
+// src/features/providers/chatgpt/chatgptPage.ts
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+
+// src/features/providers/providerErrors.ts
+import { Data } from "effect";
+var UnknownProviderError = class extends Data.TaggedError("UnknownProviderError") {
+  get message() {
+    return `Unknown provider "${this.value}". Valid providers: ${this.validProviders.join(", ")}.`;
+  }
+};
+var GuestSessionError = class extends Data.TaggedError("GuestSessionError") {
+  get message() {
+    return `${this.providerId} is not signed in: ${this.reason}`;
+  }
+};
+
+// src/features/providers/renderStallWatchdog.ts
+var stallReloadWatchdogFor = (options = {}) => {
+  const stallMs = options.stallMs === void 0 ? RENDER_STALL_RELOAD_MS : options.stallMs;
+  const maxReloads = options.maxReloads === void 0 ? MAX_STALL_RELOADS : options.maxReloads;
+  const now = options.now === void 0 ? Date.now : options.now;
+  let lastProgressAt = now();
+  let reloadsUsed = 0;
+  return {
+    noteProgress() {
+      lastProgressAt = now();
+    },
+    async maybeReload(page) {
+      if (reloadsUsed >= maxReloads) return false;
+      if (now() - lastProgressAt < stallMs) return false;
+      try {
+        await page.reload({ waitUntil: "domcontentloaded" });
+      } catch {
+      }
+      if (options.waitAfterReload !== void 0) {
+        try {
+          await options.waitAfterReload(page);
+        } catch {
+        }
+      }
+      reloadsUsed += 1;
+      lastProgressAt = now();
+      if (options.onReload !== void 0) {
+        options.onReload(reloadsUsed);
+      }
+      return true;
+    }
+  };
+};
+
+// src/features/providers/streamingGuard.ts
+var IDLE_POLL_MS = 300;
+var IDLE_CONFIRMATIONS = 2;
+var DEFAULT_IDLE_TIMEOUT_MS = 3e5;
+var isResponseGenerating = async (page, stopSelector) => {
+  if (stopSelector.length === 0) return false;
+  try {
+    return await page.locator(stopSelector).first().isVisible();
+  } catch {
+    return false;
+  }
+};
+var waitForResponseIdle = async (page, stopSelector, timeoutMs = DEFAULT_IDLE_TIMEOUT_MS) => {
+  if (stopSelector.length === 0) return;
+  const startedAt = Date.now();
+  let clearStreak = 0;
+  while (Date.now() - startedAt < timeoutMs) {
+    if (await isResponseGenerating(page, stopSelector)) {
+      clearStreak = 0;
+    } else {
+      clearStreak += 1;
+      if (clearStreak >= IDLE_CONFIRMATIONS) return;
+    }
+    try {
+      await page.waitForTimeout(IDLE_POLL_MS);
+    } catch {
+    }
+  }
+  throw new Error("Timed out waiting for the current response to finish before sending.");
+};
+
 // src/features/providers/chatgpt/chatgptPage.ts
 var EDIT_BUTTON_SELECTORS = [
   'button[data-testid="edit-turn-button"]',
@@ -1835,8 +1856,8 @@ var deleteConnectorAppBySummary = async (ctx) => {
       if (entry.name !== ctx.target.name) continue;
       await entry.button.click({ timeout: 3e3, force: true });
       await ctx.page.waitForTimeout(1e3);
-      const open = await readOpenConnectorSummary({ page: ctx.page });
-      if (!open || !sameConnectorApp({ a: open, b: ctx.target })) continue;
+      const open2 = await readOpenConnectorSummary({ page: ctx.page });
+      if (!open2 || !sameConnectorApp({ a: open2, b: ctx.target })) continue;
       return deleteOpenConnectorIfPresent({ page: ctx.page });
     }
   }
@@ -2414,19 +2435,122 @@ var newConversation = async (page) => {
   await page.goto("https://chatgpt.com/");
   await page.waitForSelector("#prompt-textarea, [contenteditable]", { timeout: 3e4 });
 };
+var parseChatGptSidebarConversationLink = (link, options = {}) => {
+  const href = link.href === null ? "" : link.href.trim();
+  const title = link.title.trim();
+  if (!href || !title) return null;
+  const sidebarLabel = link.ariaLabel === null ? "" : link.ariaLabel;
+  const outsideLooseChats = href.includes("/g/") || /\bchat in project\b/i.test(sidebarLabel) || /\bpinned conversation\b/i.test(sidebarLabel);
+  if (options.orphans && outsideLooseChats) return null;
+  const parsedUrl = new URL(href, "https://chatgpt.com");
+  const pathParts = parsedUrl.pathname.split("/").filter(Boolean);
+  const lastPathPart = pathParts.pop();
+  const id2 = lastPathPart === void 0 ? "" : lastPathPart;
+  if (!id2) return null;
+  return { id: id2, title, url: parsedUrl.toString() };
+};
 var parseSidebarLink = async (ctx) => {
   const href = await ctx.link.getAttribute("href");
   const title = await ctx.link.innerText();
-  if (!href || !title) return null;
-  const pathSegment = href.split("/").pop();
-  const id2 = pathSegment === void 0 ? "" : pathSegment;
-  return { id: id2, title: title.trim(), url: `https://chatgpt.com${href}` };
+  const ariaLabel = await ctx.link.getAttribute("aria-label");
+  return parseChatGptSidebarConversationLink({ href, title, ariaLabel }, { orphans: ctx.orphans });
+};
+var scanOrphanSidebarConversations = async (page) => {
+  await page.locator(`${SELECTORS.sidebarConversation}:not([aria-label*="pinned conversation" i])`).first().waitFor({ state: "attached", timeout: 1e4 }).catch(() => {
+  });
+  const sidebar = page.locator('nav[aria-label="Chat history"]').first();
+  if (await sidebar.count() === 0) return [];
+  const collectScrollAndReadState = (element) => {
+    const scan = element.__bridgeOrphanScan;
+    if (!scan) throw new Error("ChatGPT sidebar scan was not initialized.");
+    const sidebarRect = element.getBoundingClientRect();
+    for (const link of element.querySelectorAll('a[href^="/c/"]')) {
+      const linkRect = link.getBoundingClientRect();
+      if (linkRect.bottom < sidebarRect.top || linkRect.top > sidebarRect.bottom) continue;
+      const href = link.getAttribute("href");
+      if (!href) continue;
+      let title = link.innerText;
+      if (!title) {
+        const textContent = link.textContent;
+        title = textContent === null ? "" : textContent;
+      }
+      scan.links.set(href, {
+        href,
+        title,
+        ariaLabel: link.getAttribute("aria-label")
+      });
+    }
+    const state = {
+      size: scan.links.size,
+      scrollHeight: element.scrollHeight,
+      atBottom: element.scrollTop + element.clientHeight >= element.scrollHeight - 4
+    };
+    const step = Math.max(Math.floor(element.clientHeight * 0.8), 320);
+    element.scrollTop = Math.min(element.scrollTop + step, element.scrollHeight);
+    return state;
+  };
+  await sidebar.evaluate((element) => {
+    element.__bridgeOrphanScan = {
+      originalScrollTop: element.scrollTop,
+      links: /* @__PURE__ */ new Map()
+    };
+    element.scrollTop = 0;
+  });
+  await new Promise((resolve9) => setTimeout(resolve9, 250));
+  let stableBottomPasses = 0;
+  let links = [];
+  try {
+    let reachedStableBottom = false;
+    let before = await sidebar.evaluate(collectScrollAndReadState);
+    for (let pass = 0; pass < 240; pass += 1) {
+      await new Promise((resolve9) => setTimeout(resolve9, 300));
+      const after = await sidebar.evaluate(collectScrollAndReadState);
+      const unchanged = after.atBottom && after.size === before.size && after.scrollHeight <= before.scrollHeight + 1;
+      stableBottomPasses = unchanged ? stableBottomPasses + 1 : 0;
+      if (stableBottomPasses >= 8) {
+        reachedStableBottom = true;
+        break;
+      }
+      before = after;
+    }
+    if (!reachedStableBottom) {
+      throw new Error("ChatGPT sidebar scan did not reach the end of the chat history.");
+    }
+    links = await sidebar.evaluate((element) => {
+      const scan = element.__bridgeOrphanScan;
+      return scan ? [...scan.links.values()] : [];
+    });
+  } finally {
+    await sidebar.evaluate((element) => {
+      const scan = element.__bridgeOrphanScan;
+      if (scan) element.scrollTop = scan.originalScrollTop;
+      delete element.__bridgeOrphanScan;
+    }).catch(() => {
+    });
+  }
+  const conversations = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const conversation = parseChatGptSidebarConversationLink(link, { orphans: true });
+    if (conversation) conversations.set(conversation.id, conversation);
+  }
+  return [...conversations.values()];
 };
-var readSidebarConversations = async (page) => {
+var readAllOrphanSidebarConversations = async (page) => {
+  const scanPage = await page.context().newPage();
+  try {
+    await scanPage.goto("https://chatgpt.com/", { waitUntil: "domcontentloaded" });
+    return await scanOrphanSidebarConversations(scanPage);
+  } finally {
+    await scanPage.close().catch(() => {
+    });
+  }
+};
+var readSidebarConversations = async (page, options = {}) => {
+  if (options.orphans) return readAllOrphanSidebarConversations(page);
   const links = await page.locator(SELECTORS.sidebarConversation).all();
   const conversations = [];
   for (const link of links) {
-    const entry = await parseSidebarLink({ link });
+    const entry = await parseSidebarLink({ link, orphans: Boolean(options.orphans) });
     if (entry) conversations.push(entry);
   }
   return conversations;
@@ -3076,10 +3200,20 @@ var WORKSPACE = {
   newProjectButton: 'button[aria-label="New project"]',
   projectNameInput: 'input[name="projectName"]',
   projectFolderIcon: '[data-testid="project-folder-icon"]',
-  chatLink: 'nav a[href^="/c/"]',
+  projectDirectoryRow: '[data-testid="project-directory-scroll-root"] [role="row"]:has([role="gridcell"])',
+  projectConversationLink: 'main a[href*="/c/"]',
+  chatLink: 'nav a[href*="/c/"]',
   activeConversationMenu: '[data-testid="conversation-options-button"]',
   menuItem: '[role="menuitem"]'
 };
+var projectNameFromDirectoryRowText = (text) => {
+  const [name, detail] = text.split("\n");
+  if (name === void 0) return null;
+  const projectName = name.trim();
+  if (!projectName) return null;
+  if (projectName === "Name" && detail !== void 0 && detail.trim() === "Modified") return null;
+  return projectName;
+};
 var PROJECT_ROWS_SOURCE = String.raw`
 (() => {
   const clean = (s) => (s || "").replace(/\s+/g, " ").trim();
@@ -3121,13 +3255,146 @@ var chatGptProjectRemovalState = (namedRemoval, genericRemoval) => {
   if (genericRemoval) return "current-project-unknown";
   return "not-filed";
 };
+var chatGptProjectNameFromConversationAriaLabel = (label) => {
+  const marker = ", chat in project ";
+  const markerIndex = label.lastIndexOf(marker);
+  if (markerIndex < 0) return null;
+  const project = label.slice(markerIndex + marker.length).trim();
+  if (!project) return null;
+  return project;
+};
 var listProjects = async (page) => {
   await ensureOnProjectsPage(page);
+  const directoryRows = page.locator(WORKSPACE.projectDirectoryRow);
+  await directoryRows.first().waitFor({ timeout: 5e3 }).catch(() => {
+  });
+  const directoryNames = (await directoryRows.allInnerTexts()).map(projectNameFromDirectoryRowText).filter((name) => name !== null);
+  if (directoryNames.length > 0) {
+    return Array.from(new Set(directoryNames)).map((name) => ({ name }));
+  }
   await page.locator(WORKSPACE.projectFolderIcon).first().waitFor({ timeout: 5e3 }).catch(() => {
   });
   const names = await page.evaluate(PROJECT_ROWS_SOURCE);
   return names.map((name) => ({ name }));
 };
+var openProject = async (page, project) => {
+  await ensureOnProjectsPage(page);
+  const directoryRows = page.locator(WORKSPACE.projectDirectoryRow);
+  await directoryRows.first().waitFor({ state: "visible", timeout: 8e3 }).catch(() => {
+  });
+  const directoryIndex = (await directoryRows.allInnerTexts()).findIndex(
+    (rowText) => projectNameFromDirectoryRowText(rowText) === project
+  );
+  if (directoryIndex >= 0) {
+    await directoryRows.nth(directoryIndex).evaluate((row) => {
+      if (row instanceof HTMLElement) row.click();
+    });
+    const heading = page.locator("main").getByText(project, { exact: true }).first();
+    try {
+      await heading.waitFor({ state: "visible", timeout: 8e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    await page.locator(WORKSPACE.projectFolderIcon).first().waitFor({
+      state: "visible",
+      timeout: 8e3
+    });
+  } catch {
+    return false;
+  }
+  const projectRows = page.locator(WORKSPACE.projectFolderIcon).locator('xpath=ancestor::*[@role="row" or self::a or self::li][1]');
+  const rowCount = await projectRows.count();
+  for (let index = 0; index < rowCount; index += 1) {
+    const projectRow = projectRows.nth(index);
+    const [projectName] = (await projectRow.innerText()).split("\n");
+    if (projectName?.trim() !== project) continue;
+    await projectRow.evaluate((row) => {
+      if (row instanceof HTMLElement) row.click();
+    });
+    const heading = page.locator("main").getByText(project, { exact: true }).first();
+    try {
+      await heading.waitFor({ state: "visible", timeout: 8e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+};
+var projectPageContainsConversation = async (page, conversation) => {
+  const identifier = stripConversationId(conversation);
+  const identifierIsId = /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(identifier);
+  for (let poll = 0; poll < 50; poll += 1) {
+    const found = await page.locator(WORKSPACE.projectConversationLink).evaluateAll(
+      (links, target) => {
+        for (const link of links) {
+          const href = link.getAttribute("href");
+          if (href !== null && target.identifierIsId && href.includes(`/c/${target.identifier}`)) {
+            return true;
+          }
+          const text = link instanceof HTMLElement ? link.innerText : link.textContent;
+          let normalizedText = "";
+          if (text !== null) normalizedText = text;
+          const title = normalizedText.split("\n")[0]?.trim();
+          if (!target.identifierIsId && title === target.identifier) return true;
+        }
+        return false;
+      },
+      { identifier, identifierIsId }
+    );
+    if (found) return true;
+    const loadMore = page.getByText("Load more conversations", { exact: true }).first();
+    if (!await loadMore.isVisible()) {
+      if (poll >= 19) return false;
+      await page.waitForTimeout(500);
+      continue;
+    }
+    await loadMore.evaluate((label) => {
+      let clickTarget = label;
+      const button = label.closest("button");
+      if (button !== null) clickTarget = button;
+      if (clickTarget instanceof HTMLElement) clickTarget.click();
+    });
+    await page.waitForTimeout(700);
+  }
+  return false;
+};
+var projectContainsConversation = async (page, project, conversation) => {
+  const originalUrl = page.url();
+  try {
+    if (!await openProject(page, project)) return false;
+    await page.waitForTimeout(800);
+    return await projectPageContainsConversation(page, conversation);
+  } finally {
+    if (page.url() !== originalUrl) await gotoStable(page, originalUrl);
+  }
+};
+var conversationLinkIdentifiesProject = async (page, conversation, project) => {
+  const identifier = stripConversationId(conversation);
+  const identifierIsId = /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(identifier);
+  let links = page.locator(WORKSPACE.chatLink);
+  if (identifierIsId) links = page.locator(`nav a[href*="/c/${identifier}"]`);
+  else links = links.filter({ hasText: exactName(identifier) });
+  const count = await links.count();
+  for (let index = 0; index < count; index += 1) {
+    const ariaLabel = await links.nth(index).getAttribute("aria-label");
+    if (ariaLabel === null) continue;
+    if (chatGptProjectNameFromConversationAriaLabel(ariaLabel) === project) return true;
+  }
+  return false;
+};
+var activeConversationHeaderIdentifiesProject = async (page, project) => {
+  if (!/\/g\/g-p-[^/]+\/c\//i.test(page.url())) return false;
+  try {
+    await page.locator("header").getByText(project, { exact: true }).first().waitFor({ state: "visible", timeout: 2e3 });
+    return true;
+  } catch {
+    return false;
+  }
+};
 var gotoStable = async (page, url) => {
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
@@ -3277,38 +3544,65 @@ var deleteProject = async (page, project) => {
 };
 var moveChatToProject = async (page, input) => {
   const base = { chat: input.chat, project: input.project, moved: false };
+  const conversationId = stripConversationId(input.chat);
+  const identifierIsId = /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(conversationId);
+  if (identifierIsId && chatGptConversationIdFromUrl(page.url()) !== conversationId) {
+    await gotoStable(page, `https://chatgpt.com/c/${conversationId}`);
+    await waitForActiveConversationMenu(page, conversationId);
+  }
+  if (await activeConversationHeaderIdentifiesProject(page, input.project) || await conversationLinkIdentifiesProject(page, input.chat, input.project)) {
+    return {
+      ...base,
+      alreadyFiled: true,
+      reason: `already in project "${input.project}"`
+    };
+  }
   if (!await openConversationMenu(page, input.chat)) {
     return { ...base, reason: "could not open the chat \u22EF menu" };
   }
   const visibleMenuItems2 = page.locator(`${WORKSPACE.menuItem}:visible`);
   const moveItem = visibleMenuItems2.filter({ hasText: /^Move to project$/i }).first();
-  if (!await moveItem.isVisible({ timeout: 2e3 }).catch(() => false)) {
+  try {
+    await moveItem.waitFor({ state: "visible", timeout: 5e3 });
+  } catch {
     await dismissMenu(page);
     return { ...base, reason: "no 'Move to project' option (GPT- or project-owned chat)" };
   }
   const targetOf = () => page.locator(`${WORKSPACE.menuItem}:visible`).filter({ hasText: exactName(input.project) }).first();
+  const removalStateOf = async () => {
+    const namedRemoval = page.locator(`${WORKSPACE.menuItem}:visible`).filter({
+      hasText: new RegExp(`^Remove from ${escapeRegExp(input.project)}$`, "i")
+    });
+    const genericRemoval = page.locator(`${WORKSPACE.menuItem}:visible`).filter({ hasText: /^Remove from project$/i });
+    return chatGptProjectRemovalState(
+      await namedRemoval.count() > 0,
+      await genericRemoval.count() > 0
+    );
+  };
+  const newProjectItem = page.locator(`${WORKSPACE.menuItem}:visible`).filter({ hasText: /^New project$/i });
   await moveItem.hover().catch(() => {
   });
   let target = targetOf();
   let visible = false;
-  for (let attempt = 0; attempt < 2 && !visible; attempt += 1) {
-    if (attempt > 0) await moveItem.click().catch(() => {
+  let removalState = "not-filed";
+  let submenuVisible = false;
+  for (let attempt = 0; attempt < 2 && !visible && removalState === "not-filed"; attempt += 1) {
+    if (attempt > 0 && !submenuVisible) await moveItem.click().catch(() => {
     });
-    for (let poll = 0; poll < 8 && !visible; poll += 1) {
-      visible = await target.isVisible({ timeout: 350 }).catch(() => false);
-      if (!visible) await page.waitForTimeout(150);
+    for (let poll = 0; poll < 40 && !visible && removalState === "not-filed"; poll += 1) {
+      try {
+        await target.waitFor({ state: "visible", timeout: 350 });
+        visible = true;
+      } catch {
+        visible = false;
+      }
+      removalState = await removalStateOf();
+      submenuVisible = submenuVisible || await newProjectItem.count() > 0;
+      if (!visible && removalState === "not-filed") await page.waitForTimeout(150);
       target = targetOf();
     }
   }
   if (!visible) {
-    const namedRemoval = page.locator(`${WORKSPACE.menuItem}:visible`).filter({
-      hasText: new RegExp(`^Remove from ${escapeRegExp(input.project)}$`, "i")
-    });
-    const genericRemoval = page.locator(`${WORKSPACE.menuItem}:visible`).filter({ hasText: /^Remove from project$/i });
-    const removalState = chatGptProjectRemovalState(
-      await namedRemoval.count() > 0,
-      await genericRemoval.count() > 0
-    );
     await dismissMenu(page);
     if (removalState === "already-filed") {
       return {
@@ -3318,6 +3612,16 @@ var moveChatToProject = async (page, input) => {
       };
     }
     if (removalState === "current-project-unknown") {
+      let confirmed2 = await conversationLinkIdentifiesProject(page, input.chat, input.project);
+      if (!confirmed2)
+        confirmed2 = await projectContainsConversation(page, input.project, input.chat);
+      if (confirmed2) {
+        return {
+          ...base,
+          alreadyFiled: true,
+          reason: `already in project "${input.project}"`
+        };
+      }
       return {
         ...base,
         reason: `chat is already in a project, but ChatGPT did not identify which one`
@@ -3336,6 +3640,16 @@ var moveChatToProject = async (page, input) => {
     return { ...base, reason: `could not select project "${input.project}"` };
   }
   await page.waitForTimeout(800);
+  let confirmed = await activeConversationHeaderIdentifiesProject(page, input.project);
+  if (!confirmed)
+    confirmed = await conversationLinkIdentifiesProject(page, input.chat, input.project);
+  if (!confirmed) confirmed = await projectContainsConversation(page, input.project, input.chat);
+  if (!confirmed) {
+    return {
+      ...base,
+      reason: `ChatGPT did not confirm the move into project "${input.project}"`
+    };
+  }
   return { ...base, moved: true };
 };
 var archiveChat = async (page, chat) => {
@@ -3354,24 +3668,19 @@ var archiveChat = async (page, chat) => {
 };
 var findChatRow = async (page, chat) => {
   const id2 = stripConversationId(chat);
-  const byHref = page.locator(`nav a[href^="/c/${id2}"]`).first();
+  const byHref = page.locator(`nav a[href*="/c/${id2}"]`).first();
   const byTitle = page.locator(WORKSPACE.chatLink, { hasText: chat }).first();
   if (await byHref.count() > 0) return byHref;
   const looksLikeId = /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(id2);
   if (looksLikeId && !page.url().includes(`/c/${id2}`)) {
     await gotoStable(page, `https://chatgpt.com/c/${id2}`);
-    await page.waitForTimeout(700);
     if (await byHref.count() > 0) return byHref;
+    if (await waitForActiveConversationMenu(page, id2)) return null;
   }
   if (await byTitle.count() > 0) return byTitle;
-  const activeConversationId = chatGptConversationIdFromUrl(page.url());
-  if (activeConversationId === id2) {
-    const activeMenu = page.locator(WORKSPACE.activeConversationMenu).first();
-    const activeMenuVisible = await activeMenu.waitFor({ state: "visible", timeout: 2e3 }).then(() => true).catch(() => false);
-    if (activeMenuVisible) return null;
-  }
+  if (looksLikeId && await waitForActiveConversationMenu(page, id2)) return null;
   await page.evaluate(() => {
-    const anchor = document.querySelector('nav a[href^="/c/"]');
+    const anchor = document.querySelector('nav a[href*="/c/"]');
     let el = anchor ? anchor.closest("nav") : document.querySelector("nav");
     while (el && el.scrollHeight <= el.clientHeight + 20) el = el.parentElement;
     if (el !== null) {
@@ -3387,7 +3696,7 @@ var findChatRow = async (page, chat) => {
     if (await byHref.count() > 0) return byHref;
     if (await byTitle.count() > 0) return byTitle;
     await page.evaluate(() => {
-      const anchor = document.querySelector('nav a[href^="/c/"]');
+      const anchor = document.querySelector('nav a[href*="/c/"]');
       let el = anchor ? anchor.closest("nav") : document.querySelector("nav");
       while (el && el.scrollHeight <= el.clientHeight + 20) el = el.parentElement;
       if (el !== null) {
@@ -3428,13 +3737,25 @@ var openChatMenu = async (page, row) => {
   }
 };
 var openConversationMenu = async (page, chat) => {
+  let targetConversationId = stripConversationId(chat);
+  const targetLooksLikeId = /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(targetConversationId);
+  if (targetLooksLikeId && chatGptConversationIdFromUrl(page.url()) === targetConversationId && await openActiveConversationMenu(page, targetConversationId)) {
+    return true;
+  }
   const row = await findChatRow(page, chat);
   if (row !== null) return openChatMenu(page, row);
-  const targetConversationId = stripConversationId(chat);
-  const activeConversationId = chatGptConversationIdFromUrl(page.url());
-  if (activeConversationId !== targetConversationId) return false;
+  if (!targetLooksLikeId) {
+    const results = await searchChatGptConversations(page, { query: chat, limit: 20 });
+    const exactResult = results.find((result) => result.title.trim() === chat.trim());
+    if (exactResult === void 0) return false;
+    targetConversationId = exactResult.id;
+    await gotoStable(page, exactResult.url);
+  }
+  return openActiveConversationMenu(page, targetConversationId);
+};
+var openActiveConversationMenu = async (page, targetConversationId) => {
+  if (!await waitForActiveConversationMenu(page, targetConversationId)) return false;
   const trigger = page.locator(WORKSPACE.activeConversationMenu).first();
-  if (!await trigger.isVisible()) return false;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     if (attempt === 0) await trigger.click().catch(() => {
     });
@@ -3451,11 +3772,32 @@ var openConversationMenu = async (page, chat) => {
       ).catch(() => {
       });
     }
-    const menuVisible = await page.locator(`${WORKSPACE.menuItem}:visible`).first().waitFor({ state: "visible", timeout: 2e3 }).then(() => true).catch(() => false);
+    let menuVisible = false;
+    try {
+      await page.locator(`${WORKSPACE.menuItem}:visible`).first().waitFor({ state: "visible", timeout: 4e3 });
+      menuVisible = true;
+    } catch {
+      menuVisible = false;
+    }
     if (menuVisible) return true;
   }
   return false;
 };
+var waitForActiveConversationMenu = async (page, conversationId) => {
+  const trigger = page.locator(WORKSPACE.activeConversationMenu).first();
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const activeConversationId = chatGptConversationIdFromUrl(page.url());
+    if (activeConversationId === conversationId) {
+      try {
+        await trigger.waitFor({ state: "visible", timeout: 500 });
+        return true;
+      } catch {
+      }
+    }
+    await page.waitForTimeout(250);
+  }
+  return false;
+};
 var dismissMenu = async (page) => {
   await page.keyboard.press("Escape").catch(() => {
   });
@@ -3532,16 +3874,16 @@ var listClips = async (page) => {
   return clips;
 };
 var downloadClip = async (page, clipId, outDir) => {
-  const { mkdir: mkdir8, writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join12 } = await import("path");
+  const { mkdir: mkdir9, writeFile: writeFile7 } = await import("fs/promises");
+  const { join: join13 } = await import("path");
   const clipResponse = await page.request.get(clipUrlFromId(clipId));
   if (!clipResponse.ok()) {
     throw new Error(`Flow clip download failed (${clipResponse.status()}) for ${clipId}`);
   }
   const clipBytes = await clipResponse.body();
-  await mkdir8(outDir, { recursive: true });
-  const dest = join12(outDir, `${clipId}.mp4`);
-  await writeFile6(dest, clipBytes);
+  await mkdir9(outDir, { recursive: true });
+  const dest = join13(outDir, `${clipId}.mp4`);
+  await writeFile7(dest, clipBytes);
   return dest;
 };
 var tagAndClick = async (input) => {
@@ -3764,8 +4106,8 @@ var CLIP_SETTLE_MS = 1e4;
 var RENDER_FAILURE_CONFIRM_MS = 25e3;
 var MIN_GRID_CLIP_PX = 100;
 var CLIP_HOLD_MS = 3e3;
-var delay = (ms) => new Promise((resolve8) => {
-  setTimeout(resolve8, ms);
+var delay = (ms) => new Promise((resolve9) => {
+  setTimeout(resolve9, ms);
 });
 var pollFor = async (predicate, options) => {
   const startedAt = Date.now();
@@ -8968,7 +9310,7 @@ var attachTunnelLifecycle = (handlers) => {
     });
   });
 };
-var waitForTunnelUrl = (cloudflared) => new Promise((resolve8, reject) => {
+var waitForTunnelUrl = (cloudflared) => new Promise((resolve9, reject) => {
   const state = { publicUrl: void 0, settled: false };
   const settle = (outcome) => {
     if (state.settled) return;
@@ -8977,7 +9319,7 @@ var waitForTunnelUrl = (cloudflared) => new Promise((resolve8, reject) => {
       reject(outcome.error);
       return;
     }
-    resolve8(outcome.url);
+    resolve9(outcome.url);
   };
   const urlTimeout = setTimeout(() => {
     settle({ kind: "error", error: new Error("Timed out waiting for tunnel URL") });
@@ -9473,9 +9815,9 @@ var Orchestrator = class {
       }
     });
   }
-  async listConversations() {
+  async listConversations(options) {
     if (this.page === null) return [];
-    return this.provider.readSidebarConversations(this.page);
+    return this.provider.readSidebarConversations(this.page, options);
   }
   async searchConversations(input) {
     if (this.page === null) return [];
@@ -9566,18 +9908,18 @@ var mcpConnectorUrl = (tunnelUrl) => {
   return `${tunnelUrl.replace(/\/+$/, "")}/mcp`;
 };
 var currentGitBranch = (repoPath) => {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     execFile2("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: repoPath }, (error, stdout) => {
       if (error) {
-        resolve8(void 0);
+        resolve9(void 0);
         return;
       }
       const branch = stdout.trim();
       if (branch.length === 0) {
-        resolve8(void 0);
+        resolve9(void 0);
         return;
       }
-      resolve8(branch);
+      resolve9(branch);
     });
   });
 };
@@ -10084,12 +10426,12 @@ var DEFAULT_FANOUT_TIMEOUT_MS = 3e5;
 var DEFAULT_FANOUT_MAX_REPLY_CHARS = 2e3;
 var DEFAULT_FANOUT_LIMIT = 20;
 var withTimeout = (promise, ms, label) => {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve8(value);
+        resolve9(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -10796,15 +11138,298 @@ var serveAskGatewayStdio = async (deps) => {
   const mcpServer = askGatewayServerFor(deps);
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);
-  await new Promise((resolve8) => {
+  await new Promise((resolve9) => {
     const priorOnClose = transport.onclose;
     transport.onclose = () => {
       if (priorOnClose !== void 0) priorOnClose();
-      resolve8();
+      resolve9();
     };
   });
 };
 
+// src/features/terminal/chatOrganizationQueue.ts
+import { createHash as createHash2, randomUUID as randomUUID4 } from "crypto";
+import { existsSync } from "fs";
+import { mkdir as mkdir7, open, readFile as readFile10, rename, unlink, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname3, isAbsolute, join as join11, resolve as resolve7 } from "path";
+import { Schema as Schema8 } from "effect";
+var ChatOrganizationTaskSchema = Schema8.Struct({
+  conversation: Schema8.String.pipe(Schema8.minLength(1)),
+  project: Schema8.String.pipe(Schema8.minLength(1))
+});
+var ChatOrganizationTasksSchema = Schema8.Array(ChatOrganizationTaskSchema).pipe(
+  Schema8.minItems(1)
+);
+var PendingQueueItemSchema = Schema8.Struct({
+  status: Schema8.Literal("pending"),
+  conversation: Schema8.String,
+  project: Schema8.String,
+  attempts: Schema8.Number.pipe(Schema8.int(), Schema8.nonNegative()),
+  lastReason: Schema8.optional(Schema8.String)
+});
+var CompletedQueueItemSchema = Schema8.Struct({
+  status: Schema8.Literal("moved", "already-filed"),
+  conversation: Schema8.String,
+  project: Schema8.String,
+  attempts: Schema8.Number.pipe(Schema8.int(), Schema8.positive()),
+  completedAt: Schema8.String
+});
+var FailedQueueItemSchema = Schema8.Struct({
+  status: Schema8.Literal("failed"),
+  conversation: Schema8.String,
+  project: Schema8.String,
+  attempts: Schema8.Number.pipe(Schema8.int(), Schema8.positive()),
+  reason: Schema8.String,
+  completedAt: Schema8.String
+});
+var ChatOrganizationQueueItemSchema = Schema8.Union(
+  PendingQueueItemSchema,
+  CompletedQueueItemSchema,
+  FailedQueueItemSchema
+);
+var ChatOrganizationQueueSchema = Schema8.Struct({
+  version: Schema8.Literal(1),
+  fingerprint: Schema8.String,
+  createdAt: Schema8.String,
+  updatedAt: Schema8.String,
+  items: Schema8.Array(ChatOrganizationQueueItemSchema).pipe(Schema8.minItems(1))
+});
+var ORGANIZATION_INTERVAL = /^(?<minimum>\d+)(?:-(?<maximum>\d+))?$/u;
+var chatOrganizationIntervalFrom = (value, defaultSeconds) => {
+  if (value === void 0) {
+    return { minimumSeconds: defaultSeconds, maximumSeconds: defaultSeconds };
+  }
+  const match = ORGANIZATION_INTERVAL.exec(value.trim());
+  const minimumText = match?.groups?.minimum;
+  const maximumText = match?.groups?.maximum;
+  if (minimumText === void 0) {
+    throw new Error("--interval must be whole seconds or a range such as 10-20.");
+  }
+  const minimumSeconds = Number.parseInt(minimumText, 10);
+  let maximumSeconds = minimumSeconds;
+  if (maximumText !== void 0) maximumSeconds = Number.parseInt(maximumText, 10);
+  if (minimumSeconds <= 0 || maximumSeconds <= 0 || minimumSeconds > maximumSeconds) {
+    throw new Error("--interval must be a positive ascending range such as 10-20.");
+  }
+  return { minimumSeconds, maximumSeconds };
+};
+var nextChatOrganizationIntervalSeconds = (interval, randomFraction) => {
+  if (interval.minimumSeconds === interval.maximumSeconds) return interval.minimumSeconds;
+  const width = interval.maximumSeconds - interval.minimumSeconds + 1;
+  return interval.minimumSeconds + Math.floor(randomFraction * width);
+};
+var chatOrganizationIntervalLabel = (interval) => {
+  if (interval.minimumSeconds === interval.maximumSeconds) return `${interval.minimumSeconds}s`;
+  return `${interval.minimumSeconds}-${interval.maximumSeconds}s`;
+};
+var readOrganizationPlanSource = async (spec, launchDirectory) => {
+  const trimmed = spec.trim();
+  if (trimmed.startsWith("[")) return trimmed;
+  let sourcePath = trimmed;
+  if (trimmed.startsWith("@")) sourcePath = trimmed.slice(1);
+  let absolutePath = sourcePath;
+  if (!isAbsolute(sourcePath)) absolutePath = resolve7(launchDirectory, sourcePath);
+  return readFile10(absolutePath, "utf8");
+};
+var normalizedOrganizationTasks = (tasks) => {
+  const normalized = [];
+  for (const task of tasks) {
+    const conversation = task.conversation.trim();
+    const project = task.project.trim();
+    if (!conversation) throw new Error("Every organization task needs a Conversation id or title.");
+    if (!project) throw new Error("Every organization task needs a Project name.");
+    normalized.push({ conversation, project });
+  }
+  return normalized;
+};
+var loadChatOrganizationTasks = async (spec, launchDirectory) => {
+  if (!spec.trim()) throw new Error("--plan needs a file, @file, or inline JSON array.");
+  const source = await readOrganizationPlanSource(spec, launchDirectory);
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (error) {
+    throw new Error(
+      `Organization plan is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const tasks = Schema8.decodeUnknownSync(ChatOrganizationTasksSchema)(parsed);
+  return normalizedOrganizationTasks(tasks);
+};
+var organizationPlanFingerprint = (tasks) => {
+  return createHash2("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+};
+var chatOrganizationQueuePath = (repoRoot, tasks) => {
+  return join11(
+    bridgeDir(repoRoot),
+    "chat-organization-queues",
+    `${organizationPlanFingerprint(tasks)}.json`
+  );
+};
+var newChatOrganizationQueue = (tasks, timestamp) => {
+  return {
+    version: 1,
+    fingerprint: organizationPlanFingerprint(tasks),
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    items: tasks.map((task) => ({
+      status: "pending",
+      conversation: task.conversation,
+      project: task.project,
+      attempts: 0
+    }))
+  };
+};
+var persistChatOrganizationQueue = async (queuePath, queue) => {
+  await mkdir7(dirname3(queuePath), { recursive: true });
+  const pendingPath = `${queuePath}.${process.pid}.${randomUUID4()}.pending`;
+  try {
+    await writeFile5(pendingPath, `${JSON.stringify(queue, null, 2)}
+`, "utf8");
+    await rename(pendingPath, queuePath);
+  } finally {
+    try {
+      await unlink(pendingPath);
+    } catch {
+    }
+  }
+};
+var errorCodeOf = (error) => {
+  if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
+  if (typeof error.code !== "string") return void 0;
+  return error.code;
+};
+var removeStaleQueueLock = async (lockPath) => {
+  let owner;
+  try {
+    owner = JSON.parse(await readFile10(lockPath, "utf8"));
+  } catch {
+    return false;
+  }
+  if (typeof owner !== "object" || owner === null || !("pid" in owner)) return false;
+  if (typeof owner.pid !== "number" || !Number.isInteger(owner.pid)) return false;
+  try {
+    process.kill(owner.pid, 0);
+    return false;
+  } catch (error) {
+    if (errorCodeOf(error) !== "ESRCH") return false;
+  }
+  await unlink(lockPath);
+  return true;
+};
+var acquireChatOrganizationQueueLock = async (queuePath) => {
+  await mkdir7(dirname3(queuePath), { recursive: true });
+  const lockPath = `${queuePath}.lock`;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const handle = await open(lockPath, "wx");
+      await handle.writeFile(
+        `${JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`
+      );
+      let released = false;
+      return async () => {
+        if (released) return;
+        released = true;
+        await handle.close();
+        await unlink(lockPath);
+      };
+    } catch (error) {
+      if (errorCodeOf(error) !== "EEXIST") throw error;
+      if (attempt === 0 && await removeStaleQueueLock(lockPath)) continue;
+      throw new Error(`Organization queue is already running: ${lockPath}`);
+    }
+  }
+  throw new Error(`Could not acquire organization queue lock: ${lockPath}`);
+};
+var openChatOrganizationQueue = async (input) => {
+  const path2 = chatOrganizationQueuePath(input.repoRoot, input.tasks);
+  if (!input.restart && existsSync(path2)) {
+    const stored = JSON.parse(await readFile10(path2, "utf8"));
+    const queue2 = Schema8.decodeUnknownSync(ChatOrganizationQueueSchema)(stored);
+    const expectedFingerprint = organizationPlanFingerprint(input.tasks);
+    if (queue2.fingerprint !== expectedFingerprint) {
+      throw new Error(`Stored queue fingerprint does not match ${path2}. Use --restart.`);
+    }
+    return { path: path2, queue: queue2 };
+  }
+  const queue = newChatOrganizationQueue(input.tasks, input.timestamp);
+  await persistChatOrganizationQueue(path2, queue);
+  return { path: path2, queue };
+};
+var nextChatOrganizationQueueIndex = (queue) => {
+  const index = queue.items.findIndex((item) => item.status === "pending");
+  if (index < 0) return void 0;
+  return index;
+};
+var completeChatOrganizationQueueItem = (input) => {
+  const current = input.queue.items[input.index];
+  if (current === void 0 || current.status !== "pending") return input.queue;
+  const items = [...input.queue.items];
+  items[input.index] = {
+    status: input.status,
+    conversation: current.conversation,
+    project: current.project,
+    attempts: current.attempts + 1,
+    completedAt: input.timestamp
+  };
+  return { ...input.queue, updatedAt: input.timestamp, items };
+};
+var deferChatOrganizationQueueItem = (input) => {
+  const current = input.queue.items[input.index];
+  if (current === void 0 || current.status !== "pending") return input.queue;
+  const items = [...input.queue.items];
+  items[input.index] = {
+    status: "pending",
+    conversation: current.conversation,
+    project: current.project,
+    attempts: current.attempts,
+    lastReason: input.reason
+  };
+  return { ...input.queue, updatedAt: input.timestamp, items };
+};
+var failChatOrganizationQueueItem = (input) => {
+  const current = input.queue.items[input.index];
+  if (current === void 0 || current.status !== "pending") return input.queue;
+  const attempts = current.attempts + 1;
+  const items = [...input.queue.items];
+  if (attempts >= input.maxAttempts) {
+    items[input.index] = {
+      status: "failed",
+      conversation: current.conversation,
+      project: current.project,
+      attempts,
+      reason: input.reason,
+      completedAt: input.timestamp
+    };
+  } else {
+    items[input.index] = {
+      status: "pending",
+      conversation: current.conversation,
+      project: current.project,
+      attempts,
+      lastReason: input.reason
+    };
+  }
+  return { ...input.queue, updatedAt: input.timestamp, items };
+};
+var summarizeChatOrganizationQueue = (queue) => {
+  const summary = {
+    total: queue.items.length,
+    pending: 0,
+    moved: 0,
+    alreadyFiled: 0,
+    failed: 0
+  };
+  for (const item of queue.items) {
+    if (item.status === "pending") summary.pending += 1;
+    else if (item.status === "moved") summary.moved += 1;
+    else if (item.status === "already-filed") summary.alreadyFiled += 1;
+    else summary.failed += 1;
+  }
+  return summary;
+};
+
 // src/features/terminal/providerLabel.ts
 var providerDisplayName = (id2) => {
   return PROVIDER_CONFIG[id2].displayName;
@@ -11385,7 +12010,7 @@ var IGNORED_COMPLETION_ENTRIES = /* @__PURE__ */ new Set([
 ]);
 
 // src/features/terminal/tui/composer/fileMentionCompletion.ts
-import { isAbsolute, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute2, sep as sep2 } from "path";
 var findActiveFileMention = (input) => {
   const position = input.cursor === void 0 ? input.input.length : input.cursor;
   return parseActiveFileMention({ text: input.input, position });
@@ -11411,7 +12036,7 @@ var normalizePartialPath = (partial) => {
   return partial.replaceAll("\\", "/").replaceAll(sep2, "/");
 };
 var isUnsafePartial = (partial) => {
-  if (isAbsolute(partial) || partial.startsWith("/")) return true;
+  if (isAbsolute2(partial) || partial.startsWith("/")) return true;
   return partial.split("/").filter(Boolean).includes("..");
 };
 var compareCompletionMatches = (left, right) => {
@@ -12927,8 +13552,8 @@ var sessionIdFrom = async (params) => {
   return latest.metadata.id;
 };
 var repositoryFileFrom = (params) => {
-  if (isAbsolute2(params.input)) {
-    const rel = relative3(resolve7(params.repoRoot), resolve7(params.input));
+  if (isAbsolute3(params.input)) {
+    const rel = relative3(resolve8(params.repoRoot), resolve8(params.input));
     return repositoryPath(params.repoRoot, rel || ".");
   }
   return repositoryPath(params.repoRoot, params.input);
@@ -12965,8 +13590,8 @@ var parseCaptureUrl = (url) => {
 };
 var prepareScreenshotDir = async (repoPath) => {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dir = join11(screenshotsDir(repoPath), stamp);
-  await mkdir7(dir, { recursive: true });
+  const dir = join12(screenshotsDir(repoPath), stamp);
+  await mkdir8(dir, { recursive: true });
   return dir;
 };
 var captureWithPlaywright = async (params) => {
@@ -12998,7 +13623,7 @@ var captureViewport = async (params) => {
   return file;
 };
 var writeViewportScreenshot = async (input) => {
-  const file = join11(input.dir, `${input.viewport.name}.png`);
+  const file = join12(input.dir, `${input.viewport.name}.png`);
   await input.page.screenshot({ path: file, fullPage: true });
   return file;
 };
@@ -13016,16 +13641,16 @@ var sessionExportFromParts = async (input) => {
   if (session !== void 0 && session !== null) {
     return {
       sessionId: session.metadata.id,
-      outputPath: input.parts[1] ? resolve7(input.parts[1]) : void 0
+      outputPath: input.parts[1] ? resolve8(input.parts[1]) : void 0
     };
   }
   return {
     sessionId: await sessionIdFrom({ args: "", ctx: input.ctx }),
-    outputPath: resolve7(first)
+    outputPath: resolve8(first)
   };
 };
 var defaultExportPath = (params) => {
-  return join11(exportsDir(params.repoPath), `${params.sessionId}.md`);
+  return join12(exportsDir(params.repoPath), `${params.sessionId}.md`);
 };
 var exportContentForPath = (params) => {
   const extension = extname2(params.path).toLowerCase();
@@ -13329,8 +13954,8 @@ var writeSessionExport = async (params) => {
 };
 var persistSessionExport = async (input) => {
   const content = exportContentForPath({ path: input.targetPath, exported: input.exported });
-  await mkdir7(dirname3(input.targetPath), { recursive: true });
-  await writeFile5(input.targetPath, content, "utf-8");
+  await mkdir8(dirname4(input.targetPath), { recursive: true });
+  await writeFile6(input.targetPath, content, "utf-8");
   console.log(`Exported ${input.sessionId} to ${input.targetPath}`);
 };
 var listCheckpointsCommand = async (_args, ctx) => {
@@ -13710,7 +14335,7 @@ var runBrowserStatus = async (options = {}) => {
   process.exit(0);
 };
 var cacheProfileRoot = (options) => {
-  return options.profile ? resolve7(options.profile) : bridgeChromeProfileRoot();
+  return options.profile ? resolve8(options.profile) : bridgeChromeProfileRoot();
 };
 var runCacheList = async (options) => {
   const inventory = await inventoryChromeCache({
@@ -13850,8 +14475,8 @@ var readFanoutSource = async (spec) => {
   const trimmed = spec.trim();
   if (trimmed.startsWith("[")) return trimmed;
   const path2 = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
-  const absolute = isAbsolute2(path2) ? path2 : resolve7(process.cwd(), path2);
-  return readFile10(absolute, "utf8");
+  const absolute = isAbsolute3(path2) ? path2 : resolve8(process.cwd(), path2);
+  return readFile11(absolute, "utf8");
 };
 var loadFanoutTasks = async (spec) => {
   if (!spec.trim()) return fail("--fan-out needs a task file, @file, or inline JSON array.");
@@ -13865,7 +14490,7 @@ var loadFanoutTasks = async (spec) => {
     return fail(`--fan-out is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
   try {
-    return Schema8.decodeUnknownSync(FanoutTasksSchema)(parsed);
+    return Schema9.decodeUnknownSync(FanoutTasksSchema)(parsed);
   } catch (err) {
     return fail(
       `--fan-out does not match the task schema (need a non-empty array of {prompt, provider?, conversation?, label?, isolate?}): ${err instanceof Error ? err.message : String(err)}`
@@ -14100,7 +14725,7 @@ var finishAskRun = async (input) => {
 var startAskEngine = async (input) => {
   const withTools = Boolean(input.options.tools) && input.supportsMcpConnector;
   return startEngine({
-    repoPath: input.options.repo ? resolve7(input.options.repo) : void 0,
+    repoPath: input.options.repo ? resolve8(input.options.repo) : void 0,
     provider: input.provider,
     mcpPort: input.options.port ? Number(input.options.port) : void 0,
     withBrowser: true,
@@ -14125,7 +14750,7 @@ var debugPortFromOption = (value) => {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 };
 var profileRootFromOption = (value) => {
-  return value ? resolve7(value) : void 0;
+  return value ? resolve8(value) : void 0;
 };
 var runAskTurn = async (input) => {
   await applyAskPreflight({ engine: input.engine, options: input.options });
@@ -14143,7 +14768,7 @@ var attachAskFiles = async (input) => {
   const resolved = paths.map((target) => {
     const rel = repositoryFileFrom({ repoRoot, input: target });
     assertImagePath(rel);
-    return resolve7(repoRoot, rel);
+    return resolve8(repoRoot, rel);
   });
   await input.engine.getOrchestrator().attachFiles(resolved);
 };
@@ -14250,7 +14875,7 @@ var downloadAfterExtract = async (input) => {
 };
 var startDownloadEngine = async (options) => {
   return startEngine({
-    repoPath: options.repo ? resolve7(options.repo) : void 0,
+    repoPath: options.repo ? resolve8(options.repo) : void 0,
     provider: providerIdFrom(options.provider),
     mcpPort: options.port ? Number(options.port) : void 0,
     withBrowser: true,
@@ -14279,7 +14904,7 @@ var assertChatgptWorkspace = (options) => {
 };
 var startWorkspaceSession = async (options) => {
   const engine = await startEngine({
-    repoPath: options.repo ? resolve7(options.repo) : void 0,
+    repoPath: options.repo ? resolve8(options.repo) : void 0,
     provider: "chatgpt",
     mcpPort: options.port ? Number(options.port) : void 0,
     withBrowser: true,
@@ -14351,13 +14976,20 @@ var runProjectDelete = async (name, options) => {
 var runChatList = async (options) => {
   assertChatgptWorkspace(options);
   const { engine } = await startWorkspaceSession(options);
-  const chats = await engine.getOrchestrator().listConversations();
+  const chats = await engine.getOrchestrator().listConversations({ orphans: Boolean(options.orphans) });
   await engine.shutdown({ closeBrowser: false });
-  if (options.json) process.stdout.write(`${JSON.stringify(chats)}
-`);
-  else if (chats.length === 0) process.stdout.write("No conversations.\n");
-  else for (const chat of chats) process.stdout.write(`${chat.id}	${chat.title}
-`);
+  let output = "";
+  if (options.json) output = `${JSON.stringify(chats)}
+`;
+  else if (chats.length === 0) output = "No conversations.\n";
+  else output = `${chats.map((chat) => `${chat.id}	${chat.title}`).join("\n")}
+`;
+  await new Promise((resolve9, reject) => {
+    process.stdout.write(output, (error) => {
+      if (error) reject(error);
+      else resolve9();
+    });
+  });
   process.exit(0);
 };
 var runChatSearch = async (query, options) => {
@@ -14444,6 +15076,292 @@ var runChatMove = async (chat, options) => {
   writeMoveOutcomes(outcomes, options);
   process.exit(outcomes.every((outcome) => outcome.moved || outcome.alreadyFiled) ? 0 : 1);
 };
+var DEFAULT_ORGANIZATION_INTERVAL_SECONDS = 30;
+var DEFAULT_ORGANIZATION_COOLDOWN_SECONDS = 300;
+var DEFAULT_ORGANIZATION_MAX_ATTEMPTS = 3;
+var MAX_CONSECUTIVE_ORGANIZATION_COOLDOWNS = 12;
+var RATE_LIMIT_REASON = "ChatGPT temporarily limited access to Conversation history.";
+var positiveIntegerOption = (value, optionName, defaultValue) => {
+  if (value === void 0) return defaultValue;
+  if (!/^[1-9]\d*$/u.test(value.trim())) {
+    return fail(`${optionName} must be a positive whole number.`);
+  }
+  const parsed = Number.parseInt(value, 10);
+  return parsed;
+};
+var organizationIntervalOption = (value) => {
+  try {
+    return chatOrganizationIntervalFrom(value, DEFAULT_ORGANIZATION_INTERVAL_SECONDS);
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+};
+var waitForOrganizationInterval = async (seconds) => {
+  await new Promise((complete) => setTimeout(complete, seconds * 1e3));
+};
+var writeChatOrganizationProgress = (message, options) => {
+  if (options.json) {
+    process.stderr.write(`${message}
+`);
+    return;
+  }
+  process.stdout.write(`${message}
+`);
+};
+var moveFailureReason = (outcome) => {
+  if (outcome.reason?.trim()) return outcome.reason;
+  return "ChatGPT did not confirm the Conversation move.";
+};
+var writeChatOrganizationSummary = (input) => {
+  const summary = summarizeChatOrganizationQueue(input.queue);
+  if (input.options.json) {
+    process.stdout.write(`${JSON.stringify({ queuePath: input.queuePath, summary })}
+`);
+    return;
+  }
+  process.stdout.write(
+    `${[
+      "Organization queue finished.",
+      `Moved: ${summary.moved}`,
+      `Already filed: ${summary.alreadyFiled}`,
+      `Failed: ${summary.failed}`,
+      `Queue state: ${input.queuePath}`
+    ].join("\n")}
+`
+  );
+};
+var writeChatOrganizationDryRun = (input) => {
+  const preview = {
+    dryRun: true,
+    queuePath: input.queuePath,
+    interval: input.interval,
+    cooldownSeconds: input.cooldownSeconds,
+    maxAttempts: input.maxAttempts,
+    tasks: input.tasks
+  };
+  if (input.options.json) {
+    process.stdout.write(`${JSON.stringify(preview)}
+`);
+    return;
+  }
+  process.stdout.write(
+    `${[
+      `Organization queue dry run: ${input.tasks.length} Conversations`,
+      `Interval: ${chatOrganizationIntervalLabel(input.interval)}`,
+      `Rate-limit cooldown: ${input.cooldownSeconds}s`,
+      `Attempts per Conversation: ${input.maxAttempts}`,
+      `Resume state: ${input.queuePath}`,
+      ...input.tasks.map((task) => `  ${task.conversation} -> ${task.project}`)
+    ].join("\n")}
+`
+  );
+};
+var recordChatOrganizationAttempt = async (input) => {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  let queue;
+  if (input.rateLimited) {
+    queue = deferChatOrganizationQueueItem({
+      queue: input.queue,
+      index: input.index,
+      reason: RATE_LIMIT_REASON,
+      timestamp
+    });
+  } else if (input.moveOutcome?.moved) {
+    queue = completeChatOrganizationQueueItem({
+      queue: input.queue,
+      index: input.index,
+      status: "moved",
+      timestamp
+    });
+  } else if (input.moveOutcome?.alreadyFiled) {
+    queue = completeChatOrganizationQueueItem({
+      queue: input.queue,
+      index: input.index,
+      status: "already-filed",
+      timestamp
+    });
+  } else {
+    let reason = "ChatGPT did not complete the Conversation move.";
+    if (input.moveOutcome !== void 0) reason = moveFailureReason(input.moveOutcome);
+    else if (input.thrownReason !== void 0) reason = input.thrownReason;
+    queue = failChatOrganizationQueueItem({
+      queue: input.queue,
+      index: input.index,
+      reason,
+      maxAttempts: input.maxAttempts,
+      timestamp
+    });
+  }
+  await persistChatOrganizationQueue(input.queuePath, queue);
+  return queue;
+};
+var runChatOrganize = async (options) => {
+  assertChatgptWorkspace(options);
+  const plan = options.plan;
+  if (plan === void 0 || !plan.trim()) {
+    return fail("Usage: bridge chat organize --plan <fileOrJson>");
+  }
+  const interval = organizationIntervalOption(options.interval);
+  const cooldownSeconds = positiveIntegerOption(
+    options.cooldown,
+    "--cooldown",
+    DEFAULT_ORGANIZATION_COOLDOWN_SECONDS
+  );
+  const maxAttempts = positiveIntegerOption(
+    options.maxAttempts,
+    "--max-attempts",
+    DEFAULT_ORGANIZATION_MAX_ATTEMPTS
+  );
+  let tasks;
+  try {
+    tasks = await loadChatOrganizationTasks(plan, process.cwd());
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+  const repoRoot = repositoryRoot(options.repo);
+  const queuePath = chatOrganizationQueuePath(repoRoot, tasks);
+  if (options.dryRun) {
+    writeChatOrganizationDryRun({
+      tasks,
+      queuePath,
+      interval,
+      cooldownSeconds,
+      maxAttempts,
+      options
+    });
+    process.exit(0);
+  }
+  let releaseQueueLock;
+  try {
+    releaseQueueLock = await acquireChatOrganizationQueueLock(queuePath);
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+  let queue;
+  try {
+    const opened = await openChatOrganizationQueue({
+      repoRoot,
+      tasks,
+      restart: Boolean(options.restart),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    queue = opened.queue;
+  } catch (error) {
+    await releaseQueueLock();
+    return fail(
+      `Could not open the organization queue: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const initialSummary = summarizeChatOrganizationQueue(queue);
+  writeChatOrganizationProgress(
+    `Organization queue: ${initialSummary.pending} pending of ${initialSummary.total}; state ${queuePath}`,
+    options
+  );
+  if (initialSummary.pending === 0) {
+    writeChatOrganizationSummary({ queuePath, queue, options });
+    await releaseQueueLock();
+    process.exit(initialSummary.failed === 0 ? 0 : 1);
+  }
+  let workspace;
+  try {
+    workspace = await startWorkspaceSession(options);
+  } catch (error) {
+    await releaseQueueLock();
+    throw error;
+  }
+  const { engine, page } = workspace;
+  try {
+    let index = nextChatOrganizationQueueIndex(queue);
+    let consecutiveRateLimitCooldowns = 0;
+    while (index !== void 0) {
+      const item = queue.items[index];
+      if (item === void 0 || item.status !== "pending") {
+        index = nextChatOrganizationQueueIndex(queue);
+        continue;
+      }
+      if (await acknowledgeChatGptHistoryRateLimit(page)) {
+        consecutiveRateLimitCooldowns += 1;
+        if (consecutiveRateLimitCooldowns >= MAX_CONSECUTIVE_ORGANIZATION_COOLDOWNS) {
+          writeChatOrganizationProgress(
+            `ChatGPT remained rate-limited after ${consecutiveRateLimitCooldowns} cooldowns; leaving the queue pending for a later resume.`,
+            options
+          );
+          break;
+        }
+        writeChatOrganizationProgress(
+          `ChatGPT rate limit detected; cooling down for ${cooldownSeconds}s before continuing.`,
+          options
+        );
+        await waitForOrganizationInterval(cooldownSeconds);
+        continue;
+      }
+      consecutiveRateLimitCooldowns = 0;
+      writeChatOrganizationProgress(
+        `Moving "${item.conversation}" -> ${item.project} (attempt ${item.attempts + 1}/${maxAttempts})`,
+        options
+      );
+      let moveOutcome;
+      let thrownReason;
+      try {
+        moveOutcome = await moveChatToProject(page, {
+          chat: item.conversation,
+          project: item.project
+        });
+      } catch (error) {
+        thrownReason = error instanceof Error ? error.message : String(error);
+      }
+      const rateLimited = await acknowledgeChatGptHistoryRateLimit(page);
+      queue = await recordChatOrganizationAttempt({
+        queue,
+        queuePath,
+        index,
+        maxAttempts,
+        rateLimited,
+        moveOutcome,
+        thrownReason
+      });
+      const recorded = queue.items[index];
+      if (recorded?.status === "moved") {
+        writeChatOrganizationProgress(`Moved "${recorded.conversation}".`, options);
+      } else if (recorded?.status === "already-filed") {
+        writeChatOrganizationProgress(`Already filed "${recorded.conversation}".`, options);
+      } else if (recorded?.status === "failed") {
+        writeChatOrganizationProgress(
+          `Failed "${recorded.conversation}" after ${recorded.attempts} attempts: ${recorded.reason}`,
+          options
+        );
+      } else if (recorded?.status === "pending") {
+        let reason = "unknown failure";
+        if (recorded.lastReason !== void 0) reason = recorded.lastReason;
+        writeChatOrganizationProgress(`Will retry "${recorded.conversation}": ${reason}`, options);
+      }
+      let waitSeconds = nextChatOrganizationIntervalSeconds(interval, Math.random());
+      if (rateLimited) {
+        consecutiveRateLimitCooldowns += 1;
+        waitSeconds = cooldownSeconds;
+      }
+      index = nextChatOrganizationQueueIndex(queue);
+      if (index !== void 0) {
+        writeChatOrganizationProgress(
+          `Waiting ${waitSeconds}s before the next UI operation.`,
+          options
+        );
+        await waitForOrganizationInterval(waitSeconds);
+      }
+    }
+  } finally {
+    try {
+      await engine.shutdown({ closeBrowser: false });
+    } finally {
+      await releaseQueueLock();
+    }
+  }
+  const summary = summarizeChatOrganizationQueue(queue);
+  writeChatOrganizationSummary({ queuePath, queue, options });
+  let exitCode = 0;
+  if (summary.failed > 0 || summary.pending > 0) exitCode = 1;
+  process.exit(exitCode);
+};
 var writeArchiveOutcomes = (outcomes, options) => {
   if (options.json) {
     process.stdout.write(`${JSON.stringify(outcomes)}
@@ -14556,7 +15474,7 @@ var runTui = async (opts) => {
   console.log(`
 Starting ai-browser-bridge (${label})...`);
   const engine = await startEngine({
-    repoPath: opts.repo ? resolve7(opts.repo) : void 0,
+    repoPath: opts.repo ? resolve8(opts.repo) : void 0,
     provider,
     mcpPort: opts.port ? Number(opts.port) : void 0,
     withBrowser: opts.browser !== false,
@@ -14679,7 +15597,7 @@ var runChatgptInspect = async (options) => {
 };
 var startFlowSession = async (options) => {
   const engine = await startEngine({
-    repoPath: options.repo ? resolve7(options.repo) : void 0,
+    repoPath: options.repo ? resolve8(options.repo) : void 0,
     provider: "flow",
     mcpPort: options.port ? Number(options.port) : void 0,
     withBrowser: true,
@@ -14689,7 +15607,7 @@ var startFlowSession = async (options) => {
   });
   return { engine, page: requireBrowserPage(engine) };
 };
-var defaultFlowOutDir = (repoRoot) => join11(downloadsDir(repoRoot), "flow");
+var defaultFlowOutDir = (repoRoot) => join12(downloadsDir(repoRoot), "flow");
 var requireClipId = (options, verb) => {
   const id2 = options.id?.[0];
   if (id2 === void 0 || id2 === "") return fail(`Usage: bridge flow ${verb} --id <clipId>`);
@@ -14721,7 +15639,7 @@ var runFlowDownload = async (options) => {
   const { engine, page } = await startFlowSession(options);
   const clips = await listClips(page);
   const targets = options.id && options.id.length > 0 ? options.id : clips.map((clip) => clip.id);
-  const outDir = options.out ? resolve7(options.out) : defaultFlowOutDir(engine.config.repoPath);
+  const outDir = options.out ? resolve8(options.out) : defaultFlowOutDir(engine.config.repoPath);
   const results = [];
   for (const id2 of targets) {
     try {
@@ -14746,13 +15664,13 @@ var runFlowDownload = async (options) => {
   process.exit(results.every((download) => download.ok) ? 0 : 1);
 };
 var runFlowGenerate = async (options) => {
-  const startFramePath = options.start ? resolve7(options.start) : "";
+  const startFramePath = options.start ? resolve8(options.start) : "";
   const prompt = options.prompt === void 0 ? "" : options.prompt.trim();
   if (!startFramePath || !prompt) {
     fail("Usage: bridge flow generate --start <imagePath> --prompt <text> [--out <dir>]");
   }
   const { engine, page } = await startFlowSession(options);
-  const outDir = options.out ? resolve7(options.out) : defaultFlowOutDir(engine.config.repoPath);
+  const outDir = options.out ? resolve8(options.out) : defaultFlowOutDir(engine.config.repoPath);
   try {
     const clip = await generateClipFromFrame(page, {
       startFramePath,
@@ -14902,7 +15820,7 @@ var subcommandOpts = (command) => {
 // src/features/terminal/registerCli.ts
 var PROVIDER_OPTION = `Browser provider: ${PROVIDER_IDS.join(", ")} (default: ${DEFAULT_PROVIDER})`;
 var registerCliCommands = (program) => {
-  program.name("bridge").description("Terminal CLI that bridges ChatGPT or Gemini with local tools via MCP").version("0.4.0").option("-r, --repo <path>", "Path to the target repository (default: cwd)").option("-p, --port <number>", "MCP server port (default: 8765)").option("--provider <name>", PROVIDER_OPTION).option("--no-browser", "Skip Chrome browser connection").action(async (_options, command) => {
+  program.name("bridge").description("Terminal CLI that bridges ChatGPT or Gemini with local tools via MCP").version("0.5.1").option("-r, --repo <path>", "Path to the target repository (default: cwd)").option("-p, --port <number>", "MCP server port (default: 8765)").option("--provider <name>", PROVIDER_OPTION).option("--no-browser", "Skip Chrome browser connection").action(async (_options, command) => {
     if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
       command.outputHelp({ error: true });
       process.exitCode = 1;
@@ -15031,6 +15949,15 @@ var registerWorkspaceCommands = (program) => {
   withWorkspaceFlags(chat.command("archive [idOrTitle...]")).description("Archive one or more conversations (reversible \u2014 hides from the sidebar)").option("--id <id...>", "Archive several conversations by id in one session").action(
     (chatParts, _options, command) => runChatArchive(chatParts.join(" "), command.optsWithGlobals())
   );
+  withWorkspaceFlags(chat.command("organize")).description("Run a resumable, rate-safe Conversation organization queue").requiredOption(
+    "--plan <fileOrJson>",
+    "JSON array of {conversation, project} tasks (inline, @file, or a path)"
+  ).option(
+    "--interval <secondsOrRange>",
+    "Seconds between UI operations, fixed or random range such as 10-20 (default: 30)"
+  ).option("--cooldown <seconds>", "Seconds to wait after rate limiting (default: 300)").option("--max-attempts <count>", "Attempts per Conversation before failing (default: 3)").option("--restart", "Restart this plan instead of resuming its persisted queue").option("--dry-run", "Validate and show the queue without opening Chrome or writing state").action(
+    (_options, command) => runChatOrganize(command.optsWithGlobals())
+  );
   const task = program.command("task").description("List or schedule ChatGPT Tasks (ChatGPT only)");
   withWorkspaceFlags(task.command("list")).description("List ChatGPT Scheduled tasks").action(
     (_options, command) => runTaskList(command.optsWithGlobals())