Wire Studio “Act on findings” to durable video-to-actions runs

apps/web/src/components/OneLoopStudio.tsx

@@ -453,7 +453,7 @@
       const started = await startVideoToActions(payload);
       if (!started.ok || !started.runId) {
         if (started.status === 401 || started.status === 403) {
           window.location.href = `/login?callbackUrl=${encodeURIComponent(CANONICAL_STUDIO_PATH)}`;
           return;
         }
         setMessage(started.error || started.message || 'Could not start Act.');
@@ -466,6 +466,7 @@
           : `Act ${started.runId} started.`,
       );
       const polled = await pollVideoToActions(started.runId, {
+        statusUrl: started.statusUrl,
         attempts: 24,
         delayMs: 2000,
       });
@@ -565,7 +566,7 @@
     try {
       const started = await startStudioDeploy({ url: next });
       if (started.status === 401 || started.status === 403) {
         window.location.href = `/login?callbackUrl=${encodeURIComponent(CANONICAL_STUDIO_PATH)}`;
         return;
       }
       if (!started.ok || !started.runId) {

apps/web/src/components/VideoWorkflowStudio.tsx

@@ -550,6 +550,7 @@
       setActionMessage(`Workflow ${started.runId} running — polling transcript + actions…`);
 
       const polled = await pollVideoToActions(started.runId, {
+        statusUrl: started.statusUrl,
         attempts: 24,
         delayMs: 2000,
       });
@@ -609,7 +610,7 @@
       });
       if (started.status === 401 || started.status === 403) {
         setActionMessage('Sign in to deploy. Redirecting to Google sign-in…');
         window.location.assign('/login?callbackUrl=/studio');
         return;
       }
       if (started.status === 400) {

apps/web/src/lib/__tests__/studio-workflow.test.ts

@@ -160,6 +160,36 @@ describe('studio-workflow (WDK Product v1)', () => {
     expect(fetchMock).toHaveBeenCalledTimes(2);
   });
 
+  it('pollVideoToActions uses the durable statusUrl returned at start', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        ok: true,
+        runId: 'wrun_status_url',
+        runStatus: 'completed',
+        result: {
+          url: 'https://youtu.be/x',
+          transcriptChars: 50,
+          actionCount: 0,
+          actions: [],
+        },
+      }),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    await pollVideoToActions('wrun_status_url', {
+      statusUrl: '/api/workflows/video-to-actions/wrun_status_url',
+      attempts: 1,
+      delayMs: 1,
+    });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/workflows/video-to-actions/wrun_status_url',
+      expect.any(Object),
+    );
+  });
+
   it('startStudioDeploy succeeds when the route returns a runId', async () => {
     vi.stubGlobal(
       'fetch',

apps/web/src/lib/studio-workflow.ts

@@ -53,6 +53,12 @@ export interface VideoToActionsPoll {
   message?: string;
 }
 
+function videoToActionsStatusUrl(runId: string, statusUrl?: string): string {
+  return statusUrl?.startsWith('/api/workflows/video-to-actions/')
+    ? statusUrl
+    : `/api/workflows/video-to-actions/${encodeURIComponent(runId)}`;
+}
+
 function str(v: unknown): string | undefined {
   return typeof v === 'string' && v.trim() ? v : undefined;
 }
@@ -226,10 +232,10 @@ export async function startVideoToActions(input: {
 /** Single status poll for a workflow run. */
 export async function getVideoToActionsStatus(
   runId: string,
-  opts?: { signal?: AbortSignal },
+  opts?: { signal?: AbortSignal; statusUrl?: string },
 ): Promise<VideoToActionsPoll> {
   const response = await fetch(
-    `/api/workflows/video-to-actions/${encodeURIComponent(runId)}`,
+    videoToActionsStatusUrl(runId, opts?.statusUrl),
     {
       method: 'GET',
       credentials: 'same-origin',
@@ -300,7 +306,7 @@ export async function getVideoToActionsStatus(
  */
 export async function pollVideoToActions(
   runId: string,
-  opts?: { attempts?: number; delayMs?: number; signal?: AbortSignal },
+  opts?: { attempts?: number; delayMs?: number; signal?: AbortSignal; statusUrl?: string },
 ): Promise<VideoToActionsPoll> {
   const attempts = opts?.attempts ?? 30;
   const delayMs = opts?.delayMs ?? 2000;
@@ -315,7 +321,10 @@ export async function pollVideoToActions(
     if (opts?.signal?.aborted) {
       return { ...last, error: last.error || 'aborted', message: 'Polling aborted' };
     }
-    last = await getVideoToActionsStatus(runId, { signal: opts?.signal });
+    last = await getVideoToActionsStatus(runId, {
+      signal: opts?.signal,
+      statusUrl: opts?.statusUrl,
+    });
     if (last.runStatus && TERMINAL.has(last.runStatus)) {
       return last;
     }

apps/web/src/store/dashboard-store.ts

@@ -386,6 +386,7 @@ export const useDashboardStore = create<DashboardState>()(
       addActivity(`Durable run created: ${started.runId}`, 'success');
 
       const terminal = await pollVideoToActions(started.runId, {
+        statusUrl: started.statusUrl,
         attempts: 180,
         delayMs: 2000,
       });
@@ -422,6 +423,7 @@ export const useDashboardStore = create<DashboardState>()(
       activeRunResumptions.add(runId);
       try {
         const terminal = await pollVideoToActions(runId, {
+          statusUrl: video.statusUrl,
           attempts: 180,
           delayMs: 2000,
         });

apps/web/src/workflows/__tests__/video-to-actions.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from 'vitest';
+
+const runActionAgent = vi.fn().mockResolvedValue({
+  provider: 'gateway:test',
+  actions: [
+    {
+      tool: 'create_workflow_task',
+      status: 'pending',
+      result: 'Prepared for review.',
+    },
+  ],
+});
+
+vi.mock('@/lib/action-agent', () => ({ runActionAgent }));
+vi.mock('@/lib/transcription-service', () => ({
+  fetchTranscript: vi.fn().mockResolvedValue({
+    transcript: 'fetched transcript with enough words to pass the evidence gate',
+    segments: [{ start: 0, duration: 1, text: 'fetched transcript' }],
+    sourceUrl: 'https://www.youtube.com/watch?v=auJzb1D-fag',
+    source: 'youtube',
+    verified: true,
+  }),
+}));
+vi.mock('@/lib/gemini-video-analyzer', () => ({
+  analyzeVideoWithGemini: vi.fn().mockResolvedValue({
+    title: 'Fixture',
+    summary: 'Summary',
+    transcript: [],
+    events: [],
+    actions: [],
+    topics: [],
+    architectureCode: '',
+    ingestScript: '',
+    e22Snippets: [],
+    provenance: {
+      sourceUrl: 'https://www.youtube.com/watch?v=auJzb1D-fag',
+      sourceHost: 'www.youtube.com',
+      acquisitionMethod: 'captions',
+      transcriptSource: 'youtube',
+      transcriptVerified: true,
+      acquiredAt: new Date().toISOString(),
+      segmentCount: 1,
+      timedSegmentCount: 1,
+      durationCoverageSeconds: 1,
+      contentSha256: 'hash',
+      warnings: [],
+    },
+    quality: { passed: true, state: 'verified', issues: [] },
+  }),
+}));
+vi.mock('@/lib/gemini-client', () => ({
+  getGeminiRoutingLabel: vi.fn().mockResolvedValue('gateway:test'),
+}));
+
+describe('videoToActionsWorkflow', () => {
+  it('sends same-run transcript and events to the preview action agent', async () => {
+    const { videoToActionsWorkflow } = await import('../video-to-actions');
+    const transcript = 'provided Analyze transcript with enough words to pass the gate';
+
+    const result = await videoToActionsWorkflow({
+      url: 'https://www.youtube.com/watch?v=auJzb1D-fag',
+      videoTitle: 'Fixture',
+      transcript,
+      events: [{ type: 'action', title: 'Ship', description: 'now' }],
+    });
+
+    expect(runActionAgent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        transcript: expect.stringContaining(transcript),
+        videoTitle: 'Fixture',
+        executeTools: false,
+      }),
+    );
+    expect(result.usedProvidedTranscript).toBe(true);
+    expect(result.actions[0]?.tool).toBe('create_workflow_task');
+  });
+});

apps/web/src/workflows/video-to-actions.ts

@@ -18,6 +18,7 @@ import {
   type TranscriptSegment,
 } from '@/lib/analysis-evidence';
 import type { VideoAnalysisResult, VerifiedVideoEvidence } from '@/lib/gemini-video-analyzer';
+import { buildActionAgentSource, usableProvidedTranscript } from '@/lib/video-to-actions-input';
 
 export interface VideoToActionsEvent {
   type?: string;
@@ -68,25 +69,58 @@ export async function videoToActionsWorkflow(
     throw new FatalError('Analysis quality gate failed: missing provenance');
   }
 
-  const provider = await providerLabelStep();
-  const actions = (analysis.actions || []).map((action) => ({
-    tool: 'review_action',
-    status: 'proposed',
-    result: action.title,
+  const providedTranscript = usableProvidedTranscript(input.transcript);
+  const actionAgent = await actionAgentStep(
+    providedTranscript || evidence.transcript,
+    input.videoTitle,
+    input.events,
+  );
+  const provider = actionAgent.provider || (await providerLabelStep());
+  const actions = actionAgent.actions.map((action) => ({
+    tool: action.tool,
+    status: action.status,
+    result: action.result,
   }));
 
   return {
     url,
     transcriptChars: evidence.transcript.length,
-    actionCount: analysis.actions?.length || 0,
+    actionCount: actions.length,
     provider,
+    usedProvidedTranscript: Boolean(providedTranscript),
     actions,
     analysis,
     provenance,
     quality,
   };
 }
 
+async function actionAgentStep(
+  transcript: string,
+  videoTitle?: string,
+  events?: VideoToActionsEvent[],
+): Promise<{
+  provider: string;
+  actions: Array<{ tool: string; status: string; result?: string }>;
+}> {
+  'use step';
+
+  const { runActionAgent } = await import('@/lib/action-agent');
+  const result = await runActionAgent({
+    transcript: buildActionAgentSource(transcript, events),
+    videoTitle,
+    executeTools: false,
+  });
+  return {
+    provider: result.provider,
+    actions: result.actions.map((action) => ({
+      tool: action.tool,
+      status: action.status,
+      result: action.result,
+    })),
+  };
+}
+
 async function transcribeStep(url: string): Promise<VerifiedVideoEvidence> {
   'use step';