Catalog speaks the authoring vocabulary; grep pipe gains context flags

Root-cause fixes for the deep-eval lane's waste findings, not fallback
patches. The agent called `blocks get loop` because add_block accepts
type "loop" — the catalog omitting containers meant one surface taught
a vocabulary the other 404'd on. Loop and Parallel now have catalog
descriptors (list + get) whose option lists import the authoring
constants (VALID_LOOP_TYPES/VALID_PARALLEL_TYPES exported from the
editing operations), so the surfaces cannot drift; outputs document
the container reference semantics. Live-verified via the CLI.

The grep pipe gains -A/-B/-C context flags (window union, hit-based
-c counting) — "grep" implies them, and their absence cost real calls.

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

Author: Sg312

apps/sim/lib/catalog/application/catalog-reads.test.ts

@@ -286,7 +286,9 @@ describe('catalog block and tool reads', () => {
 
     expect(result.entries.map((entry) => entry.id)).toEqual([
       'custom_block_reports',
+      'loop',
       'notion',
+      'parallel',
       'slack',
     ])
     expect(result.hasMore).toBe(false)
@@ -296,7 +298,7 @@ describe('catalog block and tool reads', () => {
   it('accepts a workspace API key, which has no user for permission groups to key on', async () => {
     const result = await listCatalogBlocks.execute({ principal: workspaceKey, input: listInput })
 
-    expect(result.entries).toHaveLength(3)
+    expect(result.entries).toHaveLength(5)
     expect(mocks.allowedIntegrationTypes).toHaveBeenCalledWith(workspaceKey, WORKSPACE_ID)
     expect(mocks.getBlockVisibility).toHaveBeenCalledWith({ orgId: 'org-1' })
   })
@@ -313,7 +315,9 @@ describe('catalog block and tool reads', () => {
     const sources = Object.fromEntries(result.entries.map((entry) => [entry.id, entry.source]))
     expect(sources).toEqual({
       custom_block_reports: 'custom',
+      loop: 'builtin',
       notion: 'builtin',
+      parallel: 'builtin',
       slack: 'builtin',
     })
   })
@@ -338,7 +342,7 @@ describe('catalog block and tool reads', () => {
     mocks.getAllBlocks.mockReturnValue([slackBlock, previewBlock])
 
     const result = await listCatalogBlocks.execute({ principal: session, input: listInput })
-    expect(result.entries.map((entry) => entry.id)).toEqual(['slack'])
+    expect(result.entries.map((entry) => entry.id)).toEqual(['loop', 'parallel', 'slack'])
 
     await expect(
       getCatalogBlock.execute({
@@ -387,7 +391,7 @@ describe('catalog block and tool reads', () => {
     mocks.allowedIntegrationTypes.mockResolvedValue(new Set(['slack_v2']))
 
     const result = await listCatalogBlocks.execute({ principal: session, input: listInput })
-    expect(result.entries.map((entry) => entry.id)).toEqual(['slack'])
+    expect(result.entries.map((entry) => entry.id)).toEqual(['loop', 'parallel', 'slack'])
 
     await expect(
       getCatalogBlock.execute({
@@ -401,7 +405,12 @@ describe('catalog block and tool reads', () => {
     mocks.isDeploymentAvailable.mockImplementation((type: string) => type !== 'notion')
 
     const result = await listCatalogBlocks.execute({ principal: session, input: listInput })
-    expect(result.entries.map((entry) => entry.id)).toEqual(['custom_block_reports', 'slack'])
+    expect(result.entries.map((entry) => entry.id)).toEqual([
+      'custom_block_reports',
+      'loop',
+      'parallel',
+      'slack',
+    ])
   })
 
   it('narrows to trigger-capable blocks without a second endpoint', async () => {
@@ -424,15 +433,35 @@ describe('catalog block and tool reads', () => {
       principal: session,
       input: { ...listInput, limit: 2 },
     })
-    expect(first.entries.map((entry) => entry.id)).toEqual(['custom_block_reports', 'notion'])
+    expect(first.entries.map((entry) => entry.id)).toEqual(['custom_block_reports', 'loop'])
     expect(first.hasMore).toBe(true)
 
     const second = await listCatalogBlocks.execute({
       principal: session,
       input: { ...listInput, limit: 2, offset: 2 },
     })
-    expect(second.entries.map((entry) => entry.id)).toEqual(['slack'])
-    expect(second.hasMore).toBe(false)
+    expect(second.entries.map((entry) => entry.id)).toEqual(['notion', 'parallel'])
+    expect(second.hasMore).toBe(true)
+  })
+
+  it('answers for the loop and parallel containers with their authoring shape', async () => {
+    const { block: loop } = await getCatalogBlock.execute({
+      principal: session,
+      input: { workspaceId: WORKSPACE_ID, blockId: 'loop' },
+    })
+    expect(loop.id).toBe('loop')
+    expect(
+      loop.inputSchema.find((field) => field.id === 'loopType')?.options?.map((o) => o.id)
+    ).toEqual(['for', 'forEach', 'while', 'doWhile'])
+    expect(Object.keys(loop.outputs)).toContain('results')
+
+    const { block: parallel } = await getCatalogBlock.execute({
+      principal: session,
+      input: { workspaceId: WORKSPACE_ID, blockId: 'parallel' },
+    })
+    expect(
+      parallel.inputSchema.find((field) => field.id === 'parallelType')?.options?.map((o) => o.id)
+    ).toEqual(['count', 'collection'])
   })
 
   it('reads one block with its operations and tools resolved from metadata', async () => {
@@ -566,7 +595,12 @@ describe('catalog block and tool reads', () => {
      * positive by code unit. Pinning the code-unit answer is what makes an
      * offset cursor name the same row on every instance, whatever its `LANG`.
      */
-    expect(result.entries.map((entry) => entry.name)).toEqual(['Banana', 'apple'])
+    expect(result.entries.map((entry) => entry.name)).toEqual([
+      'Banana',
+      'Loop',
+      'Parallel',
+      'apple',
+    ])
   })
 
   it('reports no hosted key on a deployment that supplies none', async () => {

apps/sim/lib/catalog/application/get-block.ts

@@ -6,6 +6,7 @@ import {
 } from '@/lib/catalog/application/catalog-context'
 import { catalogOperations } from '@/lib/catalog/application/operations'
 import { type CatalogBlockDetail, projectBlockDetail } from '@/lib/catalog/projection/block-detail'
+import { getContainerBlockDetail } from '@/lib/catalog/projection/container-blocks'
 import { defineAuthorizedWorkspaceUseCase } from '@/lib/core/application'
 import { isHosted } from '@/lib/core/config/env-flags'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
@@ -43,6 +44,10 @@ export const getCatalogBlock = defineAuthorizedWorkspaceUseCase({
     const gate = await resolveCatalogGate(principal, context)
 
     const detail = await withCatalogBlockScope(gate, async () => {
+      // Containers (loop/parallel) are authorable types outside the registry;
+      // the catalog answers for the same vocabulary add_block accepts.
+      const container = getContainerBlockDetail(input.blockId)
+      if (container) return container
       const block = getLatestBlockForViewer(input.blockId)
       if (!block || !isBlockVisibleToCaller(block, gate)) return null
       return projectBlockDetail(block, { deployment: { hostedKeys: isHosted } })

apps/sim/lib/catalog/application/list-blocks.ts

@@ -17,6 +17,7 @@ import {
   type CatalogBlockSummary,
   projectBlockSummary,
 } from '@/lib/catalog/projection/block-summary'
+import { CONTAINER_BLOCK_SUMMARIES } from '@/lib/catalog/projection/container-blocks'
 import { defineAuthorizedWorkspaceUseCase } from '@/lib/core/application'
 import { getAllBlocks } from '@/blocks/registry'
 
@@ -70,11 +71,14 @@ export const listCatalogBlocks = defineAuthorizedWorkspaceUseCase({
     const search = normalizeCatalogSearch(input.search)
     const gate = await resolveCatalogGate(principal, context)
 
-    const summaries = await withCatalogBlockScope(gate, async () =>
-      getAllBlocks()
+    const summaries = await withCatalogBlockScope(gate, async () => [
+      ...getAllBlocks()
         .filter((block) => isBlockVisibleToCaller(block, gate))
-        .map(projectBlockSummary)
-    )
+        .map(projectBlockSummary),
+      // Containers are authorable types (add_block accepts them) that live outside
+      // the registry — the catalog speaks the same vocabulary as authoring.
+      ...CONTAINER_BLOCK_SUMMARIES,
+    ])
 
     const filtered = summaries.filter(
       (block) =>

apps/sim/lib/catalog/projection/container-blocks.ts

@@ -0,0 +1,165 @@
+import type { CatalogBlockDetail } from '@/lib/catalog/projection/block-detail'
+import type { CatalogBlockSummary } from '@/lib/catalog/projection/block-summary'
+import { VALID_LOOP_TYPES, VALID_PARALLEL_TYPES } from '@/lib/workflows/editing/operations'
+
+/**
+ * Loop and Parallel are containers, not registry blocks — yet the authoring
+ * surface accepts them as `type: "loop"` / `type: "parallel"` in add_block
+ * operations, and the canvas presents them alongside blocks. A catalog that
+ * omits them teaches one vocabulary and 404s on the other; these descriptors
+ * make the catalog speak the authoring surface's language. Their option lists
+ * import the authoring constants directly, so the surfaces cannot drift.
+ */
+
+const loopSummary: CatalogBlockSummary = {
+  id: 'loop',
+  name: 'Loop',
+  description:
+    'Container that runs its child blocks repeatedly: a fixed count (for), once per item of a collection (forEach), or while a condition holds (while/doWhile).',
+  category: 'blocks',
+  source: 'builtin',
+  triggerAllowed: false,
+  triggerCapable: false,
+  preview: false,
+  tags: [],
+  triggerIds: [],
+  toolIds: [],
+  operationIds: [],
+}
+
+const parallelSummary: CatalogBlockSummary = {
+  id: 'parallel',
+  name: 'Parallel',
+  description:
+    'Container that runs its child blocks in concurrent branches: a fixed count, or one branch per item of a collection.',
+  category: 'blocks',
+  source: 'builtin',
+  triggerAllowed: false,
+  triggerCapable: false,
+  preview: false,
+  tags: [],
+  triggerIds: [],
+  toolIds: [],
+  operationIds: [],
+}
+
+const CONTAINER_USAGE =
+  'Containers are authored through workflows operations apply (add_block with this type, children via nestedNodes or parentId), not placed like tool blocks. Wire the body through the container handles (loop-start-source / loop-end-source, parallel-start-source / parallel-end-source); an unwired body never runs.'
+
+const loopDetail: CatalogBlockDetail = {
+  ...loopSummary,
+  bestPractices: CONTAINER_USAGE,
+  inputSchema: [
+    {
+      id: 'loopType',
+      type: 'dropdown',
+      title: 'Loop type',
+      required: true,
+      options: VALID_LOOP_TYPES.map((id) => ({ id })),
+      description: 'How iteration is driven. Defaults to "for".',
+    },
+    {
+      id: 'iterations',
+      type: 'short-input',
+      title: 'Iterations',
+      condition: { field: 'loopType', value: 'for' },
+      description: 'Number of iterations for a for loop.',
+    },
+    {
+      id: 'collection',
+      type: 'long-input',
+      title: 'Collection',
+      condition: { field: 'loopType', value: 'forEach' },
+      description: 'Array (or reference resolving to one) iterated by a forEach loop.',
+    },
+    {
+      id: 'condition',
+      type: 'long-input',
+      title: 'Condition',
+      condition: { field: 'loopType', value: ['while', 'doWhile'] },
+      description:
+        'Continue condition for while/doWhile. May not reference blocks inside the loop body.',
+    },
+  ],
+  operationInputSchema: {},
+  inputDefinitions: {},
+  operations: {},
+  tools: [],
+  triggers: [],
+  outputs: {
+    index: {
+      type: 'number',
+      description: 'Current iteration index inside the body (<loop.index>).',
+    },
+    currentItem: {
+      type: 'any',
+      description: 'Current item inside a forEach body (<loop.currentItem>).',
+    },
+    items: {
+      type: 'array',
+      description: 'The full collection inside a forEach body (<loop.items>).',
+    },
+    results: {
+      type: 'array',
+      description:
+        'All iteration results, referenced OUTSIDE the loop by its block name (<myLoop.results>).',
+    },
+  },
+}
+
+const parallelDetail: CatalogBlockDetail = {
+  ...parallelSummary,
+  bestPractices: CONTAINER_USAGE,
+  inputSchema: [
+    {
+      id: 'parallelType',
+      type: 'dropdown',
+      title: 'Parallel type',
+      required: true,
+      options: VALID_PARALLEL_TYPES.map((id) => ({ id })),
+      description: 'How branches are created. Defaults to "count".',
+    },
+    {
+      id: 'count',
+      type: 'short-input',
+      title: 'Count',
+      condition: { field: 'parallelType', value: 'count' },
+      description: 'Number of concurrent branches.',
+    },
+    {
+      id: 'collection',
+      type: 'long-input',
+      title: 'Collection',
+      condition: { field: 'parallelType', value: 'collection' },
+      description: 'Array (or reference resolving to one) fanned out one branch per item.',
+    },
+  ],
+  operationInputSchema: {},
+  inputDefinitions: {},
+  operations: {},
+  tools: [],
+  triggers: [],
+  outputs: {
+    index: { type: 'number', description: 'Branch index inside the body (<parallel.index>).' },
+    currentItem: {
+      type: 'any',
+      description: 'Current item inside a collection branch (<parallel.currentItem>).',
+    },
+    results: {
+      type: 'array',
+      description:
+        'All branch results, referenced OUTSIDE by the block name (<myParallel.results>).',
+    },
+  },
+}
+
+export const CONTAINER_BLOCK_SUMMARIES: CatalogBlockSummary[] = [loopSummary, parallelSummary]
+
+const CONTAINER_BLOCK_DETAILS: Record<string, CatalogBlockDetail> = {
+  loop: loopDetail,
+  parallel: parallelDetail,
+}
+
+export function getContainerBlockDetail(blockId: string): CatalogBlockDetail | null {
+  return CONTAINER_BLOCK_DETAILS[blockId] ?? null
+}

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

@@ -100,3 +100,24 @@ describe('applyPipeline', () => {
     expect(applyPipeline('', [['head', '-n', '5']]).ok).toBe(false)
   })
 })
+
+describe('grep context flags', () => {
+  const input = 'a\nb\nHIT\nc\nd\ne\nHIT\nf'
+  it('-A appends trailing context lines', () => {
+    const r = applyPipeline(input, [['grep', '-A', '1', 'HIT']])
+    expect(r).toEqual({ ok: true, stdout: 'HIT\nc\nHIT\nf' })
+  })
+  it('-B and -C select windows without duplicating overlaps', () => {
+    const r = applyPipeline('x\nHIT\nHIT\ny', [['grep', '-C', '1', 'HIT']])
+    expect(r).toEqual({ ok: true, stdout: 'x\nHIT\nHIT\ny' })
+  })
+  it('-c counts hits, not context lines', () => {
+    const r = applyPipeline(input, [['grep', '-c', '-A', '2', 'HIT']])
+    expect(r).toEqual({ ok: true, stdout: '2' })
+  })
+  it('rejects a negative context count with usage guidance', () => {
+    const r = applyPipeline(input, [['grep', '-A', '-2', 'HIT']])
+    expect(r.ok).toBe(false)
+    if (!r.ok) expect(r.error).toContain('-A needs a non-negative number')
+  })
+})