takomi 2.1.37 → 2.1.39

package/plugins/takomi-flow/scripts/lib/trusted-chrome.mjs

@@ -0,0 +1,67 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import { ensureDir, FLOW_URL } from './paths.mjs';
+
+export function defaultTrustedProfileDir() {
+  return path.join(os.homedir(), '.takomi-flow', 'trusted-chrome-profile');
+}
+
+export function launchTrustedChrome(args = {}) {
+  const port = Number.parseInt(args.port || '9222', 10) || 9222;
+  const userDataDir = ensureDir(path.resolve(args.profileDir || defaultTrustedProfileDir()));
+  const executable = args.chromePath || findChromeExecutable();
+  const chromeArgs = [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${userDataDir}`,
+    '--no-first-run',
+    '--new-window',
+    args.url || FLOW_URL,
+  ];
+  if (args.printCommand) {
+    return result({ executable, chromeArgs, port, userDataDir, launched: false });
+  }
+  const child = spawn(executable, chromeArgs, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: false,
+  });
+  child.unref();
+  return result({ executable, chromeArgs, port, userDataDir, launched: true, processId: child.pid });
+}
+
+function result(data) {
+  return {
+    schemaVersion: 1,
+    status: 'ok',
+    cdpUrl: `http://127.0.0.1:${data.port}`,
+    loginUrl: data.chromeArgs[data.chromeArgs.length - 1],
+    userDataDir: data.userDataDir,
+    executable: data.executable,
+    args: data.chromeArgs,
+    launched: data.launched,
+    processId: data.processId,
+    nextActions: [
+      'Log into Google Flow manually in the opened Chrome window.',
+      `After login, use --cdp-url http://127.0.0.1:${data.port} with observe, smoke, workflow, or generate.`,
+      'Keep this Chrome window open while TakomiFlow attaches to it.',
+    ],
+  };
+}
+
+function findChromeExecutable() {
+  const candidates = process.platform === 'win32' ? [
+    path.join(process.env.PROGRAMFILES || 'C:\\Program Files', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+    path.join(process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+    path.join(process.env.LOCALAPPDATA || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+  ] : [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/usr/bin/google-chrome',
+    '/usr/bin/google-chrome-stable',
+    '/usr/bin/chromium-browser',
+  ];
+  const found = candidates.find(candidate => candidate && fs.existsSync(candidate));
+  if (!found) throw new Error('Could not find Chrome. Pass --chrome-path <path-to-chrome>.');
+  return found;
+}

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

@@ -0,0 +1,56 @@
+import { createPreparedRequest } from './request.mjs';
+import { validateRequestFile } from './request-validator.mjs';
+import { generateFromRequest } from './generation.mjs';
+import { createSettingsPlan } from './settings-plan.mjs';
+
+export async function runWorkflow(args = {}) {
+  const { request, requestPath } = createPreparedRequest(args);
+  const validation = validateRequestFile(requestPath);
+  const result = {
+    schemaVersion: 1,
+    status: validation.status === 'ok' ? 'prepared' : 'failed',
+    requestPath,
+    request,
+    settingsPlan: createSettingsPlan(request),
+    validation,
+    generation: null,
+    nextActions: nextActions(args, validation),
+  };
+  if (validation.status !== 'ok' || !args.submit) return result;
+  if (!args.allowBrowser) {
+    result.status = 'blocked';
+    result.nextActions = ['Set allowBrowser=true to permit opening Flow for generation.'];
+    return result;
+  }
+  result.generation = await generateFromRequest({
+    request: requestPath,
+    profileDir: args.profileDir,
+    browserChannel: args.browserChannel,
+    cdpUrl: args.cdpUrl,
+    headless: Boolean(args.headless),
+  });
+  result.status = result.generation.status;
+  result.nextActions = afterGeneration(result.generation);
+  return result;
+}
+
+function nextActions(args, validation) {
+  if (validation.status !== 'ok') return ['Fix request validation errors before opening Flow.'];
+  if (!args.submit) {
+    return [
+      'Review the prepared request file.',
+      'Run generate with explicit spend approval when ready.',
+    ];
+  }
+  if (!args.allowBrowser) return ['Set allowBrowser=true to permit opening Flow for generation.'];
+  return ['Generation was requested; TakomiFlow will still enforce the spend guard.'];
+}
+
+function afterGeneration(generation) {
+  const actions = [];
+  if (generation.manualActions?.length) actions.push(...generation.manualActions);
+  if (generation.errors?.length) actions.push('Review generation errors in run metadata.');
+  if (generation.assets?.length) actions.push('Run assets/report to catalog downloads and create a handoff.');
+  if (!actions.length) actions.push('Inspect the run metadata and screenshots.');
+  return actions;
+}

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

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerPrompts } from './lib/mcp-prompts.mjs';
+import { registerResources } from './lib/mcp-resources.mjs';
+import { registerTools } from './lib/mcp-tools.mjs';
+
+const server = new McpServer({
+  name: 'takomi-flow',
+  version: '0.1.0',
+});
+
+registerTools(server);
+registerResources(server);
+registerPrompts(server);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

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

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+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 reviewRunDir = path.join(os.tmpdir(), 'takomi-flow-mcp-smoke-review');
+const transport = new StdioClientTransport({
+  command: 'node',
+  args: ['scripts/mcp-server.mjs'],
+});
+
+try {
+  prepareReviewRun(reviewRunDir);
+  await client.connect(transport);
+  const tools = await client.listTools();
+  const capabilities = await client.callTool({
+    name: 'takomi_flow_capabilities',
+    arguments: {},
+  });
+  const audit = await client.callTool({
+    name: 'takomi_flow_audit',
+    arguments: { outputDir: 'C:/Users/johno/.takomi-flow/runs', limit: 3 },
+  });
+  const examples = await client.callTool({
+    name: 'takomi_flow_examples',
+    arguments: { name: 'cinematic-video' },
+  });
+  const plan = await client.callTool({
+    name: 'takomi_flow_plan',
+    arguments: {
+      kind: 'video',
+      prompt: 'MCP smoke test planned video prompt',
+      variations: 2,
+      extractFrames: 2,
+    },
+  });
+  const workflow = await client.callTool({
+    name: 'takomi_flow_workflow',
+    arguments: {
+      kind: 'image',
+      prompt: 'MCP smoke test image prompt',
+      variations: 1,
+      outputDir: 'C:/Users/johno/.takomi-flow/runs',
+    },
+  });
+  const observeBlocked = await client.callTool({
+    name: 'takomi_flow_observe',
+    arguments: { allowBrowser: false },
+  });
+  const runs = await client.callTool({
+    name: 'takomi_flow_runs',
+    arguments: { outputDir: 'C:/Users/johno/.takomi-flow/runs', limit: 3 },
+  });
+  const report = await client.callTool({
+    name: 'takomi_flow_report',
+    arguments: {
+      outputDir: 'C:/Users/johno/.takomi-flow/runs',
+      limit: 3,
+      reportPath: 'C:/Users/johno/.takomi-flow/runs/mcp-smoke-report.md',
+    },
+  });
+  const review = await client.callTool({
+    name: 'takomi_flow_review',
+    arguments: { run: reviewRunDir, frames: 0 },
+  });
+  const collect = await client.callTool({
+    name: 'takomi_flow_collect',
+    arguments: {
+      run: reviewRunDir,
+      targetDir: path.join(reviewRunDir, 'collected'),
+      frames: 0,
+    },
+  });
+  const resources = await client.listResources();
+  const contract = await client.readResource({ uri: 'takomi-flow://contract' });
+  const examplesResource = await client.readResource({ uri: 'takomi-flow://examples' });
+  const requestSchema = await client.readResource({ uri: 'takomi-flow://schemas/request' });
+  const resultSchema = await client.readResource({ uri: 'takomi-flow://schemas/result' });
+  const collectionSchema = await client.readResource({ uri: 'takomi-flow://schemas/collection' });
+  const prompts = await client.listPrompts();
+  const videoPrompt = await client.getPrompt({
+    name: 'takomi_flow_video_workflow',
+    arguments: { topic: 'test video', variations: '1' },
+  });
+  const reviewPrompt = await client.getPrompt({
+    name: 'takomi_flow_review_workflow',
+    arguments: { run: reviewRunDir, frames: '2' },
+  });
+  const collectPrompt = await client.getPrompt({
+    name: 'takomi_flow_collect_workflow',
+    arguments: { run: reviewRunDir, targetDir: path.join(reviewRunDir, 'collected') },
+  });
+  console.log(JSON.stringify({
+    status: 'ok',
+    toolCount: tools.tools.length,
+    toolNames: tools.tools.map(tool => tool.name),
+    capabilitiesStatus: capabilities.structuredContent?.provider || 'unknown',
+    auditStatus: audit.structuredContent?.status || 'unknown',
+    examplesStatus: examples.structuredContent?.example?.name || 'unknown',
+    planStatus: plan.structuredContent?.status || 'unknown',
+    workflowStatus: workflow.structuredContent?.status || 'unknown',
+    observeBlockedStatus: observeBlocked.structuredContent?.status || 'unknown',
+    runsStatus: runs.structuredContent?.schemaVersion || 'unknown',
+    reportStatus: report.structuredContent?.status || 'unknown',
+    reviewStatus: review.structuredContent?.status || 'unknown',
+    collectStatus: collect.structuredContent?.status || 'unknown',
+    resourceCount: resources.resources.length,
+    contractBytes: contract.contents?.[0]?.text?.length || 0,
+    examplesBytes: examplesResource.contents?.[0]?.text?.length || 0,
+    requestSchemaBytes: requestSchema.contents?.[0]?.text?.length || 0,
+    resultSchemaBytes: resultSchema.contents?.[0]?.text?.length || 0,
+    collectionSchemaBytes: collectionSchema.contents?.[0]?.text?.length || 0,
+    promptCount: prompts.prompts.length,
+    videoPromptMessages: videoPrompt.messages?.length || 0,
+    reviewPromptMessages: reviewPrompt.messages?.length || 0,
+    collectPromptMessages: collectPrompt.messages?.length || 0,
+  }, null, 2));
+} finally {
+  await client.close();
+}
+
+function prepareReviewRun(runDir) {
+  const downloadsDir = path.join(runDir, 'downloads');
+  fs.mkdirSync(downloadsDir, { recursive: true });
+  const assetPath = path.join(downloadsDir, 'sample.png');
+  fs.writeFileSync(assetPath, 'takomi-flow-smoke-image');
+  fs.writeFileSync(path.join(runDir, 'run.json'), `${JSON.stringify({
+    schemaVersion: 1,
+    status: 'downloaded',
+    runId: 'mcp-smoke-review',
+    command: 'mcp-smoke',
+    kind: 'image',
+    assets: [assetPath],
+    screenshots: [],
+    errors: [],
+    manualActions: [],
+    metadataPath: path.join(runDir, 'run.json'),
+  }, null, 2)}\n`);
+}

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

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { parseArgs, printUsage } from './lib/args.mjs';
+import { handleCommand } from './lib/commands.mjs';
+
+const args = parseArgs(process.argv.slice(2));
+const command = args._[0];
+
+try {
+  if (!command || args.help) {
+    printUsage();
+  } else {
+    await handleCommand(command, args);
+  }
+} catch (error) {
+  console.error(`[TakomiFlow] ${error.message}`);
+  process.exitCode = 1;
+}

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

@@ -0,0 +1,235 @@
+---
+name: takomi-flow
+description: "Use when Codex needs to operate Google Flow as a reusable agent tool through safe browser automation: bootstrap/login a persistent Flow profile, smoke-check access without spending credits, prepare image or video generation request files, run guarded Flow generations, download assets, inspect results, or integrate Flow assets into a video pipeline. Trigger for TakomiFlow, Flow browser provider, use Google Flow credits, Flow automation, generate with Flow, or agent-first Flow workflows."
+---
+
+# TakomiFlow
+
+TakomiFlow is an agent-first workflow for using Google Flow through visible browser automation. Treat it as a local tool layer for Codex agents, not as an unofficial API.
+
+## Runtime Choice
+
+Use this skill as the single TakomiFlow entrypoint.
+
+1. If the active harness is Codex and the user approves plugin installation or repair, install or reuse the global Codex plugin and then prefer its MCP tools.
+2. If the plugin already exists, verify it with `doctor` and use MCP tools when the session exposes them.
+3. If MCP is unavailable, use the TakomiFlow CLI directly.
+4. If the harness is not Codex or does not support plugins, keep using this skill as the workflow guide and call the CLI when shell access exists.
+5. If there is no shell access, provide the exact commands as a handoff checklist and stop.
+
+Never install, update, or write to global plugin locations without telling the user what path will be changed and getting approval.
+
+## Install Or Repair The Plugin
+
+Only follow this path when the user asks to install/repair TakomiFlow or agrees after you detect that the Codex plugin is missing.
+
+1. Check for an existing user plugin:
+
+   ```powershell
+   Test-Path "$HOME\plugins\takomi-flow"
+   Test-Path "$HOME\.agents\plugins\marketplace.json"
+   ```
+
+2. If the plugin exists, inspect it:
+
+   ```powershell
+   node "$HOME\plugins\takomi-flow\scripts\takomi-flow.mjs" doctor
+   ```
+
+   If this works, do not reinstall unless the user asked to update or repair.
+
+3. If missing, locate or get the VibeCode Protocol Suite:
+
+   ```powershell
+   git clone https://github.com/JStaRFilms/VibeCode-Protocol-Suite "$HOME\Source\VibeCode-Protocol-Suite"
+   ```
+
+4. Install the plugin globally for the current user:
+
+   ```powershell
+   cd "$HOME\Source\VibeCode-Protocol-Suite"
+   .\scripts\install-takomi-flow.ps1 -InstallDependencies
+   ```
+
+   This copies/registers the plugin at:
+
+   ```text
+   ~/plugins/takomi-flow
+   ~/.agents/plugins/marketplace.json
+   ```
+
+5. Verify:
+
+   ```powershell
+   node "$HOME\plugins\takomi-flow\scripts\takomi-flow.mjs" doctor
+   ```
+
+If Git is unavailable, ask the user to download the VibeCode Protocol Suite ZIP and run the installer from the extracted repo. MCP is optional; the CLI works without MCP.
+
+## 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`
+- `takomi_flow_doctor`
+- `takomi_flow_audit`
+- `takomi_flow_examples`
+- `takomi_flow_template`
+- `takomi_flow_prepare`
+- `takomi_flow_workflow`
+- `takomi_flow_validate`
+- `takomi_flow_observe`
+- `takomi_flow_generate`
+- `takomi_flow_selftest`
+- `takomi_flow_inspect`
+- `takomi_flow_latest`
+- `takomi_flow_runs`
+- `takomi_flow_assets`
+- `takomi_flow_review`
+- `takomi_flow_collect`
+- `takomi_flow_report`
+
+MCP resources:
+
+- `takomi-flow://contract`
+- `takomi-flow://capabilities`
+- `takomi-flow://examples`
+- `takomi-flow://schemas/request`
+- `takomi-flow://schemas/result`
+- `takomi-flow://schemas/collection`
+- `takomi-flow://templates/video`
+- `takomi-flow://templates/image`
+
+MCP prompts:
+
+- `takomi_flow_video_workflow`
+- `takomi_flow_image_workflow`
+- `takomi_flow_review_workflow`
+- `takomi_flow_collect_workflow`
+
+Browser-opening MCP tools require `allowBrowser=true`. Generation still requires request `allowSpend=true` or `TAKOMI_FLOW_ALLOW_SPEND=true` before it can submit.
+
+## Core Rules
+
+- 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.
+- Never submit a paid generation unless the user explicitly requested it and `allowSpend` or `TAKOMI_FLOW_ALLOW_SPEND=true` is set.
+- Keep credentials out of prompts, logs, metadata, and project files.
+- Store run artifacts in a predictable folder and report the exact result paths.
+
+## Commands
+
+From the plugin root:
+
+```bash
+node scripts/takomi-flow.mjs bootstrap
+node scripts/takomi-flow.mjs bootstrap --browser-channel chrome
+node scripts/takomi-flow.mjs trusted-chrome
+node scripts/takomi-flow.mjs doctor
+node scripts/takomi-flow.mjs audit
+node scripts/takomi-flow.mjs selftest
+node scripts/takomi-flow.mjs capabilities
+node scripts/takomi-flow.mjs examples
+node scripts/takomi-flow.mjs observe
+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 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
+node scripts/takomi-flow.mjs latest --output-dir output/takomi-flow
+node scripts/takomi-flow.mjs runs --output-dir output/takomi-flow --limit 10
+node scripts/takomi-flow.mjs assets --run output/takomi-flow/<runId>/run.json --frames 4
+node scripts/takomi-flow.mjs review --run output/takomi-flow/<runId>/run.json --frames 4
+node scripts/takomi-flow.mjs collect --run output/takomi-flow/<runId>/run.json --target-dir output/pipeline-assets --frames 4 --include-frames
+node scripts/takomi-flow.mjs report --run output/takomi-flow/<runId>/run.json
+node scripts/takomi-flow.mjs report --output-dir output/takomi-flow --limit 10
+```
+
+Important defaults:
+
+- Profile dir: `%USERPROFILE%\.takomi-flow\browser-profile`
+- Output dir: `%USERPROFILE%\.takomi-flow\runs`
+- Browser channel: real Chrome by default on Windows/macOS when available
+- Headed mode: enabled by default
+- Spend guard: disabled by default
+
+## Workflow
+
+1. First-run/runtime detection:
+   - Run `doctor` first when the installation state is unknown.
+   - Check whether `http://127.0.0.1:9222/json/version` is already reachable.
+   - If the CDP endpoint is reachable, reuse it with `--cdp-url http://127.0.0.1:9222`.
+   - If the CDP endpoint is not reachable, launch `trusted-chrome`.
+   - If MCP tools are unavailable, use CLI commands from this plugin root.
+   - If the harness has no MCP support, TakomiFlow still works through shell commands.
+2. Bootstrap login:
+   - Prefer `trusted-chrome` for Google login because Google may reject Playwright-launched browsers.
+   - Log into Google Flow manually in the opened trusted Chrome window.
+   - 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?`.
+   - 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.
+   - Do not automate credential entry.
+3. Doctor check:
+   - Run `doctor` before browser work when reliability matters.
+   - Report missing Playwright, FFmpeg, profile, or output path issues.
+4. Readiness audit:
+   - Run `audit` when an agent needs safe next actions and gated actions in one payload.
+   - Treat missing profile as a login/bootstrap gate, not a script failure.
+5. Self-test:
+   - Run `selftest` after install, after edits, or before trusting TakomiFlow in a new project.
+   - Confirm no-spend request preparation, validation, spend guard behavior, and media extraction work.
+6. Capability discovery:
+   - Run `capabilities` when an agent needs supported kinds, modes, request fields, variations, aspect ratios, outputs, and safety rules.
+   - Run `examples` or read `takomi-flow://examples` when an agent needs known-good request patterns.
+7. Observe Flow UI:
+   - Run `observe` after bootstrap to capture current Flow controls, text inputs, buttons, screenshots, and manual-action state without submitting generation.
+   - Use observation output before changing selectors.
+8. Smoke check:
+   - Run `smoke` to open Flow and save status metadata/screenshots.
+   - Confirm no generation was submitted.
+9. Prepare request:
+   - Use `template --kind video` or `template --kind image` when an agent needs a known-good request skeleton.
+   - Use `takomi-flow://schemas/request` when an agent needs a machine-readable request shape.
+   - Use `takomi-flow://schemas/result` and `takomi-flow://schemas/collection` to consume run metadata and collected outputs.
+   - Use `prepare` to create a JSON request for image or video generation.
+   - Use `workflow` when an agent should prepare, validate, and optionally submit from one call.
+   - Include prompt, variations, aspect ratio, duration, model/mode hints, and output folder.
+   - Read `settingsPlan` to see which requested Flow options are automatic versus selector-dependent.
+10. Validate request:
+   - Run `validate --request <file>` before `generate`.
+   - Fix failed source assets, invalid kinds, or malformed request JSON before opening Flow.
+   - Treat spend-guard warnings as expected unless the user explicitly approved spending credits.
+11. Generate:
+   - Run `generate` only when spend is explicitly allowed.
+   - Expect Flow to ask for credit approval; approve only when `allowSpend=true` or the user explicitly approved spending.
+   - Stop for manual intervention if the UI asks for login, captcha, quota, safety, or consent.
+   - Preserve `settingsPlan` in the run metadata so downstream agents can see requested options.
+12. Inspect:
+   - Read `run.json`, `status.json`, screenshots, and downloaded assets.
+   - Record and report `projectUrl` for every created Flow project so future runs can reuse or inspect it.
+   - Prefer `runs`, `inspect`, or `latest` for agent-readable summaries.
+   - Use `assets --frames 4` to catalog downloaded images/videos and extract review frames.
+   - Use `review --frames 4` to combine inspect, asset cataloging, frame extraction, and Markdown report creation.
+   - Use `collect` to copy reviewed outputs into a downstream project folder with a manifest.
+   - Use `report` to write a Markdown handoff for a single run or recent history.
+   - Report successes, errors, and manual next steps.
+
+## Request Shape
+
+Read `references/flow-provider-contract.md` before modifying scripts or integrating TakomiFlow into another project.
+
+## Integration Guidance
+
+- For a project pipeline, call TakomiFlow as an external provider and pass prompt/settings by JSON file.
+- Keep Flow-specific selectors isolated in `scripts/lib/flow-ui.mjs`.
+- Keep generation follow-up polling, credit approval, and completion/failure detection in `scripts/lib/flow-outcome.mjs`.
+- Keep request/result parsing stable so other agents can use it without reading script internals.
+- If a file approaches 200 lines, split it before adding more responsibilities.

package/plugins/takomi-flow/skills/takomi-flow/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "TakomiFlow"
+  short_description: "Safe Google Flow browser automation."
+  default_prompt: "Use $takomi-flow to bootstrap, smoke-check, prepare, or run a guarded Google Flow asset generation workflow."
+
+policy:
+  allow_implicit_invocation: true

package/scripts/install-takomi-flow.ps1

@@ -0,0 +1,85 @@
+param(
+  [string]$RepoRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path,
+  [string]$UserHome = $HOME,
+  [switch]$InstallDependencies,
+  [switch]$NoCopy
+)
+
+$ErrorActionPreference = 'Stop'
+
+function Write-Step($Message) {
+  Write-Host "[takomi-flow] $Message"
+}
+
+function Copy-Plugin($Source, $Destination) {
+  if ($NoCopy) {
+    Write-Step "Skipping copy because -NoCopy was set."
+    return
+  }
+  if (Test-Path -LiteralPath $Destination) {
+    Remove-Item -LiteralPath $Destination -Recurse -Force
+  }
+  New-Item -ItemType Directory -Force -Path (Split-Path -Parent $Destination) | Out-Null
+  Copy-Item -LiteralPath $Source -Destination $Destination -Recurse
+  $nodeModules = Join-Path $Destination 'node_modules'
+  if (Test-Path -LiteralPath $nodeModules) {
+    Remove-Item -LiteralPath $nodeModules -Recurse -Force
+  }
+}
+
+function Ensure-Marketplace($MarketplacePath) {
+  New-Item -ItemType Directory -Force -Path (Split-Path -Parent $MarketplacePath) | Out-Null
+  if (Test-Path -LiteralPath $MarketplacePath) {
+    $payload = Get-Content -LiteralPath $MarketplacePath -Raw | ConvertFrom-Json
+  } else {
+    $payload = [ordered]@{
+      name = 'jstarfilmsstudios'
+      interface = @{ displayName = 'J StaR Films Studios' }
+      plugins = @()
+    }
+  }
+  $entry = [ordered]@{
+    name = 'takomi-flow'
+    source = @{ source = 'local'; path = './plugins/takomi-flow' }
+    policy = @{ installation = 'AVAILABLE'; authentication = 'ON_INSTALL' }
+    category = 'Productivity'
+  }
+  $plugins = @($payload.plugins | Where-Object { $_.name -ne 'takomi-flow' })
+  $payload.plugins = @($plugins + $entry)
+  $payload | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath $MarketplacePath -Encoding UTF8
+}
+
+function Install-NodeDeps($PluginPath) {
+  if (-not $InstallDependencies) {
+    Write-Step "Skipping dependency install. Run with -InstallDependencies when needed."
+    return
+  }
+  Push-Location $PluginPath
+  try {
+    if (Get-Command pnpm -ErrorAction SilentlyContinue) {
+      pnpm install
+    } else {
+      npm install
+    }
+  } finally {
+    Pop-Location
+  }
+}
+
+$sourcePlugin = Join-Path $RepoRoot 'plugins/takomi-flow'
+$targetPlugin = Join-Path $UserHome 'plugins/takomi-flow'
+$marketplace = Join-Path $UserHome '.agents/plugins/marketplace.json'
+
+if (-not (Test-Path -LiteralPath $sourcePlugin)) {
+  throw "TakomiFlow source plugin was not found: $sourcePlugin"
+}
+
+Write-Step "Source: $sourcePlugin"
+Write-Step "Target: $targetPlugin"
+Copy-Plugin $sourcePlugin $targetPlugin
+Ensure-Marketplace $marketplace
+Install-NodeDeps $targetPlugin
+
+Write-Step "Registered marketplace: $marketplace"
+Write-Step "First run: node $targetPlugin/scripts/takomi-flow.mjs doctor"
+Write-Step "Trusted Chrome: node $targetPlugin/scripts/takomi-flow.mjs trusted-chrome"

package/src/pi-takomi-core/orchestration.ts

@@ -181,7 +181,7 @@ function describeWorkflowPhase(workflow?: OrchestratorTask["workflow"]): string
     case "vibe-genesis":
       return "Product framing and blueprint generation";
     case "vibe-design":
-      return "Design planning and interaction definition";
+      return "UI/UX design, visual system, and interaction definition";
     case "vibe-build":
       return "Implementation and delivery";
     default:

package/src/pi-takomi-core/workflows.ts

@@ -1,14 +1,14 @@
 import type { TakomiWorkflowId, WorkflowDefinition } from "./types";
 
-const VIBE_GENESIS_PLAYBOOK = `Genesis fallback summary: author the project foundation in markdown, with PRD, FR issues, coding guidelines, and a clean handoff. For broad projects, Genesis may also create the orchestration session that carries the work into Design and Build. The runtime should prefer .pi/prompts/genesis-prompt.md; this string exists only as a compatibility fallback.`;
-const VIBE_DESIGN_PLAYBOOK = `Design fallback summary: define the visual system, mockups, and builder constraints in markdown. The runtime should prefer .pi/prompts/design-prompt.md; this string exists only as a compatibility fallback.`;
+const VIBE_GENESIS_PLAYBOOK = `Genesis fallback summary: author the project foundation in markdown, with PRD, FR issues, coding guidelines, architecture decisions, data models, API contracts, implementation strategy, and a clean handoff. For broad projects, Genesis may also create the orchestration session that carries the work into UI/UX Design and Build. The runtime should prefer .pi/prompts/genesis-prompt.md; this string exists only as a compatibility fallback.`;
+const VIBE_DESIGN_PLAYBOOK = `Design fallback summary: define UI/UX only: visual system, user journeys, interaction flows, mockups, accessibility expectations, and frontend builder constraints in markdown. Technical architecture, data models, and API contracts belong in Genesis or Architect planning. The runtime should prefer .pi/prompts/design-prompt.md; this string exists only as a compatibility fallback.`;
 const VIBE_BUILD_PLAYBOOK = `Build fallback summary: implement the approved plan with FR-driven work, strict verification, mockup adherence, and explicit handoff reporting. The runtime should prefer .pi/prompts/build-prompt.md; this string exists only as a compatibility fallback.`;
 export const WORKFLOWS: Record<TakomiWorkflowId, WorkflowDefinition> = {
   "vibe-genesis": {
     id: "vibe-genesis",
     stage: "genesis",
     title: "Vibe Genesis",
-    purpose: "Initialize a project with markdown blueprints and a clean handoff into design or build. See .pi/prompts/genesis-prompt.md for the canonical behavior.",
+    purpose: "Initialize a project with markdown blueprints, technical planning, and a clean handoff into UI/UX Design or Build. See .pi/prompts/genesis-prompt.md for the canonical behavior.",
     preferredRole: "architect",
     preferredAgent: "architect",
     nextStage: "design",
@@ -18,7 +18,7 @@ export const WORKFLOWS: Record<TakomiWorkflowId, WorkflowDefinition> = {
     id: "vibe-design",
     stage: "design",
     title: "Vibe Design",
-    purpose: "Define the visual system, sitemap, mockups, and builder constraints before implementation begins. See .pi/prompts/design-prompt.md for the canonical behavior.",
+    purpose: "Define UI/UX only: visual system, user journeys, interaction flows, mockups, accessibility expectations, and frontend builder constraints before implementation begins. See .pi/prompts/design-prompt.md for the canonical behavior.",
     preferredRole: "design",
     preferredAgent: "designer",
     preferredModelHint: "Prefer Gemini 3.1 Pro Preview or another strong design-capable model actually available in Pi.",