feat(workflows): selected outputs on sync runs + cross-run logs query augmentation

selectedOutputs was artificially stream-only: a sync run rejected it with a
400 and pointed at a second call (runs get) that resolves block ids only.
The sync path already holds the full execution result, so selection now
answers in the same response: blockOutputs keyed by the request's selector
strings, names resolved against the exact state being run, absent paths
omitted, failed and timed-out runs including the blocks that did run, values
compacted like output. Route guard deleted, resume sends null, contract +
openapi + cli-api + cli-docs regenerated, CLI --select-output works on a
plain sync run (only --async still rejects it, locally, with the dialect
hint).

New agent-cli augmentation: logs query <workflowId> --block <name>
[--field <path>] [--where <path>=<value>] [--status] [--trigger] [--limit]
— one row per run across run history, recursive span walk, last match per
run wins. The augmentation layer gains command-local flag parsing
(--flag value / --flag=value / bare) to support it; positional-only
commands are unchanged.

Autopsy fix: the formatter neutral-path workaround from the display-frames
commit dropped the caller's extension, so generate:openapi (JSON) aborted
with a biome parse error while .ts generators stayed green. The extension
now survives; regression test added and wired into test:generators.

Claude-Session: https://claude.ai/code/session_01CgaxNAaeD3taGdghbXn17w

Author: Sg312

apps/docs/content/docs/cli/reference.mdx

@@ -5157,7 +5157,7 @@ sim workflows run <workflowId> [options]
 | `--input <json\|@file>` | No | Trigger input as JSON (JSON, or @path / @- to read a file or stdin). |
 | `--async` | No | Queue the run and return immediately. |
 | `--execution-timeout-seconds <value>` | No | Requested server-side timeout for an asynchronous run, in seconds. An upper bound, not the effective timeout: the run uses the smaller of this value and the plan's execution timeout, so requesting more than the plan allows silently yields the plan timeout. Rejected with `400` unless `async` is true. |
-| `--select-output <value...>` | No | Return blockName.field values from the streamed result (e.g. agent_1.content), requires --follow; missing fields are omitted (space-separated, or @path / @- with one value per line; @@value for a literal leading @). |
+| `--select-output <value...>` | No | Return blockName.field values (e.g. agent_1.content) — in blockOutputs on a sync run, or from the streamed result with --follow; missing fields are omitted. Not available with --async (space-separated, or @path / @- with one value per line; @@value for a literal leading @). |
 | `--include-file-base64` | No | Inline eligible output files as base64 content. Rejected when `async` is true. |
 | `--no-include-file-base64` | No | Send --include-file-base64 as false. |
 | `--base64-max-bytes <value>` | No | Maximum total bytes of file content to inline as base64, lowering but never raising the server limit of 16 MiB. Rejected when `async` is true. |

apps/docs/content/docs/cli/workflows.mdx

@@ -532,7 +532,7 @@ sim workflows run <workflowId> [options]
 | `--input <json\|@file>` | No | Trigger input as JSON (JSON, or @path / @- to read a file or stdin). |
 | `--async` | No | Queue the run and return immediately. |
 | `--execution-timeout-seconds <value>` | No | Requested server-side timeout for an asynchronous run, in seconds. An upper bound, not the effective timeout: the run uses the smaller of this value and the plan's execution timeout, so requesting more than the plan allows silently yields the plan timeout. Rejected with `400` unless `async` is true. |
-| `--select-output <value...>` | No | Return blockName.field values from the streamed result (e.g. agent_1.content), requires --follow; missing fields are omitted (space-separated, or @path / @- with one value per line; @@value for a literal leading @). |
+| `--select-output <value...>` | No | Return blockName.field values (e.g. agent_1.content) — in blockOutputs on a sync run, or from the streamed result with --follow; missing fields are omitted. Not available with --async (space-separated, or @path / @- with one value per line; @@value for a literal leading @). |
 | `--include-file-base64` | No | Inline eligible output files as base64 content. Rejected when `async` is true. |
 | `--no-include-file-base64` | No | Send --include-file-base64 as false. |
 | `--base64-max-bytes <value>` | No | Maximum total bytes of file content to inline as base64, lowering but never raising the server limit of 16 MiB. Rejected when `async` is true. |

apps/docs/openapi-v2-workflows.json

@@ -5169,7 +5169,14 @@
                 },
                 "kind": {
                   "type": "string",
-                  "enum": ["credential", "resource", "custom-tool", "mcp-tool", "skill"],
+                  "enum": [
+                    "credential",
+                    "resource",
+                    "custom-tool",
+                    "mcp-tool",
+                    "skill",
+                    "block-output"
+                  ],
                   "description": "What kind of entity the reference was expected to name."
                 },
                 "reason": {
@@ -9094,6 +9101,23 @@
           "output": {
             "description": "Workflow output, including partial output on failure."
           },
+          "blockOutputs": {
+            "anyOf": [
+              {
+                "type": "object",
+                "propertyNames": {
+                  "type": "string"
+                },
+                "additionalProperties": {
+                  "description": "Output value produced by one workflow block."
+                }
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "description": "Outputs of the blocks named by `selectedOutputs`, keyed by those selector strings, or null when none were requested. Selectors whose block did not run or whose path is absent are omitted; failed runs include the outputs of the blocks that did run."
+          },
           "error": {
             "anyOf": [
               {
@@ -9121,7 +9145,7 @@
             "minimum": 0
           }
         },
-        "required": ["runId", "workflowId", "status", "output", "error"],
+        "required": ["runId", "workflowId", "status", "output", "blockOutputs", "error"],
         "additionalProperties": false,
         "title": "Workflow run result",
         "description": "Synchronous workflow run output and in-band execution status. Run failures are reported in band, not as HTTP errors — a run that exceeds its execution timeout returns HTTP 200 with `status: \"failed\"` and `error.code: \"TIMEOUT\"`, so branch on `status`."
@@ -9147,6 +9171,7 @@
               "output": {
                 "result": "Ticket routed to Support"
               },
+              "blockOutputs": null,
               "error": null,
               "startedAt": "2026-08-09T18:04:10.000Z",
               "endedAt": "2026-08-09T18:04:11.000Z",
@@ -9305,7 +9330,7 @@
             "type": "boolean"
           },
           "selectedOutputs": {
-            "description": "Block output references to include in a streamed response, as `blockId`, `blockId.path`, or `BlockName.path` (resolved against the live workflow). Requires `stream: true` — it shapes the streamed envelope only, so it is rejected on a sync request and when `async` is true. To narrow a finished run, pass `selectedOutputs` to the run resource instead.",
+            "description": "Block output references to include in the response, as `blockId`, `blockId.path`, or `BlockName.path` (resolved against the workflow state being run). On a sync request the named outputs come back in `blockOutputs`, keyed by these selector strings; on a stream they shape the streamed envelope. Selectors that resolve to no block or no value are omitted. Rejected when `async` is true — a queued run has produced nothing to select; narrow the finished run via the run resource instead.",
             "maxItems": 100,
             "type": "array",
             "items": {
@@ -9883,6 +9908,7 @@
               "output": {
                 "result": "Ticket routed to Support"
               },
+              "blockOutputs": null,
               "error": null,
               "startedAt": "2026-08-09T18:04:10.000Z",
               "endedAt": "2026-08-09T18:04:11.000Z",

apps/sim/app/api/v2/workflows/[workflowId]/execute/route.test.ts

@@ -324,6 +324,7 @@ describe('POST /api/v2/workflows/[workflowId]/execute', () => {
       workflowId: 'workflow-1',
       status: 'completed',
       output: { result: 'done' },
+      blockOutputs: null,
       error: null,
       durationMs: 42,
     })
@@ -590,12 +591,47 @@ describe('POST /api/v2/workflows/[workflowId]/execute', () => {
     expect(mockPreprocessExecution).not.toHaveBeenCalled()
   })
 
-  it('rejects selectedOutputs on a sync request rather than ignoring it', async () => {
-    const res = await callExecute({ selectedOutputs: ['agent_1.content'] })
+  it('returns blockOutputs for selectedOutputs on a sync request', async () => {
+    const agentBlockId = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'
+    mockLoadDeployedWorkflowState.mockResolvedValue({
+      blocks: { [agentBlockId]: { id: agentBlockId, name: 'Agent 1' } },
+      edges: [],
+      loops: {},
+      parallels: {},
+      variables: {},
+    })
+    mockExecuteWorkflowCore.mockResolvedValue({
+      success: true,
+      output: { result: 'done' },
+      logs: [
+        {
+          blockId: agentBlockId,
+          blockName: 'Agent 1',
+          startedAt: 's',
+          endedAt: 'e',
+          durationMs: 5,
+          success: true,
+          output: { content: 'hi', tokens: { total: 7 } },
+        },
+      ],
+      metadata: {
+        duration: 42,
+        startTime: '2026-07-31T00:00:00.000Z',
+        endTime: '2026-07-31T00:00:01.000Z',
+      },
+    })
 
-    expect(res.status).toBe(400)
-    expect((await res.json()).error.message).toContain('selectedOutputs requires stream: true')
-    expect(mockPreprocessExecution).not.toHaveBeenCalled()
+    const res = await callExecute({
+      input: {},
+      selectedOutputs: ['Agent 1.content', 'Agent 1.absent', agentBlockId],
+    })
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.data.blockOutputs).toEqual({
+      'Agent 1.content': 'hi',
+      [agentBlockId]: { content: 'hi', tokens: { total: 7 } },
+    })
   })
 
   it.each(['includeThinking', 'includeToolCalls'])(

apps/sim/app/api/v2/workflows/[workflowId]/execute/route.ts

@@ -256,19 +256,6 @@ export const POST = withRouteHandler(
           'Async execution does not support streaming or output-shaping options'
         )
       }
-      /**
-       * `selectedOutputs` shapes the streamed envelope only — the sync path
-       * returns the workflow's own final output and never reads it. Accepting
-       * it silently answered a full, unselected body to a caller who believed
-       * they had narrowed it, so the option is refused where it does nothing
-       * and the two paths that honour selection are named instead.
-       */
-      if (body.selectedOutputs?.length && !body.stream) {
-        return v2Error(
-          'BAD_REQUEST',
-          'selectedOutputs requires stream: true. For a completed run, request the run resource with ?selectedOutputs= instead.'
-        )
-      }
       const hasAgentStreamOptions = hasAgentStreamPolicy({
         includeThinking: body.includeThinking,
         includeToolCalls: body.includeToolCalls,
@@ -424,6 +411,7 @@ export const POST = withRouteHandler(
           workflowId: result.workflowId,
           status: result.status,
           output: result.output ?? null,
+          blockOutputs: result.blockOutputs ?? null,
           error: result.error,
           startedAt: result.startedAt,
           endedAt: result.endedAt,

apps/sim/app/api/v2/workflows/[workflowId]/runs/[runId]/resume/route.ts

@@ -111,6 +111,8 @@ export const POST = withRouteHandler(
           workflowId,
           status: result.status as 'completed' | 'failed' | 'paused' | 'cancelled',
           output: result.output ?? null,
+          // Resume has no request body to name selectors in, so selection never applies here.
+          blockOutputs: null,
           error:
             typeof result.error === 'string'
               ? classifyExecutionError(new Error(result.error))

apps/sim/lib/api/contracts/v2/openapi/workflows.ts

@@ -179,6 +179,7 @@ const RUN_RESULT_EXAMPLE = {
     workflowId: WORKFLOW_ID,
     status: 'completed',
     output: { result: 'Ticket routed to Support' },
+    blockOutputs: null,
     error: null,
     startedAt: '2026-08-09T18:04:10.000Z',
     endedAt: '2026-08-09T18:04:11.000Z',

apps/sim/lib/api/contracts/v2/workflows.ts

@@ -1293,7 +1293,7 @@ export const v2ExecuteWorkflowBodySchema = z
       .max(100)
       .optional()
       .describe(
-        'Block output references to include in a streamed response, as `blockId`, `blockId.path`, or `BlockName.path` (resolved against the live workflow). Requires `stream: true` — it shapes the streamed envelope only, so it is rejected on a sync request and when `async` is true. To narrow a finished run, pass `selectedOutputs` to the run resource instead.'
+        'Block output references to include in the response, as `blockId`, `blockId.path`, or `BlockName.path` (resolved against the workflow state being run). On a sync request the named outputs come back in `blockOutputs`, keyed by these selector strings; on a stream they shape the streamed envelope. Selectors that resolve to no block or no value are omitted. Rejected when `async` is true — a queued run has produced nothing to select; narrow the finished run via the run resource instead.'
       ),
     includeThinking: z
       .boolean()
@@ -1365,6 +1365,12 @@ export const v2ExecuteWorkflowDataSchema = z
       .enum(['completed', 'failed', 'paused', 'cancelled'])
       .describe('Terminal or paused run status.'),
     output: z.unknown().describe('Workflow output, including partial output on failure.'),
+    blockOutputs: z
+      .record(z.string(), z.unknown().describe('Output value produced by one workflow block.'))
+      .nullable()
+      .describe(
+        'Outputs of the blocks named by `selectedOutputs`, keyed by those selector strings, or null when none were requested. Selectors whose block did not run or whose path is absent are omitted; failed runs include the outputs of the blocks that did run.'
+      ),
     error: v2ExecutionErrorSchema
       .nullable()
       .describe('Structured execution failure, or null when none occurred.'),

apps/sim/lib/mothership/tools/cli-tool-display.ts

@@ -224,6 +224,7 @@ export const CLI_TOOL_TITLES: Record<string, string> = {
   cli_workspaces_members: 'Listing workspace members',
   // Agent-only CLI augmentations
   cli_files_grep: 'Searching file contents',
+  cli_logs_query: 'Querying run history',
   cli_workflow_blocks: 'Listing workflow blocks',
   cli_workflow_deps: 'Tracing block inputs',
   cli_workflow_edges: 'Reading workflow wiring',

apps/sim/lib/mothership/tools/handlers/agent-cli/agent-cli.test.ts

@@ -220,3 +220,130 @@ describe('workflow grep', () => {
     expect(result.stderr).toContain('Unexpected request')
   })
 })
+
+describe('flag parsing', () => {
+  it('collects --flag value, --flag=value, and bare flags without shifting positionals', () => {
+    const match = matchAgentCliCommand([
+      'logs',
+      'query',
+      'wf-1',
+      '--block',
+      'Router',
+      '--limit=5',
+      '--verbose',
+    ])
+    expect(match?.rest).toEqual(['wf-1'])
+    expect(match?.flags.get('block')).toBe('Router')
+    expect(match?.flags.get('limit')).toBe('5')
+    expect(match?.flags.get('verbose')).toBe(true)
+  })
+})
+
+describe('logs query', () => {
+  const RUNS_PATH = '/api/v2/workflows/wf-1/runs'
+  const runsResponse = {
+    data: [
+      { runId: 'run-1', status: 'completed', startedAt: 't1' },
+      { runId: 'run-2', status: 'completed', startedAt: 't2' },
+      { runId: 'run-3', status: 'failed', startedAt: 't3' },
+    ],
+  }
+  const routedTrace = {
+    data: {
+      traceSpans: [
+        {
+          name: 'Start',
+          children: [{ name: 'Router', status: 'success', output: { route: 'priority', n: 2 } }],
+        },
+      ],
+    },
+  }
+  const unroutedTrace = {
+    data: { traceSpans: [{ name: 'Start', output: {} }] },
+  }
+
+  it('emits one row per run with the block field dug from nested spans', async () => {
+    const match = matchAgentCliCommand([
+      'logs',
+      'query',
+      'wf-1',
+      '--block',
+      'Router',
+      '--field',
+      'output.route',
+    ])
+    const result = await executeAgentCliCommand(
+      match!,
+      runtimeWith({
+        [RUNS_PATH]: runsResponse,
+        '/api/v2/logs/run-1': routedTrace,
+        '/api/v2/logs/run-2': unroutedTrace,
+        '/api/v2/logs/run-3': routedTrace,
+      })
+    )
+    expect(result.exitCode).toBe(0)
+    const report = JSON.parse(result.stdout)
+    expect(report.runsScanned).toBe(3)
+    expect(report.rows).toEqual([
+      {
+        runId: 'run-1',
+        startedAt: 't1',
+        runStatus: 'completed',
+        hits: 1,
+        blockStatus: 'success',
+        value: 'priority',
+      },
+      { runId: 'run-2', startedAt: 't2', runStatus: 'completed', hits: 0, value: null },
+      {
+        runId: 'run-3',
+        startedAt: 't3',
+        runStatus: 'failed',
+        hits: 1,
+        blockStatus: 'success',
+        value: 'priority',
+      },
+    ])
+  })
+
+  it('filters rows with --where and reports unavailable traces instead of failing', async () => {
+    const match = matchAgentCliCommand([
+      'logs',
+      'query',
+      'wf-1',
+      '--block',
+      'Router',
+      '--where',
+      'output.route=priority',
+    ])
+    const result = await executeAgentCliCommand(
+      match!,
+      runtimeWith({
+        [RUNS_PATH]: runsResponse,
+        '/api/v2/logs/run-1': routedTrace,
+        '/api/v2/logs/run-2': unroutedTrace,
+      })
+    )
+    expect(result.exitCode).toBe(0)
+    const report = JSON.parse(result.stdout)
+    expect(report.missingTrace).toBe(1)
+    expect(report.rows).toEqual([
+      {
+        runId: 'run-1',
+        startedAt: 't1',
+        runStatus: 'completed',
+        hits: 1,
+        blockStatus: 'success',
+        value: { route: 'priority', n: 2 },
+      },
+      { runId: 'run-2', startedAt: 't2', runStatus: 'completed', hits: 0, value: null },
+      { runId: 'run-3', startedAt: 't3', runStatus: 'failed', note: 'trace unavailable' },
+    ])
+  })
+
+  it('fails usefully without a workflow id or --block', async () => {
+    const match = matchAgentCliCommand(['logs', 'query', 'wf-1'])
+    const result = await executeAgentCliCommand(match!, runtimeWith({}))
+    expect(result.exitCode).toBe(1)
+    expect(result.stderr).toContain('--block')
+  })
+})