takomi 2.1.39 → 2.1.40

package/plugins/takomi-flow/scripts/lib/flow-project-session.mjs

@@ -0,0 +1,153 @@
+import { FLOW_URL } from './paths.mjs';
+import { hasText, openFlow } from './flow-ui.mjs';
+
+export async function prepareProjectEditor(browser, request, result) {
+  const diagnostics = { projectUrl: undefined, recovered: false };
+  const waitMs = Number(request.editorWaitMs || process.env.TAKOMI_FLOW_EDITOR_WAIT_MS || 90000);
+
+  let mayUseCurrentProject = false;
+  if (request.projectUrl) {
+    browser.page = await openProjectUrl(browser, request.projectUrl);
+    mayUseCurrentProject = true;
+  } else if (request.reuseCurrentProject) {
+    browser.page = await findProjectPage(browser) || browser.page;
+    mayUseCurrentProject = true;
+  }
+
+  if (mayUseCurrentProject && isProjectUrl(browser.page.url())) {
+    const ready = await waitForProjectEditor(browser.page, waitMs);
+    diagnostics.projectUrl = browser.page.url();
+    return { ok: ready.ok, diagnostics, manualActions: ready.manualActions };
+  }
+
+  await openFlow(browser.page);
+  if (request.allowNewProject) {
+    const opened = await clickNewProject(browser.page);
+    if (!opened) {
+      return { ok: false, diagnostics, manualActions: ['New project button was not found. Open a Flow project manually, then retry with --project-url.'] };
+    }
+    const ready = await waitForProjectEditor(browser.page, waitMs);
+    diagnostics.projectUrl = browser.page.url();
+    return { ok: ready.ok, diagnostics, manualActions: ready.manualActions };
+  }
+
+  Object.assign(result, await currentFlowState(browser.page));
+  return {
+    ok: false,
+    diagnostics,
+    manualActions: ['Open an existing Flow project, pass --project-url, or set --allow-new-project to create a new Flow project.'],
+  };
+}
+
+export async function recoverFreshChat(page, request) {
+  if (!request.freshChatOnFailure) return { recovered: false, reason: 'freshChatOnFailure is disabled.' };
+  if (!isProjectUrl(page.url())) return { recovered: false, reason: 'Current page is not a Flow project.' };
+  const before = page.url();
+  await leaveMediaEditor(page);
+  const candidates = [
+    page.getByRole('button', { name: /new chat|new session|start new chat|new generation/i }).first(),
+    page.locator('button,[role="button"]').filter({ hasText: /new chat|new session|start new chat|new generation/i }).first(),
+    page.locator('[aria-label*="New chat" i], [aria-label*="New session" i], [aria-label*="Start new" i]').first(),
+  ];
+  for (const locator of candidates) {
+    if (!(await locator.count().catch(() => 0))) continue;
+    try {
+      await locator.click({ timeout: 10000 });
+      await page.waitForTimeout(1500);
+      const ready = await waitForProjectEditor(page, request.editorWaitMs || 60000);
+      return { recovered: ready.ok, reason: ready.ok ? 'fresh chat opened' : ready.manualActions.join(' ') };
+    } catch {}
+  }
+  if (await hasText(page, /oops|something went wrong|try again|chat failed/i)) {
+    await page.goto(projectBaseUrl(before), { waitUntil: 'domcontentloaded', timeout: 90000 }).catch(() => {});
+    const ready = await waitForProjectEditor(page, request.editorWaitMs || 60000);
+    return { recovered: ready.ok, reason: ready.ok ? 'project reloaded' : ready.manualActions.join(' ') };
+  }
+  return { recovered: false, reason: 'No same-project fresh chat control was found.' };
+}
+
+async function openProjectUrl(browser, projectUrl) {
+  const page = (await findProjectPage(browser, projectUrl)) || browser.page;
+  await page.goto(projectBaseUrl(projectUrl), { waitUntil: 'domcontentloaded', timeout: 90000 });
+  await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => {});
+  await leaveMediaEditor(page);
+  return page;
+}
+
+async function findProjectPage(browser, exactUrl = undefined) {
+  const pages = browser.context.pages();
+  const match = pages.find(page => exactUrl ? page.url() === exactUrl : isProjectUrl(page.url()));
+  return match || null;
+}
+
+async function clickNewProject(page) {
+  const candidates = [
+    page.getByRole('button', { name: /new project/i }).first(),
+    page.locator('button').filter({ hasText: /new project/i }).first(),
+    page.getByText('New project').first(),
+  ];
+  for (const locator of candidates) {
+    if (!(await locator.count().catch(() => 0))) continue;
+    try {
+      await locator.click({ timeout: 10000 });
+      await page.waitForURL(/\/project\//, { timeout: 30000 }).catch(() => {});
+      await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => {});
+      return isProjectUrl(page.url());
+    } catch {}
+  }
+  return false;
+}
+
+async function waitForProjectEditor(page, timeoutMs) {
+  await leaveMediaEditor(page);
+  await page.waitForLoadState('domcontentloaded', { timeout: 30000 }).catch(() => {});
+  await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => {});
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const state = await currentFlowState(page);
+    if (state.manualActions.length) return { ok: false, manualActions: state.manualActions };
+    const hasEditorText = await hasText(page, /what do you want to create|start creating|add media/i);
+    const inputCount = await page.locator('div[role="textbox"], textarea:not(.g-recaptcha-response)').count().catch(() => 0);
+    if (hasEditorText && inputCount > 0) return { ok: true, manualActions: [] };
+    await page.waitForTimeout(1000);
+  }
+  return { ok: false, manualActions: ['Flow project editor did not become ready before the wait timeout.'] };
+}
+
+async function leaveMediaEditor(page) {
+  if (!/\/edit\//.test(page.url())) return;
+  const candidates = [
+    page.getByRole('button', { name: /^Done$/i }).last(),
+    page.locator('button').filter({ hasText: /^Done$/i }).last(),
+    page.getByRole('button', { name: /back/i }).first(),
+    page.locator('button').filter({ hasText: /arrow_back|back/i }).first(),
+  ];
+  for (const locator of candidates) {
+    if (!(await locator.count().catch(() => 0))) continue;
+    try {
+      await locator.click({ timeout: 10000, force: true });
+      await page.waitForURL(url => !/\/edit\//.test(url.toString()), { timeout: 15000 }).catch(() => {});
+      if (!/\/edit\//.test(page.url())) return;
+    } catch {}
+  }
+  await page.goto(projectBaseUrl(page.url()), { waitUntil: 'domcontentloaded', timeout: 90000 }).catch(() => {});
+}
+
+async function currentFlowState(page) {
+  const text = (await page.locator('body').innerText({ timeout: 5000 }).catch(() => '')).toLowerCase();
+  const manualActions = [];
+  if (text.includes('sign in') || text.includes('log in')) manualActions.push('Sign into Google/Flow in the opened browser.');
+  if (text.includes('captcha') || text.includes('verify')) manualActions.push('Complete the verification challenge in the browser.');
+  if (/quota|usage limit|not enough credits|insufficient credits|out of credits/.test(text)) {
+    manualActions.push('Review Flow quota or credits message in the browser.');
+  }
+  return { manualActions };
+}
+
+function isProjectUrl(url) {
+  return /\/project\//.test(url || '');
+}
+
+function projectBaseUrl(url) {
+  return String(url || '').replace(/\/edit\/[^/?#]+.*/, '');
+}

package/plugins/takomi-flow/scripts/lib/flow-ui.mjs

@@ -1,10 +1,11 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { FLOW_URL } from './paths.mjs';
+import { openGeneratedMediaById } from './flow-media.mjs';
 
 export async function openFlow(page) {
   await page.goto(FLOW_URL, { waitUntil: 'domcontentloaded', timeout: 90000 });
-  await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => {});
+  await page.waitForLoadState('networkidle', { timeout: 8000 }).catch(() => {});
 }
 
 export async function capture(page, run, name) {
@@ -43,7 +44,7 @@ export async function ensureProjectEditor(page) {
     try {
       await locator.click({ timeout: 10000 });
       await page.waitForURL(/\/project\//, { timeout: 30000 }).catch(() => {});
-      await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => {});
+      await page.waitForLoadState('networkidle', { timeout: 8000 }).catch(() => {});
       return page.url().includes('/project/') && await waitForProjectEditor(page);
     } catch {}
   }
@@ -51,7 +52,7 @@ export async function ensureProjectEditor(page) {
 }
 
 async function waitForProjectEditor(page) {
-  await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => {});
+  await page.waitForLoadState('networkidle', { timeout: 8000 }).catch(() => {});
   const ready = page.locator('body').filter({ hasText: /what do you want to create|start creating|add media/i });
   await ready.waitFor({ state: 'visible', timeout: 60000 }).catch(() => {});
   return (await page.locator('div[role="textbox"], textarea:not(.g-recaptcha-response)').count().catch(() => 0)) > 0;
@@ -59,23 +60,43 @@ async function waitForProjectEditor(page) {
 
 export async function fillPrompt(page, prompt) {
   const candidates = [
-    page.locator('div[role="textbox"]').filter({ hasText: /what do you want to create/i }).last(),
-    page.locator('div[role="textbox"]').last(),
-    page.locator('textarea:not(.g-recaptcha-response):not([name*="recaptcha"])').last(),
+    page.locator('textarea:not(.g-recaptcha-response):not([name*="recaptcha"]):visible').last(),
+    page.locator('[contenteditable="true"][role="textbox"]:visible').last(),
+    page.locator('div[role="textbox"]:visible').last(),
   ];
   for (const locator of candidates) {
     if (!(await locator.count().catch(() => 0))) continue;
     try {
       await locator.click({ timeout: 8000 });
-      await page.keyboard.press(process.platform === 'darwin' ? 'Meta+A' : 'Control+A').catch(() => {});
-      await page.keyboard.type(prompt, { delay: 2 });
-      const matched = await page.locator('body').filter({ hasText: prompt.slice(0, 40) }).count().catch(() => 0);
-      if (matched) return true;
+      if (!(await fillEditable(locator, page, prompt))) continue;
+      if (await editableContains(locator, prompt)) return true;
     } catch {}
   }
   return false;
 }
 
+async function fillEditable(locator, page, prompt) {
+  if (await locator.fill(prompt, { timeout: 8000 }).then(() => true).catch(() => false)) return true;
+  await page.keyboard.press(process.platform === 'darwin' ? 'Meta+A' : 'Control+A').catch(() => {});
+  await page.keyboard.insertText(prompt).catch(async () => {
+    await page.keyboard.type(prompt, { delay: 5 });
+  });
+  return true;
+}
+
+async function editableContains(locator, prompt) {
+  const expected = compactText(prompt).slice(0, 80);
+  const actual = await locator.evaluate(element => {
+    const value = element.value || element.innerText || element.textContent || '';
+    return value.replace(/\s+/g, ' ').trim();
+  }).catch(() => '');
+  return compactText(actual).includes(expected);
+}
+
+function compactText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
 export async function submitGeneration(page) {
   const preferred = [
     page.locator('button').filter({ hasText: /arrow_forward\s*Create/i }).last(),
@@ -85,6 +106,7 @@ export async function submitGeneration(page) {
   for (const button of preferred) {
     if (!(await button.count().catch(() => 0))) continue;
     try {
+      if (await button.isDisabled().catch(() => false)) continue;
       await button.click({ timeout: 8000 });
       return true;
     } catch {}
@@ -97,6 +119,7 @@ export async function submitGeneration(page) {
   for (const button of buttons) {
     if (!(await button.count().catch(() => 0))) continue;
     try {
+      if (await button.isDisabled().catch(() => false)) continue;
       await button.click({ timeout: 8000 });
       return true;
     } catch {}
@@ -104,17 +127,19 @@ export async function submitGeneration(page) {
   return false;
 }
 
-export async function tryDownloadAssets(page, run, maxDownloads = 1) {
+export async function tryDownloadAssets(page, run, maxDownloads = 1, options = {}) {
   const assets = [];
-  await openGeneratedMedia(page);
+  const allowRenderedImageFallback = options.allowRenderedImageFallback !== false;
+  await openGeneratedMedia(page, options.mediaIds || []);
   for (let i = 0; i < maxDownloads; i += 1) {
-    const button = page.locator('button').filter({ hasText: /download\s*Download|download/i }).first();
+    const button = downloadButton(page);
     if (!(await button.count().catch(() => 0))) break;
     const [completed] = await Promise.all([
       page.waitForEvent('download', { timeout: 30000 }).catch(() => null),
       button.click({ timeout: 5000 }).catch(() => null),
     ]);
     if (!completed) {
+      if (!allowRenderedImageFallback) break;
       const imagePath = await downloadLargestRenderedImage(page, run, i).catch(() => null);
       if (!imagePath) break;
       assets.push(imagePath);
@@ -141,8 +166,11 @@ async function downloadLargestRenderedImage(page, run, index) {
   return filePath;
 }
 
-export async function openGeneratedMedia(page) {
-  if (await page.locator('button').filter({ hasText: /download\s*Download/i }).count().catch(() => 0)) return true;
+export async function openGeneratedMedia(page, mediaIds = []) {
+  if (await downloadButton(page).count().catch(() => 0)) return true;
+  for (const mediaId of mediaIds) {
+    if (await openGeneratedMediaById(page, mediaId)) return true;
+  }
   const candidates = [
     page.getByAltText(/video thumbnail|generated image/i).first(),
     page.locator('img[src*="media.getMediaUrlRedirect"]').last(),
@@ -163,3 +191,14 @@ export async function openGeneratedMedia(page) {
 export async function hasText(page, pattern) {
   return (await page.locator('body').filter({ hasText: pattern }).count().catch(() => 0)) > 0;
 }
+
+export function downloadButton(page) {
+  return page.locator([
+    'button[aria-label*="Download" i]',
+    '[role="button"][aria-label*="Download" i]',
+    'button[title*="Download" i]',
+    '[role="button"][title*="Download" i]',
+    'button:has-text("download")',
+    '[role="button"]:has-text("download")',
+  ].join(', ')).first();
+}

package/plugins/takomi-flow/scripts/lib/generation.mjs

@@ -3,14 +3,16 @@ import { defaultProfileDir, FLOW_URL, readJson, resolvePath } from './paths.mjs'
 import { normalizeRequest, canSpend } from './request.mjs';
 import { closeFlowBrowser, launchFlowBrowser } from './browser.mjs';
 import { createRun, baseResult, saveResult } from './result.mjs';
-import { capture, ensureProjectEditor, fillPrompt, inspectFlowState, openFlow, submitGeneration, tryDownloadAssets } from './flow-ui.mjs';
+import { capture, fillPrompt, hasText, submitGeneration, tryDownloadAssets } from './flow-ui.mjs';
 import { handleGenerationFollowups, waitForGenerationOutcome } from './flow-outcome.mjs';
 import { catalogAssets } from './media.mjs';
 import { createSettingsPlan } from './settings-plan.mjs';
+import { prepareProjectEditor, recoverFreshChat } from './flow-project-session.mjs';
+import { listMediaIds } from './flow-media.mjs';
 
 export async function generateFromRequest(args = {}) {
   if (!args.request) throw new Error('generate requires a request path.');
-  const request = normalizeRequest(readJson(path.resolve(args.request)));
+  const request = normalizeRequest({ ...readJson(path.resolve(args.request)), ...requestOverrides(args) });
   const run = createRun(request, 'generate');
   const result = baseResult('blocked', run, {
     command: 'generate',
@@ -32,41 +34,42 @@ export async function generateFromRequest(args = {}) {
     headless: Boolean(args.headless),
   });
   try {
-    await openFlow(browser.page);
-    result.screenshots.push(await capture(browser.page, run, 'before-prompt'));
-    const state = await inspectFlowState(browser.page);
-    if (state.manualActions.length) {
-      requireManual(result, state.manualActions);
+    result.screenshots.push(await capture(browser.page, run, 'before-project-resolve'));
+    const project = await prepareProjectEditor(browser, request, result);
+    result.projectSession = project.diagnostics;
+    if (!project.ok) {
+      requireManual(result, project.manualActions);
       return result;
     }
-    if (!(await ensureProjectEditor(browser.page))) {
-      requireManual(result, ['New project button or project editor was not found. Open a Flow project manually, then retry with --cdp-url.']);
-      return result;
-    }
-    result.projectUrl = browser.page.url();
+    result.projectUrl = project.diagnostics.projectUrl || browser.page.url();
     result.screenshots.push(await capture(browser.page, run, 'project-editor'));
-    if (!(await fillPrompt(browser.page, request.prompt))) {
-      requireManual(result, ['Prompt box was not found. Update Flow selectors or paste the prompt manually.']);
-      return result;
+    const maxAttempts = request.freshChatOnFailure === false ? 1 : 2;
+    result.generationAttempts = [];
+    if (request.freshChatOnFailure !== false && await hasText(browser.page, /failed|oops, something went wrong/i)) {
+      await recoverFreshChat(browser.page, request);
     }
-    result.screenshots.push(await capture(browser.page, run, 'prompt-filled'));
-    if (!(await submitGeneration(browser.page))) {
-      requireManual(result, ['Generate/Create button was not found. Submit manually in the opened browser.']);
-      return result;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      const attemptResult = await runGenerationAttempt(browser.page, request, run, attempt);
+      result.generationAttempts.push({ attempt, outcome: attemptResult.outcome, recovered: attemptResult.recovered });
+      result.projectUrl = browser.page.url();
+      result.generationOutcome = attemptResult.outcome;
+      result.screenshots.push(await capture(browser.page, run, attempt === 1 ? 'after-wait' : `after-wait-${attempt}`));
+      result.assets = attemptResult.assets;
+      if (result.assets.length) break;
+      if (attempt < maxAttempts && shouldRetryOutcome(attemptResult.outcome)) {
+        const recovery = await recoverFreshChat(browser.page, request);
+        if (recovery.recovered) {
+          result.generationAttempts[result.generationAttempts.length - 1].recovered = true;
+          continue;
+        }
+      }
+      break;
     }
-    result.projectUrl = browser.page.url();
-    await handleGenerationFollowups(browser.page, request);
-    result.generationOutcome = await waitForGenerationOutcome(browser.page, request);
-    result.projectUrl = browser.page.url();
-    result.screenshots.push(await capture(browser.page, run, 'after-wait'));
-    result.assets = await tryDownloadAssets(browser.page, run, request.variations);
     if (result.assets.length) {
       result.assetCatalogPath = (await catalogAssets(run, result.assets, { frames: request.extractFrames || 0 })).catalogPath;
     }
     result.status = result.assets.length ? 'downloaded' : 'manual_action_required';
-    if (!result.assets.length) {
-      result.manualActions.push(nextActionForOutcome(result.generationOutcome));
-    }
+    if (!result.assets.length) result.manualActions.push(nextActionForOutcome(result.generationOutcome));
     return result;
   } catch (error) {
     result.status = 'failed';
@@ -78,6 +81,100 @@ export async function generateFromRequest(args = {}) {
   }
 }
 
+function requestOverrides(args) {
+  return Object.fromEntries([
+    ['projectUrl', args.projectUrl],
+    ['reuseCurrentProject', args.reuseCurrentProject],
+    ['allowNewProject', args.allowNewProject],
+    ['freshChatOnFailure', args.freshChatOnFailure],
+    ['editorWaitMs', args.editorWaitMs],
+  ].filter(([, value]) => value !== undefined));
+}
+
+async function fillPromptWithRecovery(page, request) {
+  if (await fillPrompt(page, request.prompt)) return true;
+  const recovery = await recoverFreshChat(page, request);
+  return recovery.recovered && await fillPrompt(page, request.prompt);
+}
+
+async function submitWithRecovery(page, request) {
+  if (await submitGeneration(page)) return true;
+  const recovery = await recoverFreshChat(page, request);
+  return recovery.recovered
+    && await fillPrompt(page, request.prompt)
+    && await submitGeneration(page);
+}
+
+async function runGenerationAttempt(page, request, run, attempt) {
+  const baselineMediaIds = await listMediaIds(page);
+  const pending = await pendingGenerationState(page, request);
+  if (pending.matchesRequest) {
+    await handleGenerationFollowups(page, request);
+    const outcome = await waitForGenerationOutcome(page, request, { baselineMediaIds });
+    const assets = await downloadAttemptAssets(page, run, request, outcome);
+    return { outcome, assets, recovered: false };
+  }
+  if (pending.exists) {
+    return {
+      outcome: { status: 'active_generation_pending' },
+      assets: [],
+      recovered: false,
+    };
+  }
+  if (!(await fillPromptWithRecovery(page, request))) {
+    return {
+      outcome: { status: 'prompt_not_found' },
+      assets: [],
+      recovered: false,
+    };
+  }
+  await capture(page, run, attempt === 1 ? 'prompt-filled' : `prompt-filled-${attempt}`);
+  if (!(await submitWithRecovery(page, request))) {
+    return {
+      outcome: { status: 'submit_not_found' },
+      assets: [],
+      recovered: false,
+    };
+  }
+  await handleGenerationFollowups(page, request);
+  const outcome = await waitForGenerationOutcome(page, request, { baselineMediaIds });
+  const assets = await downloadAttemptAssets(page, run, request, outcome);
+  return { outcome, assets, recovered: false };
+}
+
+async function downloadAttemptAssets(page, run, request, outcome) {
+  const assets = await tryDownloadAssets(page, run, request.variations, {
+    mediaIds: outcome.mediaIds || [],
+    allowRenderedImageFallback: request.kind !== 'video',
+  });
+  if (assets.length && !['download_ready', 'media_ready'].includes(outcome.status)) {
+    outcome.status = 'download_ready';
+    outcome.recoveredFromStaleText = true;
+  }
+  return assets;
+}
+
+function shouldRetryOutcome(outcome = {}) {
+  return ['failed', 'prompt_not_found', 'submit_not_found'].includes(outcome.status);
+}
+
+async function pendingGenerationState(page, request) {
+  const pendingPattern = /would you like me to kick off|costing\s+\d+\s+credits|currently in the queue|waiting in the queue|been scheduled|i['’]ve scheduled|ready for you shortly/i;
+  const text = await page.locator('body').innerText({ timeout: 5000 }).catch(() => '');
+  const exists = pendingPattern.test(text);
+  if (!exists) return { exists: false, matchesRequest: false };
+  const pageText = compactText(text).toLowerCase();
+  const promptText = compactText(request.prompt).toLowerCase();
+  const corePrompt = compactText(request.prompt.replace(/^create exactly one.*?not still images\.\s*/i, '')).toLowerCase();
+  const matchesRequest = pageText.includes(promptText.slice(0, 80))
+    || (corePrompt.length > 20 && pageText.includes(corePrompt.slice(0, 80)));
+  return { exists, matchesRequest };
+}
+
+function compactText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
 function requireManual(result, actions) {
   result.status = 'manual_action_required';
   result.manualActions.push(...actions);
@@ -85,6 +182,9 @@ function requireManual(result, actions) {
 
 function nextActionForOutcome(outcome = {}) {
   if (outcome.status === 'failed') return 'Flow reported generation failure. Inspect the browser/run screenshots.';
+  if (outcome.status === 'active_generation_pending') return 'A different Flow generation is already pending. Wait for it to finish before submitting another prompt.';
+  if (outcome.status === 'prompt_not_found') return 'Prompt box was not found. Update Flow selectors or paste the prompt manually.';
+  if (outcome.status === 'submit_not_found') return 'Generate/Create button was not found. Submit manually in the opened browser.';
   if (outcome.status === 'timeout') return 'Generation did not finish before the wait timeout. Leave trusted Chrome open and run inspect/observe again.';
   return 'Generation may still be running or download controls changed. Inspect the browser/run screenshots.';
 }

package/plugins/takomi-flow/scripts/lib/mcp-tools.mjs

@@ -28,6 +28,11 @@ export function registerTools(server) {
     allowSpend: z.boolean().optional(),
     extractFrames: z.number().int().nonnegative().optional(),
     sourceAssets: z.array(z.string()).optional(),
+    projectUrl: z.string().optional(),
+    reuseCurrentProject: z.boolean().optional(),
+    allowNewProject: z.boolean().optional(),
+    freshChatOnFailure: z.boolean().optional(),
+    editorWaitMs: z.number().int().positive().optional(),
     submit: z.boolean().optional(),
     targetDir: z.string().optional(),
   }, args => api.plan(args));
@@ -53,6 +58,11 @@ function registerRequestTools(register) {
     allowSpend: z.boolean().optional(),
     extractFrames: z.number().int().nonnegative().optional(),
     sourceAssets: z.array(z.string()).optional(),
+    projectUrl: z.string().optional(),
+    reuseCurrentProject: z.boolean().optional(),
+    allowNewProject: z.boolean().optional(),
+    freshChatOnFailure: z.boolean().optional(),
+    editorWaitMs: z.number().int().positive().optional(),
     notes: z.string().optional(),
   };
   register('takomi_flow_prepare', 'Create a prepared request JSON file for a Flow image or video generation.', requestShape, args => api.prepare(args));
@@ -86,6 +96,11 @@ function registerBrowserTools(register) {
     browserChannel: z.string().optional(),
     cdpUrl: z.string().optional(),
     headless: z.boolean().optional(),
+    projectUrl: z.string().optional(),
+    reuseCurrentProject: z.boolean().optional(),
+    allowNewProject: z.boolean().optional(),
+    freshChatOnFailure: z.boolean().optional(),
+    editorWaitMs: z.number().int().positive().optional(),
   }, args => requireBrowser(args, () => api.generate(args)));
 }
 

package/plugins/takomi-flow/scripts/lib/request-validator.mjs

@@ -39,6 +39,12 @@ export function validateRequest(raw, requestPath = undefined) {
   if (normalized.aspectRatio && !capabilities.aspectRatios.includes(normalized.aspectRatio)) {
     warnings.push(`Aspect ratio "${normalized.aspectRatio}" is not in listed options.`);
   }
+  if (normalized.projectUrl && !isFlowProjectUrl(normalized.projectUrl)) {
+    errors.push(`Project URL must be a Google Flow project URL: ${normalized.projectUrl}`);
+  }
+  if (normalized.editorWaitMs !== undefined && normalized.editorWaitMs < 1000) {
+    errors.push('editorWaitMs must be at least 1000 milliseconds.');
+  }
   for (const asset of normalized.sourceAssets) {
     if (!fs.existsSync(path.resolve(asset))) {
       errors.push(`Source asset does not exist: ${asset}`);
@@ -56,3 +62,12 @@ export function validateRequest(raw, requestPath = undefined) {
     warnings,
   };
 }
+
+function isFlowProjectUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.hostname === 'labs.google' && url.pathname.includes('/fx/tools/flow/project/');
+  } catch {
+    return false;
+  }
+}

package/plugins/takomi-flow/scripts/lib/request.mjs

@@ -23,9 +23,14 @@ export function normalizeRequest(input) {
     mode: input.mode || (kind === 'video' ? 'text-to-video' : 'text-to-image'),
     modelHint: input.modelHint || input.model || 'best-available',
     outputDir: path.resolve(input.outputDir || input['output-dir'] || defaultRunsDir()),
-    allowSpend: Boolean(input.allowSpend || input['allow-spend'] || false),
+    allowSpend: toOptionalBoolean(input.allowSpend ?? input['allow-spend'], false),
     extractFrames: Math.max(0, Number.parseInt(input.extractFrames || input['extract-frames'] || '0', 10) || 0),
     sourceAssets: normalizeList(input.sourceAssets || input.assets),
+    projectUrl: input.projectUrl || input['project-url'] || undefined,
+    reuseCurrentProject: toOptionalBoolean(input.reuseCurrentProject ?? input['reuse-current-project'], true),
+    allowNewProject: toOptionalBoolean(input.allowNewProject ?? input['allow-new-project'], false),
+    freshChatOnFailure: toOptionalBoolean(input.freshChatOnFailure ?? input['fresh-chat-on-failure'], true),
+    editorWaitMs: toOptionalNumber(input.editorWaitMs || input['editor-wait-ms']),
     notes: input.notes || undefined,
   };
 }
@@ -48,6 +53,12 @@ function toOptionalNumber(value) {
   return Number.isFinite(parsed) ? parsed : undefined;
 }
 
+function toOptionalBoolean(value, defaultValue) {
+  if (value === undefined || value === null || value === '') return defaultValue;
+  if (typeof value === 'boolean') return value;
+  return ['1', 'true', 'yes', 'on'].includes(String(value).toLowerCase());
+}
+
 function normalizeList(value) {
   if (!value) return [];
   if (Array.isArray(value)) return value;

package/plugins/takomi-flow/scripts/lib/settings-plan.mjs

@@ -8,8 +8,13 @@ export function createSettingsPlan(request) {
     modelHint: request.modelHint,
     extractFrames: request.extractFrames,
     sourceAssets: request.sourceAssets || [],
+    projectUrl: request.projectUrl,
+    reuseCurrentProject: request.reuseCurrentProject,
+    allowNewProject: request.allowNewProject,
+    freshChatOnFailure: request.freshChatOnFailure,
+    editorWaitMs: request.editorWaitMs,
   };
-  const automatic = ['prompt', 'download folder', 'metadata', 'asset catalog'];
+  const automatic = ['prompt', 'project reuse', 'same-project chat recovery', 'download folder', 'metadata', 'asset catalog'];
   if (request.extractFrames > 0) automatic.push('video review frame extraction after download');
   return {
     schemaVersion: 1,

package/plugins/takomi-flow/scripts/mcp-smoke.mjs

@@ -6,10 +6,12 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 
 const client = new Client({ name: 'takomi-flow-smoke', version: '0.1.0' });
+const pluginRoot = path.resolve(import.meta.dirname, '..');
 const reviewRunDir = path.join(os.tmpdir(), 'takomi-flow-mcp-smoke-review');
 const transport = new StdioClientTransport({
   command: 'node',
   args: ['scripts/mcp-server.mjs'],
+  cwd: pluginRoot,
 });
 
 try {

package/plugins/takomi-flow/skills/takomi-flow/SKILL.md

@@ -69,7 +69,6 @@ If Git is unavailable, ask the user to download the VibeCode Protocol Suite ZIP
 ## Agent Tool Surface
 
 Prefer MCP tools when they are available in the active Codex session. Use the CLI commands as the stable fallback.
-
 MCP tools:
 
 - `takomi_flow_capabilities`
@@ -116,7 +115,13 @@ Browser-opening MCP tools require `allowBrowser=true`. Generation still requires
 - Use public Flow UI automation only.
 - Do not bypass captchas, login challenges, quotas, safety checks, rate limits, or hidden endpoints.
 - Prefer headed mode first so the user can handle Google login, consent, quota, and safety prompts.
+- Browser commands should start from trusted Chrome/CDP by default; use Playwright-launched browsers only as an explicit fallback.
 - Never submit a paid generation unless the user explicitly requested it and `allowSpend` or `TAKOMI_FLOW_ALLOW_SPEND=true` is set.
+- Reuse the current Flow project or pass `projectUrl`; create new projects only when the user asks or `allowNewProject` is set.
+- Treat Flow as one active generation at a time: wait for the current approved generation to finish and download it before submitting another paid generation.
+- A gray preview placeholder with scheduled, queue, or ready-shortly copy means the generation is in progress, not failed.
+- If stale scheduled or failure text remains after media is ready, probe/open the generated media and use the top toolbar Download control instead of waiting for the full timeout.
+- Download generated media by opening the media and clicking the top toolbar `Download` icon/button.
 - Keep credentials out of prompts, logs, metadata, and project files.
 - Store run artifacts in a predictable folder and report the exact result paths.
 
@@ -138,6 +143,7 @@ node scripts/takomi-flow.mjs smoke
 node scripts/takomi-flow.mjs template --kind video
 node scripts/takomi-flow.mjs prepare --kind video --prompt "cinematic AI lab scene" --variations 2
 node scripts/takomi-flow.mjs workflow --kind video --prompt "cinematic AI lab scene" --variations 2
+node scripts/takomi-flow.mjs workflow --kind video --prompt "cinematic AI lab scene" --project-url "<Flow project URL>" --reuse-current-project
 node scripts/takomi-flow.mjs validate --request output/takomi-flow/requests/<file>.json
 node scripts/takomi-flow.mjs generate --request output/takomi-flow/requests/<file>.json
 node scripts/takomi-flow.mjs inspect --run output/takomi-flow/<runId>/run.json
@@ -173,6 +179,9 @@ Important defaults:
    - Keep that Chrome window open and use `--cdp-url http://127.0.0.1:9222` for observe/generate.
    - A signed-in dashboard should show project cards and a `New project` button during `observe`.
    - The project editor prompt textbox currently contains `What do you want to create?`.
+   - Leave Chrome on the desired project editor or pass `--project-url`; TakomiFlow does not click `New project` unless `--allow-new-project` is set.
+   - Rename a project by editing the top-left header title/date-time input.
+   - If the chat breaks, keep the same project and let `freshChatOnFailure` try one fresh chat before manual recovery.
    - Prefer video durations `4`, `6`, `8`, or `10` seconds to avoid a Flow follow-up question.
    - Use `bootstrap` only when Google accepts the launched browser.
    - Ask the user to log into Google Flow manually in the opened browser.