ai-browser-bridge 0.5.1 → 0.6.0

package/dist/bridge.js

@@ -11150,7 +11150,7 @@ var serveAskGatewayStdio = async (deps) => {
 // 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 { mkdir as mkdir7, open, readdir as readdir5, 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({
@@ -11187,14 +11187,34 @@ var ChatOrganizationQueueItemSchema = Schema8.Union(
   CompletedQueueItemSchema,
   FailedQueueItemSchema
 );
+var ChatOrganizationPacingSchema = Schema8.Struct({
+  currentSeconds: Schema8.Number.pipe(Schema8.int(), Schema8.positive()),
+  successStreak: Schema8.Number.pipe(Schema8.int(), Schema8.nonNegative()),
+  rateLimitCount: Schema8.Number.pipe(Schema8.int(), Schema8.nonNegative())
+});
+var ChatOrganizationVerificationSchema = Schema8.Struct({
+  complete: Schema8.Boolean,
+  inventoryComplete: Schema8.Boolean,
+  remainingOrphans: Schema8.Number.pipe(Schema8.int(), Schema8.nonNegative()),
+  plannedStillLoose: Schema8.Array(Schema8.String),
+  verifiedAt: Schema8.String,
+  error: Schema8.optional(Schema8.String)
+});
 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))
+  items: Schema8.Array(ChatOrganizationQueueItemSchema).pipe(Schema8.minItems(1)),
+  pacing: Schema8.optional(ChatOrganizationPacingSchema),
+  verification: Schema8.optional(ChatOrganizationVerificationSchema)
 });
 var ORGANIZATION_INTERVAL = /^(?<minimum>\d+)(?:-(?<maximum>\d+))?$/u;
+var CLOSED_BROWSER_SESSION = /(?:target page, context or browser has been closed|browser has been closed|context has been closed|page has been closed)/iu;
+var chatOrganizationSessionWasClosed = (reason) => {
+  if (reason === void 0) return false;
+  return CLOSED_BROWSER_SESSION.test(reason);
+};
 var chatOrganizationIntervalFrom = (value, defaultSeconds) => {
   if (value === void 0) {
     return { minimumSeconds: defaultSeconds, maximumSeconds: defaultSeconds };
@@ -11218,6 +11238,40 @@ var nextChatOrganizationIntervalSeconds = (interval, randomFraction) => {
   const width = interval.maximumSeconds - interval.minimumSeconds + 1;
   return interval.minimumSeconds + Math.floor(randomFraction * width);
 };
+var initialChatOrganizationPacing = (currentSeconds) => ({
+  currentSeconds,
+  successStreak: 0,
+  rateLimitCount: 0
+});
+var constrainChatOrganizationPacing = (pacing, options) => ({
+  ...pacing,
+  currentSeconds: Math.min(
+    options.maximumSeconds,
+    Math.max(options.minimumSeconds, pacing.currentSeconds)
+  ),
+  successStreak: Math.min(pacing.successStreak, options.speedUpAfter - 1)
+});
+var adaptiveChatOrganizationPacingAfterSuccess = (pacing, options) => {
+  const successStreak = pacing.successStreak + 1;
+  if (successStreak < options.speedUpAfter) return { ...pacing, successStreak };
+  return {
+    ...pacing,
+    currentSeconds: Math.min(
+      pacing.currentSeconds,
+      Math.max(options.minimumSeconds, Math.floor(pacing.currentSeconds * 0.8))
+    ),
+    successStreak: 0
+  };
+};
+var adaptiveChatOrganizationPacingAfterRateLimit = (pacing, options) => ({
+  currentSeconds: Math.min(options.maximumSeconds, Math.ceil(pacing.currentSeconds * 1.5)),
+  successStreak: 0,
+  rateLimitCount: pacing.rateLimitCount + 1
+});
+var nextAdaptiveChatOrganizationIntervalSeconds = (pacing, randomFraction) => {
+  const jitter = Math.max(1, Math.ceil(pacing.currentSeconds * 0.2));
+  return pacing.currentSeconds + Math.floor(randomFraction * (jitter + 1));
+};
 var chatOrganizationIntervalLabel = (interval) => {
   if (interval.minimumSeconds === interval.maximumSeconds) return `${interval.minimumSeconds}s`;
   return `${interval.minimumSeconds}-${interval.maximumSeconds}s`;
@@ -11294,11 +11348,98 @@ var persistChatOrganizationQueue = async (queuePath, queue) => {
     }
   }
 };
+var updateChatOrganizationQueuePacing = (input) => ({
+  ...input.queue,
+  pacing: input.pacing,
+  updatedAt: input.timestamp
+});
+var updateChatOrganizationQueueVerification = (input) => ({
+  ...input.queue,
+  verification: input.verification,
+  updatedAt: input.timestamp
+});
 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 chatOrganizationPausePath = (queuePath) => `${queuePath}.pause`;
+var chatOrganizationQueueIsPaused = async (queuePath) => existsSync(chatOrganizationPausePath(queuePath));
+var pauseChatOrganizationQueue = async (queuePath, timestamp) => {
+  await mkdir7(dirname3(queuePath), { recursive: true });
+  await writeFile5(
+    chatOrganizationPausePath(queuePath),
+    `${JSON.stringify({ pausedAt: timestamp })}
+`,
+    "utf8"
+  );
+};
+var clearChatOrganizationQueuePause = async (queuePath) => {
+  try {
+    await unlink(chatOrganizationPausePath(queuePath));
+  } catch (error) {
+    if (errorCodeOf(error) !== "ENOENT") throw error;
+  }
+};
+var organizationQueueIsRunning = async (queuePath) => {
+  let owner;
+  try {
+    owner = JSON.parse(await readFile10(`${queuePath}.lock`, "utf8"));
+  } catch {
+    return { running: false };
+  }
+  if (typeof owner !== "object" || owner === null || !("pid" in owner)) {
+    return { running: false };
+  }
+  if (typeof owner.pid !== "number" || !Number.isInteger(owner.pid)) return { running: false };
+  try {
+    process.kill(owner.pid, 0);
+    return { running: true, ownerPid: owner.pid };
+  } catch (error) {
+    if (errorCodeOf(error) === "ESRCH") return { running: false, ownerPid: owner.pid };
+    return { running: true, ownerPid: owner.pid };
+  }
+};
+var readChatOrganizationQueue = async (queuePath) => {
+  const stored = JSON.parse(await readFile10(queuePath, "utf8"));
+  return Schema8.decodeUnknownSync(ChatOrganizationQueueSchema)(stored);
+};
+var resolveChatOrganizationQueue = async (repoRoot, selector) => {
+  const queueDirectory = join11(bridgeDir(repoRoot), "chat-organization-queues");
+  let queuePath;
+  if (selector?.trim()) {
+    const trimmed = selector.trim();
+    if (isAbsolute(trimmed) || trimmed.includes("/")) queuePath = resolve7(repoRoot, trimmed);
+    else queuePath = join11(queueDirectory, trimmed.endsWith(".json") ? trimmed : `${trimmed}.json`);
+  } else {
+    let names;
+    try {
+      names = (await readdir5(queueDirectory)).filter((name) => /^[a-f0-9]{16}\.json$/u.test(name));
+    } catch (error) {
+      if (errorCodeOf(error) === "ENOENT") names = [];
+      else throw error;
+    }
+    const queues = await Promise.all(
+      names.map(async (name) => {
+        const path2 = join11(queueDirectory, name);
+        return { path: path2, queue: await readChatOrganizationQueue(path2) };
+      })
+    );
+    queues.sort((left, right) => right.queue.updatedAt.localeCompare(left.queue.updatedAt));
+    queuePath = queues[0]?.path;
+  }
+  if (queuePath === void 0 || !existsSync(queuePath)) {
+    throw new Error("No persisted ChatGPT organization queue was found.");
+  }
+  const queue = await readChatOrganizationQueue(queuePath);
+  const ownership = await organizationQueueIsRunning(queuePath);
+  return {
+    path: queuePath,
+    queue,
+    paused: await chatOrganizationQueueIsPaused(queuePath),
+    ...ownership
+  };
+};
 var removeStaleQueueLock = async (lockPath) => {
   let owner;
   try {
@@ -11429,6 +11570,47 @@ var summarizeChatOrganizationQueue = (queue) => {
   }
   return summary;
 };
+var conversationIdentity = (value) => {
+  const trimmed = value.trim();
+  const conversationPath = /\/c\/(?<id>[^/?#]+)/u.exec(trimmed)?.groups?.id;
+  if (conversationPath !== void 0) return conversationPath;
+  return trimmed;
+};
+var reopenChatOrganizationQueueItems = (input) => {
+  const targets = new Set(input.conversations.map(conversationIdentity));
+  let changed = false;
+  const items = input.queue.items.map((item) => {
+    if (item.status !== "moved" && item.status !== "already-filed" || item.attempts >= input.maxAttempts || !targets.has(conversationIdentity(item.conversation))) {
+      return item;
+    }
+    changed = true;
+    return {
+      status: "pending",
+      conversation: item.conversation,
+      project: item.project,
+      attempts: item.attempts,
+      lastReason: "Full-history audit found the Conversation still loose."
+    };
+  });
+  if (!changed) return input.queue;
+  return { ...input.queue, items, updatedAt: input.timestamp };
+};
+var chatOrganizationVerificationFrom = (input) => {
+  const orphanIdentities = /* @__PURE__ */ new Set();
+  for (const orphan of input.orphans) {
+    orphanIdentities.add(conversationIdentity(orphan.id));
+    orphanIdentities.add(orphan.title.trim());
+  }
+  const plannedStillLoose = input.queue.items.filter((item) => orphanIdentities.has(conversationIdentity(item.conversation))).map((item) => item.conversation);
+  const summary = summarizeChatOrganizationQueue(input.queue);
+  return {
+    complete: summary.pending === 0 && summary.failed === 0 && plannedStillLoose.length === 0,
+    inventoryComplete: true,
+    remainingOrphans: input.orphans.length,
+    plannedStillLoose,
+    verifiedAt: input.timestamp
+  };
+};
 
 // src/features/terminal/providerLabel.ts
 var providerDisplayName = (id2) => {
@@ -11995,7 +12177,7 @@ var applyInputSuggestion = (input, group, index = 0) => {
 };
 
 // src/features/terminal/tui/composer/fileAutocompleteComplete.ts
-import { readdir as readdir5 } from "fs/promises";
+import { readdir as readdir6 } from "fs/promises";
 
 // src/features/terminal/tui/composer/fileAutocompleteTypes.ts
 var DEFAULT_COMPLETION_LIMIT = 20;
@@ -12100,7 +12282,7 @@ var completionSearchDirectory = (input) => {
 };
 var readCompletionMatches = async (input) => {
   try {
-    const dirents = await readdir5(input.absoluteSearchDir, { withFileTypes: true });
+    const dirents = await readdir6(input.absoluteSearchDir, { withFileTypes: true });
     return dirents.filter((dirent) => dirent.isDirectory() || dirent.isFile()).filter((dirent) => !IGNORED_COMPLETION_ENTRIES.has(dirent.name)).filter((dirent) => input.namePrefix.startsWith(".") || !dirent.name.startsWith(".")).filter((dirent) => dirent.name.startsWith(input.namePrefix)).map((dirent) => mapDirent({ dirent, dirPrefix: input.dirPrefix })).sort((left, right) => compareCompletionMatches(left, right)).slice(0, input.limit);
   } catch {
     return [];
@@ -12141,7 +12323,7 @@ var hasTrailingWhitespace = (input) => {
 };
 
 // src/features/terminal/tui/suggestions/repoPathSuggestions.ts
-import { readdir as readdir6 } from "fs/promises";
+import { readdir as readdir7 } from "fs/promises";
 import { extname, sep as sep3 } from "path";
 var IGNORED_COMPLETION_ENTRIES2 = /* @__PURE__ */ new Set([
   ".git",
@@ -12186,7 +12368,7 @@ var searchDirectory = (input) => {
 };
 var listMatchingEntries = async (input) => {
   try {
-    const entries = await readdir6(input.absoluteSearchDir, { withFileTypes: true });
+    const entries = await readdir7(input.absoluteSearchDir, { withFileTypes: true });
     return entries.filter((entry) => isCompletableEntry({ name: entry.name, namePrefix: input.namePrefix })).filter((entry) => matchesKind({ entry, kind: input.kind, namePrefix: input.namePrefix })).map((entry) => pathEntrySuggestion(entry.name, input.dirPrefix, entry.isDirectory())).sort(comparePathSuggestions).slice(0, input.limit);
   } catch {
     return [];
@@ -15076,11 +15258,15 @@ 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 DEFAULT_ORGANIZATION_INTERVAL_SECONDS = 60;
+var DEFAULT_ORGANIZATION_MIN_INTERVAL_SECONDS = 15;
+var DEFAULT_ORGANIZATION_MAX_INTERVAL_SECONDS = 180;
+var DEFAULT_ORGANIZATION_SPEED_UP_AFTER = 3;
+var DEFAULT_ORGANIZATION_COOLDOWN_SECONDS = 600;
+var DEFAULT_ORGANIZATION_MAX_ATTEMPTS = 4;
 var MAX_CONSECUTIVE_ORGANIZATION_COOLDOWNS = 12;
 var RATE_LIMIT_REASON = "ChatGPT temporarily limited access to Conversation history.";
+var CLOSED_SESSION_REASON = "ChatGPT browser session closed; reopening before retry.";
 var positiveIntegerOption = (value, optionName, defaultValue) => {
   if (value === void 0) return defaultValue;
   if (!/^[1-9]\d*$/u.test(value.trim())) {
@@ -15096,8 +15282,16 @@ var organizationIntervalOption = (value) => {
     return fail(error instanceof Error ? error.message : String(error));
   }
 };
-var waitForOrganizationInterval = async (seconds) => {
-  await new Promise((complete) => setTimeout(complete, seconds * 1e3));
+var waitForOrganizationInterval = async (seconds, queuePath) => {
+  let remainingMilliseconds = seconds * 1e3;
+  while (remainingMilliseconds > 0) {
+    if (await chatOrganizationQueueIsPaused(queuePath)) return "paused";
+    const slice = Math.min(1e3, remainingMilliseconds);
+    await new Promise((complete) => setTimeout(complete, slice));
+    remainingMilliseconds -= slice;
+  }
+  if (await chatOrganizationQueueIsPaused(queuePath)) return "paused";
+  return "elapsed";
 };
 var writeChatOrganizationProgress = (message, options) => {
   if (options.json) {
@@ -15115,18 +15309,29 @@ var moveFailureReason = (outcome) => {
 var writeChatOrganizationSummary = (input) => {
   const summary = summarizeChatOrganizationQueue(input.queue);
   if (input.options.json) {
-    process.stdout.write(`${JSON.stringify({ queuePath: input.queuePath, summary })}
-`);
+    process.stdout.write(
+      `${JSON.stringify({
+        queuePath: input.queuePath,
+        state: input.paused ? "paused" : "finished",
+        summary,
+        pacing: input.queue.pacing,
+        verification: input.queue.verification
+      })}
+`
+    );
     return;
   }
   process.stdout.write(
     `${[
-      "Organization queue finished.",
+      input.paused ? "Organization queue paused." : "Organization queue finished.",
       `Moved: ${summary.moved}`,
       `Already filed: ${summary.alreadyFiled}`,
+      `Pending: ${summary.pending}`,
       `Failed: ${summary.failed}`,
+      input.queue.pacing === void 0 ? void 0 : `Adaptive pace: ${input.queue.pacing.currentSeconds}s base (${input.queue.pacing.rateLimitCount} rate limits)`,
+      input.queue.verification === void 0 ? void 0 : `Full-history verification: ${input.queue.verification.complete ? "complete" : "incomplete"}; ${input.queue.verification.remainingOrphans} intentional/remaining orphans`,
       `Queue state: ${input.queuePath}`
-    ].join("\n")}
+    ].filter((line) => line !== void 0).join("\n")}
 `
   );
 };
@@ -15137,6 +15342,10 @@ var writeChatOrganizationDryRun = (input) => {
     interval: input.interval,
     cooldownSeconds: input.cooldownSeconds,
     maxAttempts: input.maxAttempts,
+    adaptive: input.adaptive,
+    minimumIntervalSeconds: input.minimumIntervalSeconds,
+    maximumIntervalSeconds: input.maximumIntervalSeconds,
+    speedUpAfter: input.speedUpAfter,
     tasks: input.tasks
   };
   if (input.options.json) {
@@ -15148,6 +15357,7 @@ var writeChatOrganizationDryRun = (input) => {
     `${[
       `Organization queue dry run: ${input.tasks.length} Conversations`,
       `Interval: ${chatOrganizationIntervalLabel(input.interval)}`,
+      `Adaptive pacing: ${input.adaptive ? `yes (${input.minimumIntervalSeconds}-${input.maximumIntervalSeconds}s; speed up after ${input.speedUpAfter} successes)` : "no"}`,
       `Rate-limit cooldown: ${input.cooldownSeconds}s`,
       `Attempts per Conversation: ${input.maxAttempts}`,
       `Resume state: ${input.queuePath}`,
@@ -15159,7 +15369,14 @@ var writeChatOrganizationDryRun = (input) => {
 var recordChatOrganizationAttempt = async (input) => {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   let queue;
-  if (input.rateLimited) {
+  if (input.sessionClosed) {
+    queue = deferChatOrganizationQueueItem({
+      queue: input.queue,
+      index: input.index,
+      reason: CLOSED_SESSION_REASON,
+      timestamp
+    });
+  } else if (input.rateLimited) {
     queue = deferChatOrganizationQueueItem({
       queue: input.queue,
       index: input.index,
@@ -15195,6 +15412,132 @@ var recordChatOrganizationAttempt = async (input) => {
   await persistChatOrganizationQueue(input.queuePath, queue);
   return queue;
 };
+var persistChatOrganizationPacing = async (input) => {
+  const queue = updateChatOrganizationQueuePacing({
+    queue: input.queue,
+    pacing: input.pacing,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await persistChatOrganizationQueue(input.queuePath, queue);
+  return queue;
+};
+var verifyCompletedChatOrganizationQueue = async (input) => {
+  writeChatOrganizationProgress(
+    "Verifying the completed plan against an exhaustive full-history orphan scan.",
+    input.options
+  );
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  let verification;
+  try {
+    const orphans = await input.workspace.engine.getOrchestrator().listConversations({ orphans: true });
+    verification = chatOrganizationVerificationFrom({
+      queue: input.queue,
+      orphans,
+      timestamp
+    });
+  } catch (error) {
+    verification = {
+      complete: false,
+      inventoryComplete: false,
+      remainingOrphans: 0,
+      plannedStillLoose: [],
+      verifiedAt: timestamp,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  let queue = updateChatOrganizationQueueVerification({
+    queue: input.queue,
+    verification,
+    timestamp
+  });
+  if (verification.plannedStillLoose.length > 0) {
+    queue = reopenChatOrganizationQueueItems({
+      queue,
+      conversations: verification.plannedStillLoose,
+      maxAttempts: input.maxAttempts,
+      timestamp
+    });
+  }
+  await persistChatOrganizationQueue(input.queuePath, queue);
+  if (verification.inventoryComplete) {
+    writeChatOrganizationProgress(
+      `Full-history scan reached the stable end: ${verification.remainingOrphans} loose Conversations remain; ${verification.plannedStillLoose.length} planned Conversations are still loose.`,
+      input.options
+    );
+  } else {
+    writeChatOrganizationProgress(
+      `Full-history verification could not prove completion: ${verification.error ?? "unknown scan failure"}`,
+      input.options
+    );
+  }
+  return queue;
+};
+var organizationQueueState = (input) => {
+  if (input.running) return input.paused ? "pausing" : "running";
+  if (input.paused) return "paused";
+  if (input.summary.pending === 0) return input.summary.failed > 0 ? "failed" : "completed";
+  return "idle";
+};
+var runChatOrganizeStatus = async (options) => {
+  const selected = await resolveChatOrganizationQueue(repositoryRoot(options.repo), options.queue);
+  const summary = summarizeChatOrganizationQueue(selected.queue);
+  const state = organizationQueueState({
+    paused: selected.paused,
+    running: selected.running,
+    summary
+  });
+  const status = {
+    state,
+    queuePath: selected.path,
+    ownerPid: selected.ownerPid,
+    summary,
+    pacing: selected.queue.pacing,
+    verification: selected.queue.verification
+  };
+  if (options.json) process.stdout.write(`${JSON.stringify(status)}
+`);
+  else {
+    process.stdout.write(
+      `${[
+        `Organization queue: ${state}`,
+        `Moved: ${summary.moved}`,
+        `Already filed: ${summary.alreadyFiled}`,
+        `Pending: ${summary.pending}`,
+        `Failed: ${summary.failed}`,
+        selected.queue.pacing === void 0 ? "Adaptive pace: not initialized" : `Adaptive pace: ${selected.queue.pacing.currentSeconds}s base (${selected.queue.pacing.successStreak} success streak; ${selected.queue.pacing.rateLimitCount} rate limits)`,
+        selected.queue.verification === void 0 ? "Full-history verification: not run" : `Full-history verification: ${selected.queue.verification.complete ? "complete" : "incomplete"}`,
+        `Queue state: ${selected.path}`
+      ].join("\n")}
+`
+    );
+  }
+};
+var runChatOrganizePause = async (options) => {
+  const selected = await resolveChatOrganizationQueue(repositoryRoot(options.repo), options.queue);
+  await pauseChatOrganizationQueue(selected.path, (/* @__PURE__ */ new Date()).toISOString());
+  const message = selected.running ? "Pause requested; the active UI operation will finish before the queue releases its lock." : "Organization queue paused.";
+  if (options.json) {
+    process.stdout.write(
+      `${JSON.stringify({ state: selected.running ? "pausing" : "paused", queuePath: selected.path })}
+`
+    );
+  } else process.stdout.write(`${message}
+Queue state: ${selected.path}
+`);
+};
+var runChatOrganizeResume = async (options) => {
+  assertChatgptWorkspace(options);
+  const selected = await resolveChatOrganizationQueue(repositoryRoot(options.repo), options.queue);
+  if (selected.running) return fail(`Organization queue is already running: ${selected.path}`);
+  await clearChatOrganizationQueuePause(selected.path);
+  const plan = JSON.stringify(
+    selected.queue.items.map((item) => ({
+      conversation: item.conversation,
+      project: item.project
+    }))
+  );
+  return runChatOrganize({ ...options, plan, restart: false, dryRun: false });
+};
 var runChatOrganize = async (options) => {
   assertChatgptWorkspace(options);
   const plan = options.plan;
@@ -15202,6 +15545,25 @@ var runChatOrganize = async (options) => {
     return fail("Usage: bridge chat organize --plan <fileOrJson>");
   }
   const interval = organizationIntervalOption(options.interval);
+  const adaptive = options.adaptive !== false;
+  const minimumIntervalSeconds = positiveIntegerOption(
+    options.minInterval,
+    "--min-interval",
+    DEFAULT_ORGANIZATION_MIN_INTERVAL_SECONDS
+  );
+  const maximumIntervalSeconds = positiveIntegerOption(
+    options.maxInterval,
+    "--max-interval",
+    DEFAULT_ORGANIZATION_MAX_INTERVAL_SECONDS
+  );
+  if (maximumIntervalSeconds < minimumIntervalSeconds) {
+    return fail("--max-interval must be greater than or equal to --min-interval.");
+  }
+  const speedUpAfter = positiveIntegerOption(
+    options.speedUpAfter,
+    "--speed-up-after",
+    DEFAULT_ORGANIZATION_SPEED_UP_AFTER
+  );
   const cooldownSeconds = positiveIntegerOption(
     options.cooldown,
     "--cooldown",
@@ -15227,6 +15589,10 @@ var runChatOrganize = async (options) => {
       interval,
       cooldownSeconds,
       maxAttempts,
+      adaptive,
+      minimumIntervalSeconds,
+      maximumIntervalSeconds,
+      speedUpAfter,
       options
     });
     process.exit(0);
@@ -15246,6 +15612,26 @@ var runChatOrganize = async (options) => {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
     queue = opened.queue;
+    if (adaptive) {
+      const pacing = queue.pacing === void 0 ? initialChatOrganizationPacing(
+        Math.min(
+          maximumIntervalSeconds,
+          Math.max(
+            minimumIntervalSeconds,
+            nextChatOrganizationIntervalSeconds(interval, Math.random())
+          )
+        )
+      ) : constrainChatOrganizationPacing(queue.pacing, {
+        minimumSeconds: minimumIntervalSeconds,
+        maximumSeconds: maximumIntervalSeconds,
+        speedUpAfter
+      });
+      queue = await persistChatOrganizationPacing({
+        queue,
+        queuePath,
+        pacing
+      });
+    }
   } catch (error) {
     await releaseQueueLock();
     return fail(
@@ -15257,10 +15643,13 @@ var runChatOrganize = async (options) => {
     `Organization queue: ${initialSummary.pending} pending of ${initialSummary.total}; state ${queuePath}`,
     options
   );
-  if (initialSummary.pending === 0) {
+  const needsVerification = options.verify !== false && queue.verification?.complete !== true;
+  if (initialSummary.pending === 0 && !needsVerification) {
     writeChatOrganizationSummary({ queuePath, queue, options });
     await releaseQueueLock();
-    process.exit(initialSummary.failed === 0 ? 0 : 1);
+    process.exit(
+      initialSummary.failed === 0 && (options.verify === false || queue.verification?.complete === true) ? 0 : 1
+    );
   }
   let workspace;
   try {
@@ -15269,97 +15658,187 @@ var runChatOrganize = async (options) => {
     await releaseQueueLock();
     throw error;
   }
-  const { engine, page } = workspace;
+  let workspaceWasShutdown = false;
+  let paused = false;
   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) {
+    let halted = false;
+    while (!paused && !halted) {
+      let index = nextChatOrganizationQueueIndex(queue);
+      while (index !== void 0) {
+        if (await chatOrganizationQueueIsPaused(queuePath)) {
+          paused = true;
           writeChatOrganizationProgress(
-            `ChatGPT remained rate-limited after ${consecutiveRateLimitCooldowns} cooldowns; leaving the queue pending for a later resume.`,
+            "Organization queue pause acknowledged; no new UI operation will start.",
             options
           );
           break;
         }
+        const item = queue.items[index];
+        if (item === void 0 || item.status !== "pending") {
+          index = nextChatOrganizationQueueIndex(queue);
+          continue;
+        }
+        if (await acknowledgeChatGptHistoryRateLimit(workspace.page)) {
+          consecutiveRateLimitCooldowns += 1;
+          if (adaptive && queue.pacing !== void 0) {
+            queue = await persistChatOrganizationPacing({
+              queue,
+              queuePath,
+              pacing: adaptiveChatOrganizationPacingAfterRateLimit(queue.pacing, {
+                maximumSeconds: maximumIntervalSeconds
+              })
+            });
+          }
+          if (consecutiveRateLimitCooldowns >= MAX_CONSECUTIVE_ORGANIZATION_COOLDOWNS) {
+            writeChatOrganizationProgress(
+              `ChatGPT remained rate-limited after ${consecutiveRateLimitCooldowns} cooldowns; leaving the queue pending for a later resume.`,
+              options
+            );
+            halted = true;
+            break;
+          }
+          writeChatOrganizationProgress(
+            `ChatGPT rate limit detected; cooling down for ${cooldownSeconds}s before continuing${queue.pacing === void 0 ? "." : ` at a slower ${queue.pacing.currentSeconds}s adaptive pace.`}`,
+            options
+          );
+          if (await waitForOrganizationInterval(cooldownSeconds, queuePath) === "paused") {
+            paused = true;
+            break;
+          }
+          continue;
+        }
+        consecutiveRateLimitCooldowns = 0;
         writeChatOrganizationProgress(
-          `ChatGPT rate limit detected; cooling down for ${cooldownSeconds}s before continuing.`,
+          `Moving "${item.conversation}" -> ${item.project} (attempt ${item.attempts + 1}/${maxAttempts})`,
           options
         );
-        await waitForOrganizationInterval(cooldownSeconds);
-        continue;
+        let moveOutcome;
+        let thrownReason;
+        try {
+          moveOutcome = await moveChatToProject(workspace.page, {
+            chat: item.conversation,
+            project: item.project
+          });
+        } catch (error) {
+          thrownReason = error instanceof Error ? error.message : String(error);
+        }
+        const sessionClosed = chatOrganizationSessionWasClosed(thrownReason);
+        const rateLimited = await acknowledgeChatGptHistoryRateLimit(workspace.page);
+        queue = await recordChatOrganizationAttempt({
+          queue,
+          queuePath,
+          index,
+          maxAttempts,
+          sessionClosed,
+          rateLimited,
+          moveOutcome,
+          thrownReason
+        });
+        if (adaptive && queue.pacing !== void 0) {
+          let pacing = queue.pacing;
+          if (rateLimited) {
+            pacing = adaptiveChatOrganizationPacingAfterRateLimit(pacing, {
+              maximumSeconds: maximumIntervalSeconds
+            });
+          } else if (moveOutcome?.moved || moveOutcome?.alreadyFiled) {
+            pacing = adaptiveChatOrganizationPacingAfterSuccess(pacing, {
+              minimumSeconds: minimumIntervalSeconds,
+              speedUpAfter
+            });
+          } else if (pacing.successStreak > 0) {
+            pacing = { ...pacing, successStreak: 0 };
+          }
+          queue = await persistChatOrganizationPacing({ queue, queuePath, pacing });
+        }
+        if (sessionClosed) {
+          writeChatOrganizationProgress(
+            "ChatGPT browser session closed; reopening it without consuming a retry attempt.",
+            options
+          );
+          await workspace.engine.shutdown({ closeBrowser: false });
+          workspaceWasShutdown = true;
+          try {
+            workspace = await startWorkspaceSession(options);
+            workspaceWasShutdown = false;
+          } catch (error) {
+            writeChatOrganizationProgress(
+              `Could not reopen the ChatGPT browser session; leaving the queue pending: ${error instanceof Error ? error.message : String(error)}`,
+              options
+            );
+            halted = true;
+            break;
+          }
+          index = nextChatOrganizationQueueIndex(queue);
+          continue;
+        }
+        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 = adaptive && queue.pacing !== void 0 ? nextAdaptiveChatOrganizationIntervalSeconds(queue.pacing, Math.random()) : 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${adaptive ? " (adaptive)." : "."}`,
+            options
+          );
+          if (await waitForOrganizationInterval(waitSeconds, queuePath) === "paused") {
+            paused = true;
+            break;
+          }
+        }
       }
-      consecutiveRateLimitCooldowns = 0;
+      if (paused || halted) break;
+      if (options.verify !== false && summarizeChatOrganizationQueue(queue).pending === 0) {
+        queue = await verifyCompletedChatOrganizationQueue({
+          queue,
+          queuePath,
+          workspace,
+          options,
+          maxAttempts
+        });
+      }
+      const reopened = nextChatOrganizationQueueIndex(queue);
+      if (reopened === void 0) break;
       writeChatOrganizationProgress(
-        `Moving "${item.conversation}" -> ${item.project} (attempt ${item.attempts + 1}/${maxAttempts})`,
+        "The full-history audit found planned Conversations still loose; retrying them automatically.",
         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);
-      }
+      consecutiveRateLimitCooldowns = 0;
     }
   } finally {
     try {
-      await engine.shutdown({ closeBrowser: false });
+      if (!workspaceWasShutdown) await workspace.engine.shutdown({ closeBrowser: false });
     } finally {
       await releaseQueueLock();
     }
   }
   const summary = summarizeChatOrganizationQueue(queue);
-  writeChatOrganizationSummary({ queuePath, queue, options });
+  writeChatOrganizationSummary({ queuePath, queue, options, paused });
+  if (paused) process.exit(0);
   let exitCode = 0;
-  if (summary.failed > 0 || summary.pending > 0) exitCode = 1;
+  if (summary.failed > 0 || summary.pending > 0 || options.verify !== false && queue.verification?.complete !== true) {
+    exitCode = 1;
+  }
   process.exit(exitCode);
 };
 var writeArchiveOutcomes = (outcomes, options) => {
@@ -15820,7 +16299,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.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) => {
+  program.name("bridge").description("Terminal CLI that bridges ChatGPT or Gemini with local tools via MCP").version("0.6.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) => {
     if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
       command.outputHelp({ error: true });
       process.exitCode = 1;
@@ -15922,6 +16401,15 @@ var withWorkspaceFlags = (command) => {
     "Chrome user-data-dir to drive (parallel accounts; default shared bridge profile)"
   ).option("--json", "Emit JSON instead of human-readable lines");
 };
+var withOrganizationPacingFlags = (command) => {
+  return command.option(
+    "--interval <secondsOrRange>",
+    "Initial seconds between UI operations, fixed or random range such as 60-90 (default: 60)"
+  ).option("--no-adaptive", "Keep the initial interval instead of adapting to success/limits").option("--min-interval <seconds>", "Fastest adaptive base interval (default: 15)").option("--max-interval <seconds>", "Slowest adaptive base interval (default: 180)").option(
+    "--speed-up-after <count>",
+    "Successful moves before reducing the adaptive interval (default: 3)"
+  ).option("--cooldown <seconds>", "Seconds to wait after rate limiting (default: 600)").option("--max-attempts <count>", "Attempts per Conversation before failing (default: 4)").option("--no-verify", "Skip the exhaustive orphan scan when the queue finishes");
+};
 var registerWorkspaceCommands = (program) => {
   const project = program.command("project").description("Manage ChatGPT Projects (ChatGPT only)");
   withWorkspaceFlags(project.command("list")).description("List ChatGPT Projects").action(
@@ -15949,15 +16437,21 @@ 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(
+  const organize = withOrganizationPacingFlags(withWorkspaceFlags(chat.command("organize"))).description("Run a resumable, rate-safe Conversation organization queue").option(
     "--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(
+  ).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())
   );
+  withWorkspaceFlags(organize.command("status")).description("Show the latest organization queue state and adaptive pace").option("--queue <pathOrFingerprint>", "Select a queue instead of the latest one").action(
+    (_options, command) => runChatOrganizeStatus(command.optsWithGlobals())
+  );
+  withWorkspaceFlags(organize.command("pause")).description("Pause the latest queue after its active UI operation").option("--queue <pathOrFingerprint>", "Select a queue instead of the latest one").action(
+    (_options, command) => runChatOrganizePause(command.optsWithGlobals())
+  );
+  withOrganizationPacingFlags(withWorkspaceFlags(organize.command("resume"))).description("Resume the latest persisted organization queue").option("--queue <pathOrFingerprint>", "Select a queue instead of the latest one").action(
+    (_options, command) => runChatOrganizeResume(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())