@@ -15,9 +15,14 @@ const { mocks } = vi.hoisted(() => ({
     executeWorkflowUseCase: vi.fn(),
     hasExecutionResult: vi.fn(),
     readAttemptedExecutionId: vi.fn(),
+    logStatus: vi.fn(),
   },
 }))
 
+vi.mock('@/lib/workflows/executor/execution-state', () => ({
+  getWorkflowExecutionLogStatus: mocks.logStatus,
+}))
+
 vi.mock('@/lib/mothership/application/execute-workflow-use-case', () => ({
   executeCopilotWorkflowUseCase: mocks.executeWorkflowUseCase,
   messageForCopilotWorkflowError: (error: unknown, fallback = 'Workflow operation failed') =>
@@ -445,12 +450,9 @@ describe('a workflow tool run past its wait', () => {
     const started = new Promise((resolve) => {
       settle = resolve
     })
-    mocks.executeWorkflowUseCase.mockImplementationOnce(
-      (_context: unknown, _useCase: unknown, input: { lifecycle: { onDispatch?: () => void } }) => {
-        if (dispatch) input.lifecycle.onDispatch?.()
-        return started
-      }
-    )
+    mocks.executeWorkflowUseCase.mockReturnValueOnce(started)
+    // The run's log exists once it started; a run still in preflight has none.
+    mocks.logStatus.mockResolvedValue(dispatch ? 'running' : undefined)
     return {
       settle,
       lifecycle: () =>
@@ -493,7 +495,7 @@ describe('a workflow tool run past its wait', () => {
     await expect(held[0]).resolves.toMatchObject({ success: true })
   })
 
-  it('answers a run still in preflight past its wait with how it settles', async () => {
+  it('waits on a run past its wait until its log exists, answering one that never starts with how it settles', async () => {
     const run = pendingRun(false)
     let answered = false
     const answer = executeRunWorkflow(
@@ -509,6 +511,25 @@ describe('a workflow tool run past its wait', () => {
     await expect(answer).resolves.toMatchObject({ success: false })
   })
 
+  it('answers a run still starting up running once its log exists', async () => {
+    const run = pendingRun()
+    mocks.logStatus.mockReset().mockResolvedValueOnce(undefined).mockResolvedValue('running')
+    let answered = false
+    const answer = executeRunWorkflow(
+      { workflowId: 'workflow-1' },
+      { ...context, workflowRunWaitMs: 1_000 }
+    ).then((result) => {
+      answered = true
+      return result
+    })
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(answered).toBe(false)
+    await vi.advanceTimersByTimeAsync(1_000)
+    await expect(answer).resolves.toMatchObject({ output: { status: 'running' } })
+    expect(mocks.logStatus).toHaveBeenCalledWith(run.lifecycle().executionId, 'workflow-1')
+    run.settle({ success: true, output: {}, logs: [] })
+  })
+
   it('answers with the result when the run settles within its wait', async () => {
     const run = pendingRun()
     const answer = executeRunBlock(
 
@@ -39,6 +39,7 @@ import {
   runWorkflowFromCopilot,
   runWorkflowUntilBlockFromCopilot,
 } from '@/lib/workflows/application/run-workflow-from-copilot'
+import { getWorkflowExecutionLogStatus } from '@/lib/workflows/executor/execution-state'
 import { hasExecutionResult, readAttemptedExecutionId } from '@/executor/utils/errors'
 import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 
@@ -257,6 +258,9 @@ function copilotRunLifecycle(context: ExecutionContext) {
   }
 }
 
+/** How often a run past its wait is re-read for its log before it is answered running. */
+const RUN_LOG_POLL_MS = 1000
+
 /**
  * Runs a workflow tool's run and answers with its result. When the call names a wait the run
  * outlasts (`workflowRunWaitMs`), it answers the run still running by the execution id it gave
@@ -272,20 +276,18 @@ async function answerWithinWait(
   const waitMs = context.workflowRunWaitMs
   if (waitMs === undefined) return run(lifecycle)
   const executionId = lifecycle.boundExecution?.executionId ?? generateId()
-  let markDispatched: () => void = () => {}
-  const dispatched = new Promise<null>((resolve) => {
-    markDispatched = () => resolve(null)
-  })
-  const settled = run({ ...lifecycle, executionId, onDispatch: () => markDispatched() })
+  const settled = run({ ...lifecycle, executionId })
   retainSandboxExecution(settled)
   const stopWaiting = new AbortController()
-  const waited = interruptibleSleep(waitMs, stopWaiting.signal).then(() => null)
+  const waited = (ms: number) => interruptibleSleep(ms, stopWaiting.signal).then(() => null)
   try {
-    const result = await Promise.race([settled, waited])
+    let result = await Promise.race([settled, waited(waitMs)])
+    // Answered running only once the run is readable by its id; one still starting up (or in
+    // preflight) is waited on until its log exists or it settles.
+    while (!result && !(await getWorkflowExecutionLogStatus(executionId, workflowId))) {
+      result = await Promise.race([settled, waited(RUN_LOG_POLL_MS)])
+    }
     if (result) return result
-    // Only a run handed to the executor is answered running; one still in preflight settles first.
-    const started = await Promise.race([settled, dispatched])
-    if (started) return started
   } finally {
     stopWaiting.abort()
   }
 
@@ -65,8 +65,6 @@ export interface CopilotWorkflowRunLifecycle {
    * before it settles (a workflow tool that answers a still-running run by its id).
    */
   executionId?: string
-  /** Called once authorization and admission passed and the run is handed to the executor. */
-  onDispatch?: () => void
 }
 
 interface BaseCopilotRunInput {
@@ -309,7 +307,6 @@ async function executeCopilotRun(params: {
    * can already make with the id it was handed. Keep the executor call first: anything
    * inserted above it would be reported as a run that may exist.
    */
-  params.input.lifecycle.onDispatch?.()
   try {
     const result = await executeWorkflow(
       {