takomi 2.1.39 → 2.1.40

package/assets/.agent/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.

package/docs/features/TakomiFlow_Portable_Plugin.md

@@ -26,6 +26,8 @@ Move the proven TakomiFlow Google Flow automation into this repository as the so
 - First-run agents should run `doctor`, then check whether `http://127.0.0.1:9222` is already serving Chrome DevTools Protocol.
 - If CDP is alive, agents should reuse it.
 - If CDP is missing, agents should start `trusted-chrome` and ask the user to sign into Google Flow manually.
+- For repeated generations, agents should reuse the current Flow project tab or pass `projectUrl`; clicking `New project` requires explicit `allowNewProject`.
+- If a project chat is stale or broken, agents should recover by creating a fresh chat inside the same project before asking for manual intervention.
 - Agents should prefer MCP tools when the harness supports MCP and the plugin is installed.
 - Agents should offer plugin installation/repair in Codex only after user approval.
 - Agents should fall back to CLI commands and standalone skill instructions when MCP or plugins are absent.
@@ -44,9 +46,10 @@ Move the proven TakomiFlow Google Flow automation into this repository as the so
 3. Agent checks for an existing trusted Chrome CDP instance.
 4. Agent reuses the instance or launches trusted Chrome.
 5. User signs in manually when needed.
-6. Agent prepares and validates a Flow request.
-7. Agent submits only with explicit spend approval.
-8. Agent records `projectUrl`, downloads assets, catalogs outputs, and writes a report.
+6. Agent resolves the target project from `projectUrl` or the current project tab.
+7. Agent prepares and validates a Flow request.
+8. Agent submits only with explicit spend approval.
+9. Agent records `projectUrl`, downloads assets, catalogs outputs, and writes a report.
 
 ## Database Schema
 
@@ -66,6 +69,7 @@ Persistent state is file-based:
 - A fresh computer can bootstrap by running the repo installer or directly invoking the plugin CLI from this repo.
 - Global/user writes must be explicit installer actions, not hidden side effects.
 - Project URLs must be captured for every generated Flow project.
+- New Flow projects are opt-in; project reuse is the default.
 
 ## Verification
 

package/docs/takomi-flow-onboarding.md

@@ -44,6 +44,16 @@ If all you have is a skill, use the bundled `takomi-flow` skill. It is the singl
    node plugins/takomi-flow/scripts/takomi-flow.mjs observe --allow-browser --cdp-url http://127.0.0.1:9222
    ```
 
+## Reusing One Flow Project
+
+For repeated generations, leave trusted Chrome open on the Flow project editor and reuse it:
+
+```powershell
+node plugins/takomi-flow/scripts/takomi-flow.mjs workflow --kind video --prompt "cinematic lab scene" --project-url "https://labs.google/fx/tools/flow/project/..." --submit --allow-browser --allow-spend --cdp-url http://127.0.0.1:9222
+```
+
+TakomiFlow does not click `New project` unless `--allow-new-project` is set. If a chat surface is stale or broken, it tries one fresh chat inside the same project before asking for manual help.
+
 ## MCP Or CLI
 
 - If the harness supports MCP, use TakomiFlow MCP tools.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takomi",
-  "version": "2.1.39",
+  "version": "2.1.40",
   "description": "🎯 Stop wrestling with AI. Start building with purpose. The artisan's toolkit for agent workflows, Codex skills, and original Takomi capabilities like 21st.dev integration.",
   "type": "module",
   "bin": {

package/plugins/takomi-flow/assets/capabilities.json

@@ -77,6 +77,36 @@
       "type": "boolean",
       "required": false,
       "description": "Explicit user approval to submit a generation that may spend Flow credits."
+    },
+    {
+      "name": "projectUrl",
+      "type": "string",
+      "required": false,
+      "description": "Existing Flow project URL to reuse instead of creating a new project."
+    },
+    {
+      "name": "reuseCurrentProject",
+      "type": "boolean",
+      "required": false,
+      "description": "Prefer the already open Flow project tab when attached to trusted Chrome."
+    },
+    {
+      "name": "allowNewProject",
+      "type": "boolean",
+      "required": false,
+      "description": "Permit clicking New project when no reusable project is available."
+    },
+    {
+      "name": "freshChatOnFailure",
+      "type": "boolean",
+      "required": false,
+      "description": "Recover stale or broken chat state by starting a fresh chat inside the same project."
+    },
+    {
+      "name": "editorWaitMs",
+      "type": "integer",
+      "required": false,
+      "description": "Override the Flow project editor readiness wait budget in milliseconds."
     }
   ],
   "sourceAssets": {
@@ -96,13 +126,15 @@
     "collection": "takomi-flow://schemas/collection"
   },
   "settingsCoverage": {
-    "automatic": ["prompt", "download folder", "metadata", "asset catalog", "video review frame extraction"],
+    "automatic": ["prompt", "project reuse", "same-project chat recovery", "download folder", "metadata", "asset catalog", "video review frame extraction"],
     "selectorDependent": ["mode", "aspectRatio", "durationSeconds", "modelHint", "sourceAssets", "variations"],
     "note": "Selector-dependent settings are preserved in settingsPlan metadata until live Flow controls are observed and tuned."
   },
   "safety": {
     "spendGuardDefault": false,
     "requiresAllowSpend": true,
+    "newProjectDefault": false,
+    "sameProjectChatRecovery": true,
     "bypassCaptcha": false,
     "bypassQuota": false,
     "automateCredentials": false

package/plugins/takomi-flow/assets/request.schema.json

@@ -60,6 +60,30 @@
       "items": { "type": "string" },
       "default": []
     },
+    "projectUrl": {
+      "type": "string",
+      "description": "Existing Google Flow project/editor URL to reuse for this generation."
+    },
+    "reuseCurrentProject": {
+      "type": "boolean",
+      "default": true,
+      "description": "When attached to Chrome, prefer an already open Flow project tab."
+    },
+    "allowNewProject": {
+      "type": "boolean",
+      "default": false,
+      "description": "Permit TakomiFlow to click New project when no reusable project/editor is available."
+    },
+    "freshChatOnFailure": {
+      "type": "boolean",
+      "default": true,
+      "description": "Try one same-project fresh chat recovery when prompt or submit controls are broken."
+    },
+    "editorWaitMs": {
+      "type": "integer",
+      "minimum": 1000,
+      "description": "Maximum time to wait for the Flow project editor to become usable."
+    },
     "notes": {
       "type": "string"
     }

package/plugins/takomi-flow/assets/result.schema.json

@@ -18,6 +18,7 @@
     "prompt": { "type": "string" },
     "flowUrl": { "type": "string" },
     "projectUrl": { "type": "string" },
+    "projectSession": { "type": "object" },
     "settingsPlan": { "type": "object" },
     "assets": {
       "type": "array",

package/plugins/takomi-flow/assets/templates/image-request.json

@@ -9,5 +9,9 @@
   "outputDir": "C:/Users/johno/.takomi-flow/runs",
   "allowSpend": false,
   "sourceAssets": [],
+  "projectUrl": "",
+  "reuseCurrentProject": true,
+  "allowNewProject": false,
+  "freshChatOnFailure": true,
   "notes": "Set allowSpend=true only after explicit user approval."
 }

package/plugins/takomi-flow/assets/templates/video-request.json

@@ -11,5 +11,9 @@
   "allowSpend": false,
   "extractFrames": 4,
   "sourceAssets": [],
+  "projectUrl": "",
+  "reuseCurrentProject": true,
+  "allowNewProject": false,
+  "freshChatOnFailure": true,
   "notes": "Set allowSpend=true only after explicit user approval."
 }

package/plugins/takomi-flow/references/flow-provider-contract.md

@@ -61,7 +61,15 @@ First-run agents should also check for an existing trusted Chrome DevTools endpo
 curl http://127.0.0.1:9222/json/version
 ```
 
-If the endpoint exists, reuse it with `--cdp-url http://127.0.0.1:9222`. If it does not exist, run `trusted-chrome` and ask the user to sign into Google Flow manually. MCP is optional; every MCP operation has a CLI equivalent through `node scripts/takomi-flow.mjs`.
+If the endpoint exists, reuse it with `--cdp-url http://127.0.0.1:9222`. If it does not exist, run `trusted-chrome` and ask the user to sign into Google Flow manually. Browser commands should start from trusted Chrome/CDP by default; Playwright-launched browser contexts are only an explicit fallback. MCP is optional; every MCP operation has a CLI equivalent through `node scripts/takomi-flow.mjs`.
+
+Repeated generations should reuse a Flow project instead of creating a new one. Pass `projectUrl` / `--project-url`, or attach to trusted Chrome while it is already on a `/project/` editor tab. TakomiFlow prefers the current project by default, does not click `New project` unless `allowNewProject=true` / `--allow-new-project` is set, and can recover a stale or broken chat by starting one fresh chat inside the same project.
+
+Flow should be treated as one active paid generation at a time. A gray preview placeholder plus scheduled, queue, or ready-shortly copy means the generation was accepted and is still in progress; do not classify it as failed or submit another paid generation until the current media is ready and downloaded.
+
+During polling, stale scheduled or failure text may remain visible after the current media is ready. The agent should probe for an open media view or ready media tile and exit as soon as the top toolbar Download control is available, instead of waiting for the full timeout.
+
+The Flow project name can be edited from the top-left header title/date-time input after opening the project.
 
 Run this after install or edits:
 
@@ -97,7 +105,8 @@ verified without pressing Create.
 Live video durations are `4`, `6`, `8`, and `10` seconds. If the agent asks for an unsupported
 duration, Flow may ask a follow-up. A verified generation also asked for explicit approval before
 spending 7 credits for one video. After output creation, opening the generated media reveals a
-toolbar `download` button that saves the MP4.
+top toolbar download icon. Aim for the button with tooltip, title, aria label, or visible text
+`Download`; clicking it saves the MP4.
 
 Use templates when starting a request from scratch:
 
@@ -137,6 +146,11 @@ Agents can read `takomi-flow://schemas/request` for the JSON Schema version of t
   "outputDir": "C:/Users/johno/.takomi-flow/runs",
   "allowSpend": false,
   "extractFrames": 4,
+  "projectUrl": "https://labs.google/fx/tools/flow/project/example",
+  "reuseCurrentProject": true,
+  "allowNewProject": false,
+  "freshChatOnFailure": true,
+  "editorWaitMs": 90000,
   "notes": "Optional agent notes for traceability."
 }
 ```
@@ -156,6 +170,11 @@ Agents can discover the same fields from `capabilities.requestFields`.
 - `allowSpend`: Must be `true` for generation submission.
 - `extractFrames`: Optional number of review frames to extract from downloaded videos.
 - `sourceAssets`: Optional array of local file paths for future image/video-to-video flows.
+- `projectUrl`: Optional existing Flow project/editor URL to reuse.
+- `reuseCurrentProject`: Prefer an already open Flow project tab when attached through CDP. Defaults to `true`.
+- `allowNewProject`: Permit clicking `New project` when no reusable project/editor exists. Defaults to `false`.
+- `freshChatOnFailure`: Try one fresh chat inside the same project when prompt or submit controls are broken. Defaults to `true`.
+- `editorWaitMs`: Optional wait budget for Flow editor readiness.
 
 ## Validation JSON
 
@@ -183,6 +202,10 @@ Agents can read `takomi-flow://schemas/result` for the JSON Schema version of ru
   "kind": "video",
   "prompt": "cinematic AI lab scene with practical lighting",
   "projectUrl": "https://labs.google/fx/tools/flow/project/example",
+  "projectSession": {
+    "projectUrl": "https://labs.google/fx/tools/flow/project/example",
+    "recovered": false
+  },
   "settingsPlan": {
     "requested": {
       "mode": "text-to-video",

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

@@ -51,6 +51,11 @@ function mcpSequence(request, options) {
     allowSpend: request.allowSpend,
     extractFrames: request.extractFrames,
     sourceAssets: request.sourceAssets,
+    projectUrl: request.projectUrl,
+    reuseCurrentProject: request.reuseCurrentProject,
+    allowNewProject: request.allowNewProject,
+    freshChatOnFailure: request.freshChatOnFailure,
+    editorWaitMs: request.editorWaitMs,
     submit: options.submit,
     allowBrowser: options.submit,
   };
@@ -95,6 +100,11 @@ function optionArgs(request, submit) {
   if (request.outputDir) args.push(`--output-dir "${escapeArg(request.outputDir)}"`);
   if (request.extractFrames) args.push(`--extract-frames ${request.extractFrames}`);
   if (request.sourceAssets.length) args.push(`--assets "${escapeArg(request.sourceAssets.join(','))}"`);
+  if (request.projectUrl) args.push(`--project-url "${escapeArg(request.projectUrl)}"`);
+  if (request.reuseCurrentProject) args.push('--reuse-current-project');
+  if (request.allowNewProject) args.push('--allow-new-project');
+  if (request.freshChatOnFailure === false) args.push('--fresh-chat-on-failure=false');
+  if (request.editorWaitMs) args.push(`--editor-wait-ms ${request.editorWaitMs}`);
   if (submit) args.push('--submit --allow-browser --allow-spend');
   return args.length ? ` ${args.join(' ')}` : '';
 }

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

@@ -6,7 +6,11 @@ export function parseArgs(argv) {
       args._.push(token);
       continue;
     }
-    const key = token.slice(2);
+    const [key, inlineValue] = token.slice(2).split(/=(.*)/s, 2);
+    if (inlineValue !== undefined) {
+      args[key] = inlineValue;
+      continue;
+    }
     const next = argv[i + 1];
     if (!next || next.startsWith('--')) {
       args[key] = true;
@@ -33,10 +37,10 @@ Usage:
   node scripts/takomi-flow.mjs observe [--profile-dir <path>] [--output-dir <path>] [--browser-channel chrome] [--cdp-url <url>] [--headless]
   node scripts/takomi-flow.mjs smoke [--profile-dir <path>] [--output-dir <path>] [--browser-channel chrome] [--cdp-url <url>]
   node scripts/takomi-flow.mjs prepare --kind <video|image> --prompt <text> [--variations 1]
-  node scripts/takomi-flow.mjs workflow --kind <video|image> --prompt <text> [--submit --allow-browser --allow-spend]
+  node scripts/takomi-flow.mjs workflow --kind <video|image> --prompt <text> [--project-url <url>] [--reuse-current-project] [--allow-new-project] [--submit --allow-browser --allow-spend]
   node scripts/takomi-flow.mjs template --kind <video|image> [--output-dir <path>]
   node scripts/takomi-flow.mjs validate --request <path>
-  node scripts/takomi-flow.mjs generate --request <path>
+  node scripts/takomi-flow.mjs generate --request <path> [--project-url <url>] [--reuse-current-project] [--allow-new-project]
   node scripts/takomi-flow.mjs selftest [--output-dir <path>]
   node scripts/takomi-flow.mjs inspect --run <run.json|run-dir>
   node scripts/takomi-flow.mjs latest [--output-dir <path>]
@@ -53,5 +57,10 @@ Google login note:
   If Google says the browser may not be secure, use trusted Chrome attach mode:
   node scripts/takomi-flow.mjs trusted-chrome
   Then log in manually and attach with --cdp-url http://127.0.0.1:9222.
+
+Project reuse:
+  Pass --project-url or attach Chrome while already on a Flow project. TakomiFlow will not click
+  New project unless --allow-new-project is set. Use --fresh-chat-on-failure=false to disable
+  same-project chat recovery.
 `);
 }

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

@@ -1,17 +1,21 @@
 import path from 'node:path';
 import { ensureDir } from './paths.mjs';
 import { loadPlaywright } from './playwright-loader.mjs';
+import { launchTrustedChrome } from './trusted-chrome.mjs';
+
+const DEFAULT_CDP_URL = 'http://127.0.0.1:9222';
 
 export async function launchFlowBrowser(options = {}) {
   const { chromium } = await loadPlaywright();
   const profileDir = ensureDir(path.resolve(options.profileDir));
   const downloadsDir = ensureDir(path.resolve(options.downloadsDir));
   const headless = options.headless === true;
-  if (options.cdpUrl) {
-    const browser = await chromium.connectOverCDP(options.cdpUrl);
+  const trustedCdpUrl = await trustedChromeCdpUrl(options);
+  if (trustedCdpUrl) {
+    const browser = await chromium.connectOverCDP(trustedCdpUrl);
     const context = browser.contexts()[0] || await browser.newContext({ acceptDownloads: true });
     const page = context.pages()[0] || await context.newPage();
-    return { browser, context, page, profileDir, downloadsDir, cdpUrl: options.cdpUrl, attached: true };
+    return { browser, context, page, profileDir, downloadsDir, cdpUrl: trustedCdpUrl, attached: true };
   }
   const channel = options.browserChannel || process.env.TAKOMI_FLOW_BROWSER_CHANNEL || defaultBrowserChannel();
   const context = await chromium.launchPersistentContext(profileDir, {
@@ -27,12 +31,47 @@ export async function launchFlowBrowser(options = {}) {
 
 export async function closeFlowBrowser(browser) {
   if (browser.attached) {
+    if (typeof browser.browser?.disconnect === 'function') {
+      browser.browser.disconnect();
+      return;
+    }
     await browser.browser?.close?.().catch(() => {});
     return;
   }
   await browser.context.close().catch(() => {});
 }
 
+async function trustedChromeCdpUrl(options) {
+  if (options.cdpUrl) return options.cdpUrl;
+  if (options.headless === true || options.usePlaywrightBrowser === true) return null;
+  if (await canConnect(DEFAULT_CDP_URL)) return DEFAULT_CDP_URL;
+  try {
+    const trusted = launchTrustedChrome({ url: options.url });
+    return await waitForCdp(trusted.cdpUrl);
+  } catch {
+    return null;
+  }
+}
+
+async function waitForCdp(cdpUrl) {
+  const timeoutMs = 10000;
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    if (await canConnect(cdpUrl)) return cdpUrl;
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+  return null;
+}
+
+async function canConnect(cdpUrl) {
+  try {
+    const response = await fetch(`${cdpUrl}/json/version`, { signal: AbortSignal.timeout(2000) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
 function defaultBrowserChannel() {
   if (process.platform === 'win32' || process.platform === 'darwin') return 'chrome';
   return undefined;

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

@@ -10,14 +10,20 @@ export async function handleCommand(command, args) {
   if (command === 'workflow') return printJson(await api.workflow({
     ...args,
     outputDir: args['output-dir'],
-    allowSpend: Boolean(args['allow-spend']),
+    allowSpend: booleanArg(args['allow-spend']),
     extractFrames: args['extract-frames'],
     sourceAssets: args.assets,
-    allowBrowser: Boolean(args['allow-browser']),
+    allowBrowser: booleanArg(args['allow-browser']),
     profileDir: args['profile-dir'],
     browserChannel: args['browser-channel'],
     cdpUrl: args['cdp-url'],
-    submit: Boolean(args.submit),
+    headless: booleanArg(args.headless),
+    submit: booleanArg(args.submit),
+    projectUrl: args['project-url'],
+    reuseCurrentProject: args['reuse-current-project'],
+    allowNewProject: args['allow-new-project'],
+    freshChatOnFailure: args['fresh-chat-on-failure'],
+    editorWaitMs: args['editor-wait-ms'],
   }));
   if (command === 'template') return template(args);
   if (command === 'examples') return printJson(api.examples({ name: args.name }));
@@ -26,7 +32,7 @@ export async function handleCommand(command, args) {
     chromePath: args['chrome-path'],
     port: args.port,
     url: args.url,
-    printCommand: Boolean(args['print-command']),
+    printCommand: booleanArg(args['print-command']),
   }));
   if (command === 'validate') return printJson(api.validate({ request: args.request }));
   if (command === 'bootstrap') return bootstrap(args);
@@ -40,10 +46,10 @@ export async function handleCommand(command, args) {
   if (command === 'plan') return printJson(api.plan({
     ...args,
     outputDir: args['output-dir'],
-    allowSpend: Boolean(args['allow-spend']),
+    allowSpend: booleanArg(args['allow-spend']),
     extractFrames: args['extract-frames'],
     sourceAssets: args.assets,
-    submit: Boolean(args.submit),
+    submit: booleanArg(args.submit),
     targetDir: args['target-dir'],
   }));
   if (command === 'observe') return observe(args);
@@ -53,7 +59,12 @@ export async function handleCommand(command, args) {
     profileDir: args['profile-dir'],
     browserChannel: args['browser-channel'],
     cdpUrl: args['cdp-url'],
-    headless: Boolean(args.headless),
+    headless: booleanArg(args.headless),
+    projectUrl: args['project-url'],
+    reuseCurrentProject: args['reuse-current-project'],
+    allowNewProject: args['allow-new-project'],
+    freshChatOnFailure: args['fresh-chat-on-failure'],
+    editorWaitMs: args['editor-wait-ms'],
   }));
   if (command === 'selftest') return printJson(await api.selftest({ outputDir: args['output-dir'] }));
   if (command === 'inspect') return printJson(api.inspect({ run: args.run }));
@@ -69,7 +80,7 @@ export async function handleCommand(command, args) {
     run: args.run,
     targetDir: args['target-dir'],
     frames: args.frames || 0,
-    includeFrames: Boolean(args['include-frames']),
+    includeFrames: booleanArg(args['include-frames']),
     reportPath: args['report-path'],
   }));
   if (command === 'report') return printJson(api.report({
@@ -81,13 +92,19 @@ export async function handleCommand(command, args) {
   throw new Error(`Unknown command: ${command}`);
 }
 
+function booleanArg(value) {
+  if (value === undefined || value === null || value === '') return false;
+  if (typeof value === 'boolean') return value;
+  return ['1', 'true', 'yes', 'on'].includes(String(value).toLowerCase());
+}
+
 async function observe(cliArgs) {
   printJson(await api.observe({
     profileDir: cliArgs['profile-dir'],
     outputDir: cliArgs['output-dir'],
     browserChannel: cliArgs['browser-channel'],
     cdpUrl: cliArgs['cdp-url'],
-    headless: Boolean(cliArgs.headless),
+    headless: booleanArg(cliArgs.headless),
   }));
 }
 
@@ -126,7 +143,7 @@ async function bootstrap(cliArgs) {
     downloadsDir: run.downloadsDir,
     browserChannel: cliArgs['browser-channel'],
     cdpUrl: cliArgs['cdp-url'],
-    headless: Boolean(cliArgs.headless),
+    headless: booleanArg(cliArgs.headless),
   });
   try {
     await openFlow(browser.page);
@@ -151,7 +168,7 @@ async function smoke(cliArgs) {
     downloadsDir: run.downloadsDir,
     browserChannel: cliArgs['browser-channel'],
     cdpUrl: cliArgs['cdp-url'],
-    headless: Boolean(cliArgs.headless),
+    headless: booleanArg(cliArgs.headless),
   });
   const result = baseResult('ok', run, { command: 'smoke', flowUrl: FLOW_URL, profileDir });
   try {

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

@@ -0,0 +1,39 @@
+export async function listMediaIds(page) {
+  const ids = await page.locator('img[src*="media.getMediaUrlRedirect"], video[src*="media.getMediaUrlRedirect"]').evaluateAll(items => (
+    items.map(item => mediaIdFromUrl(item.getAttribute('src') || item.src || '')).filter(Boolean)
+  )).catch(() => []);
+  return [...new Set(ids)];
+}
+
+export async function newMediaIds(page, baselineIds = []) {
+  const baseline = new Set(baselineIds);
+  return (await listMediaIds(page)).filter(id => !baseline.has(id));
+}
+
+export async function openGeneratedMediaById(page, mediaId) {
+  if (!mediaId) return false;
+  const candidates = [
+    page.locator(`img[src*="${mediaId}"]`).first(),
+    page.locator(`video[src*="${mediaId}"]`).first(),
+  ];
+  for (const locator of candidates) {
+    if (!(await locator.count().catch(() => 0))) continue;
+    try {
+      await locator.scrollIntoViewIfNeeded().catch(() => {});
+      await locator.click({ timeout: 10000, force: true });
+      await page.waitForTimeout(3000);
+      return true;
+    } catch {}
+  }
+  return false;
+}
+
+function mediaIdFromUrl(value) {
+  try {
+    const url = new URL(value, 'https://labs.google');
+    return url.searchParams.get('name');
+  } catch {
+    const match = /[?&]name=([^&]+)/.exec(value);
+    return match ? decodeURIComponent(match[1]) : null;
+  }
+}

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

@@ -1,4 +1,5 @@
-import { hasText, openGeneratedMedia } from './flow-ui.mjs';
+import { downloadButton, hasText, openGeneratedMedia } from './flow-ui.mjs';
+import { newMediaIds } from './flow-media.mjs';
 
 export async function handleGenerationFollowups(page, request) {
   if (await hasText(page, /which of these durations would you prefer/i)) {
@@ -14,7 +15,9 @@ export async function handleGenerationFollowups(page, request) {
 export async function waitForGenerationOutcome(page, request, options = {}) {
   const timeoutMs = Number(options.timeoutMs || process.env.TAKOMI_FLOW_WAIT_MS || 300000);
   const intervalMs = Number(options.intervalMs || process.env.TAKOMI_FLOW_POLL_MS || 5000);
+  const readyProbeMs = Number(options.readyProbeMs || process.env.TAKOMI_FLOW_READY_PROBE_MS || 45000);
   const started = Date.now();
+  let lastReadyProbeAt = 0;
   let approved = false;
   while (Date.now() - started < timeoutMs) {
     if (await hasText(page, /which of these durations would you prefer/i)) {
@@ -23,18 +26,26 @@ export async function waitForGenerationOutcome(page, request, options = {}) {
     if (await hasText(page, /costing\s+\d+\s+credits/i)) {
       approved = await clickApprove(page) || approved;
     }
-    if (await page.locator('button').filter({ hasText: /download\s*Download/i }).count().catch(() => 0)) {
-      return { status: 'download_ready', approved };
+    const freshMediaIds = await newMediaIds(page, options.baselineMediaIds || []);
+    const downloadReady = await downloadButton(page).count().catch(() => 0);
+    if (downloadReady && (!options.baselineMediaIds || freshMediaIds.length || /\/edit\//.test(page.url()))) {
+      return { status: 'download_ready', approved, mediaIds: freshMediaIds };
     }
-    if (await page.locator('img[src*="media.getMediaUrlRedirect"], video').count().catch(() => 0)) {
-      await openGeneratedMedia(page);
-      return { status: 'media_ready', approved };
+    if (freshMediaIds.length) {
+      await openGeneratedMedia(page, freshMediaIds);
+      return { status: 'media_ready', approved, mediaIds: freshMediaIds };
     }
-    if (await hasVisibleText(page, /\b\d{1,3}%\b|generating|waiting in the queue|been scheduled/i)) {
+    if (Date.now() - started >= readyProbeMs && Date.now() - lastReadyProbeAt >= readyProbeMs) {
+      lastReadyProbeAt = Date.now();
+      if (await probeDownloadableMedia(page, freshMediaIds)) {
+        return { status: 'download_ready', approved, mediaIds: freshMediaIds, probed: true };
+      }
+    }
+    if (await hasVisibleText(page, /\b\d{1,3}%\b|generating|currently in the queue|waiting in the queue|been scheduled|i['’]ve scheduled|ready for you shortly/i)) {
       await page.waitForTimeout(intervalMs);
       continue;
     }
-    if (await hasVisibleText(page, /failed|oops, something went wrong/i)) {
+    if (await hasText(page, /failed|oops, something went wrong/i)) {
       return { status: 'failed', approved };
     }
     await page.waitForTimeout(intervalMs);
@@ -42,6 +53,13 @@ export async function waitForGenerationOutcome(page, request, options = {}) {
   return { status: 'timeout', approved };
 }
 
+async function probeDownloadableMedia(page, mediaIds = []) {
+  if (await downloadButton(page).count().catch(() => 0)) return true;
+  await openGeneratedMedia(page, mediaIds);
+  await page.waitForTimeout(1000);
+  return (await downloadButton(page).count().catch(() => 0)) > 0;
+}
+
 async function hasVisibleText(page, pattern) {
   return page.locator('body').evaluate((body, source) => {
     const regex = new RegExp(source, 'i');
@@ -74,16 +92,23 @@ async function chooseDuration(page, requested) {
 
 async function clickApprove(page) {
   const candidates = [
-    page.getByText('Approve', { exact: true }).first(),
-    page.locator('div,button,[role="button"]').filter({ hasText: /^\s*check\s*Approve\s*$/i }).first(),
-    page.locator('text=Approve').first(),
+    page.getByRole('button', { name: /^Approve$/i }).last(),
+    page.locator('button').filter({ hasText: /^Approve$/i }).last(),
+    page.locator('[role="button"]').filter({ hasText: /^Approve$/i }).last(),
+    page.locator('div,button,[role="button"]').filter({ hasText: /^\s*check\s*Approve\s*$/i }).last(),
   ];
   for (const locator of candidates) {
     if (!(await locator.count().catch(() => 0))) continue;
     try {
       await locator.click({ timeout: 10000, force: true });
       await page.waitForTimeout(1000);
-      return true;
+      const stillVisible = await page.getByRole('button', { name: /^Approve$/i })
+        .last()
+        .isVisible({ timeout: 1000 })
+        .catch(() => false);
+      if (!stillVisible || await hasVisibleText(page, /generating|currently in the queue|waiting in the queue|been scheduled|i['’]ve scheduled|ready for you shortly/i)) {
+        return true;
+      }
     } catch {}
   }
   return false;