@@ -197,7 +197,10 @@ describe('DAGExecutor run-from-block snapshot metadata', () => {
       version: '1',
       blocks: [
         createBlock('start', BlockType.STARTER),
-        createBlock('producer', BlockType.FUNCTION),
+        {
+          ...createBlock('producer', BlockType.FUNCTION),
+          metadata: { id: 'function', name: 'Fetch' },
+        },
         createBlock('consumer', BlockType.FUNCTION),
       ],
       connections: [
@@ -220,7 +223,12 @@ describe('DAGExecutor run-from-block snapshot metadata', () => {
     const error = await executor.executeFromBlock('wf', 'consumer', sourceSnapshot).catch((e) => e)
 
     expect(error).toBeInstanceOf(RunFromBlockValidationError)
-    expect(error.message).toBe('Upstream dependency not executed: producer')
+    expect(error.message).toBe('Upstream dependency not executed: Fetch')
+    expect(error.refusal).toEqual({
+      kind: 'upstream_not_executed',
+      blockId: 'consumer',
+      upstreamBlockId: 'producer',
+    })
   })
 })
 
 
@@ -153,10 +153,15 @@ export class DAGExecutor {
     const dag = this.dagBuilder.build(this.workflow, { includeAllBlocks: true })
 
     const executedBlocks = new Set(sourceSnapshot.executedBlocks)
-    const validation = validateRunFromBlock(startBlockId, dag, executedBlocks)
+    const blockNames = new Map<string, string>()
+    for (const block of this.workflow.blocks) {
+      if (block.metadata?.name) blockNames.set(block.id, block.metadata.name)
+    }
+    const validation = validateRunFromBlock(startBlockId, dag, executedBlocks, blockNames)
     if (!validation.valid) {
       throw new RunFromBlockValidationError(
-        validation.error ?? `Cannot run from block: ${startBlockId}`
+        validation.error ?? `Cannot run from block: ${startBlockId}`,
+        validation.refusal
       )
     }
 
 
@@ -29,18 +29,37 @@ export function resolveContainerToSentinelStart(blockId: string, dag: DAG): stri
 export interface RunFromBlockValidation {
   valid: boolean
   error?: string
+  /** Why the start was refused, by id, for callers that phrase their own guidance. */
+  refusal?: RunFromBlockRefusal
 }
 
+/**
+ * The structured reason behind a refused run-from-block start. `blockId` is always the
+ * requested start block.
+ */
+export type RunFromBlockRefusal =
+  | { kind: 'block_not_found'; blockId: string }
+  | {
+      kind: 'inside_subflow'
+      blockId: string
+      subflowId: string
+      subflowType: 'loop' | 'parallel'
+    }
+  | { kind: 'upstream_not_executed'; blockId: string; upstreamBlockId: string }
+
 /**
  * A run-from-block start the executor refused before running anything: the block is
  * missing, sits inside a loop or parallel, or has an upstream dependency the source
  * snapshot never executed. Its own class so the application layer can hand the reason
  * to the caller as a validation failure instead of the generic system-error fallback.
  */
 export class RunFromBlockValidationError extends Error {
-  constructor(message: string) {
+  readonly refusal?: RunFromBlockRefusal
+
+  constructor(message: string, refusal?: RunFromBlockRefusal) {
     super(message)
     this.name = 'RunFromBlockValidationError'
+    this.refusal = refusal
   }
 }
 
@@ -158,39 +177,50 @@ export function computeExecutionSets(dag: DAG, startBlockId: string): ExecutionS
  * @param blockId - The block ID to validate
  * @param dag - The workflow DAG
  * @param executedBlocks - Set of blocks that were executed in the source run
+ * @param blockNames - Display names by block id, so the message names blocks instead of ids
  * @returns Validation result with error message if invalid
  */
 export function validateRunFromBlock(
   blockId: string,
   dag: DAG,
-  executedBlocks: Set<string>
+  executedBlocks: Set<string>,
+  blockNames: ReadonlyMap<string, string> = new Map()
 ): RunFromBlockValidation {
+  const label = (id: string) => blockNames.get(id) ?? id
+  const insideSubflow = (
+    subflowId: string | undefined,
+    subflowType: 'loop' | 'parallel'
+  ): RunFromBlockValidation => {
+    if (!subflowId) {
+      return { valid: false, error: `Cannot run from block inside ${subflowType}: ${blockId}` }
+    }
+    return {
+      valid: false,
+      error: `Cannot run from block inside ${subflowType}: ${label(subflowId)}. Run the ${subflowType} or the whole workflow instead.`,
+      refusal: { kind: 'inside_subflow', blockId, subflowId, subflowType },
+    }
+  }
+
   const node = dag.nodes.get(blockId)
   const isLoopContainer = dag.loopConfigs.has(blockId)
   const isParallelContainer = dag.parallelConfigs.has(blockId)
   const isContainer = isLoopContainer || isParallelContainer
   let validationNode = node
 
   if (!node && !isContainer) {
-    return { valid: false, error: `Block not found in workflow: ${blockId}` }
+    return {
+      valid: false,
+      error: `Block not found in workflow: ${blockId}`,
+      refusal: { kind: 'block_not_found', blockId },
+    }
   }
 
   if (isContainer) {
     const parentLoopId = findParentLoop(blockId, dag)
-    if (parentLoopId) {
-      return {
-        valid: false,
-        error: `Cannot run from block inside loop: ${parentLoopId}`,
-      }
-    }
+    if (parentLoopId) return insideSubflow(parentLoopId, 'loop')
 
     const parentParallelId = findParentParallel(blockId, dag)
-    if (parentParallelId) {
-      return {
-        valid: false,
-        error: `Cannot run from block inside parallel: ${parentParallelId}`,
-      }
-    }
+    if (parentParallelId) return insideSubflow(parentParallelId, 'parallel')
 
     const sentinelStartId = resolveContainerToSentinelStart(blockId, dag)
     if (!sentinelStartId || !dag.nodes.has(sentinelStartId)) {
@@ -203,19 +233,8 @@ export function validateRunFromBlock(
   }
 
   if (node) {
-    if (node.metadata.isLoopNode) {
-      return {
-        valid: false,
-        error: `Cannot run from block inside loop: ${node.metadata.subflowId}`,
-      }
-    }
-
-    if (node.metadata.isParallelBranch) {
-      return {
-        valid: false,
-        error: `Cannot run from block inside parallel: ${node.metadata.subflowId}`,
-      }
-    }
+    if (node.metadata.isLoopNode) return insideSubflow(node.metadata.subflowId, 'loop')
+    if (node.metadata.isParallelBranch) return insideSubflow(node.metadata.subflowId, 'parallel')
 
     if (node.metadata.isSentinel) {
       return { valid: false, error: 'Cannot run from sentinel node' }
@@ -236,7 +255,8 @@ export function validateRunFromBlock(
       if (!executedBlocks.has(sourceId)) {
         return {
           valid: false,
-          error: `Upstream dependency not executed: ${sourceId}`,
+          error: `Upstream dependency not executed: ${label(sourceId)}`,
+          refusal: { kind: 'upstream_not_executed', blockId, upstreamBlockId: sourceId },
         }
       }
     }
 
@@ -306,6 +306,131 @@ describe('Copilot workflow run application commands', () => {
     expect(readAttemptedExecutionId(error)).toBe('child-execution-1')
   })
 
+  describe('a refused run-from-block start tells the agent what to do next', () => {
+    const blocks = {
+      'start-1': { id: 'start-1', name: 'Start', enabled: true },
+      'fetch-1': { id: 'fetch-1', name: 'Fetch', enabled: true },
+      'loop-1': { id: 'loop-1', name: 'Each row', enabled: true },
+      'agent-1': { id: 'agent-1', name: 'Summarize', enabled: true },
+      'note-1': { id: 'note-1', name: 'Notes', enabled: false },
+    }
+
+    async function refuse(
+      blockId: string,
+      error: RunFromBlockValidationError,
+      workflowBlocks: Record<string, unknown> = blocks
+    ) {
+      mockLoadDraft.mockResolvedValue({ blocks: workflowBlocks, edges: [] })
+      mocks.sourceState.mockResolvedValueOnce({
+        blockStates: {},
+        executedBlocks: [],
+        blockLogs: [],
+        decisions: {},
+        completedLoops: [],
+        activeExecutionPath: [],
+      })
+      mockExecuteWorkflow.mockRejectedValueOnce(error)
+      const thrown = await runFromBlockFromCopilot
+        .execute({
+          principal,
+          input: {
+            workflowId: 'workflow-1',
+            useDraftState: true,
+            lifecycle,
+            blockId,
+            sourceExecutionId: 'source-execution-1',
+          },
+        })
+        .catch((caught) => caught)
+      expect(thrown).toBeInstanceOf(OrchestrationError)
+      expect(thrown.code).toBe('validation')
+      return thrown.message as string
+    }
+
+    it('names the upstream block that never ran and the calls that get past it', async () => {
+      const message = await refuse(
+        'agent-1',
+        new RunFromBlockValidationError('Upstream dependency not executed: Fetch', {
+          kind: 'upstream_not_executed',
+          blockId: 'agent-1',
+          upstreamBlockId: 'fetch-1',
+        })
+      )
+
+      expect(message).toContain('"Summarize" (agent-1)')
+      expect(message).toContain('"Fetch" (fetch-1)')
+      expect(message).toContain('execution source-execution-1')
+      expect(message).toContain('run_workflow_until_block')
+      expect(message).toContain('stopAfterBlockId "agent-1"')
+      expect(message).toContain('executionId')
+    })
+
+    it('names the container a nested block sits in and points at it', async () => {
+      const message = await refuse(
+        'agent-1',
+        new RunFromBlockValidationError('Cannot run from block inside loop: Each row', {
+          kind: 'inside_subflow',
+          blockId: 'agent-1',
+          subflowId: 'loop-1',
+          subflowType: 'loop',
+        })
+      )
+
+      expect(message).toContain('inside loop "Each row" (loop-1)')
+      expect(message).toContain('block id "loop-1"')
+      expect(message).toContain('run_workflow')
+    })
+
+    it('lists the blocks the workflow does have when the id is unknown', async () => {
+      const message = await refuse(
+        'agent-x',
+        new RunFromBlockValidationError('Block not found in workflow: agent-x', {
+          kind: 'block_not_found',
+          blockId: 'agent-x',
+        })
+      )
+
+      expect(message).toContain('"agent-x" is not in the draft workflow')
+      expect(message).toContain('"Fetch" (fetch-1)')
+      expect(message).toContain('"Each row" (loop-1)')
+    })
+
+    it('bounds the block list on a large workflow', async () => {
+      const many = Object.fromEntries(
+        Array.from({ length: 25 }, (_, index) => [
+          `b-${index}`,
+          { id: `b-${index}`, name: `Block ${index}`, enabled: true },
+        ])
+      )
+      const message = await refuse(
+        'missing',
+        new RunFromBlockValidationError('Block not found in workflow: missing', {
+          kind: 'block_not_found',
+          blockId: 'missing',
+        }),
+        many
+      )
+
+      expect(message).toContain('(b-19)')
+      expect(message).not.toContain('(b-20)')
+      expect(message).toContain('and 5 more')
+    })
+
+    it('says a known but unrunnable block is disabled instead of missing', async () => {
+      const message = await refuse(
+        'note-1',
+        new RunFromBlockValidationError('Block not found in workflow: note-1', {
+          kind: 'block_not_found',
+          blockId: 'note-1',
+        })
+      )
+
+      expect(message).toContain('"Notes" (note-1)')
+      expect(message).toContain('disabled')
+      expect(message).not.toContain('is not in the')
+    })
+  })
+
   /**
    * A caller whose result was withheld decides about retry from one fact: whether a run
    * exists. This layer owns that answer, because it is the last place that can distinguish