@pikku/inspector 0.12.7 → 0.12.9

package/src/utils/extract-function-name.ts

@@ -1,5 +1,6 @@
 import * as ts from 'typescript'
 import { randomUUID } from 'crypto'
+import { formatVersionedId } from '@pikku/core'
 
 export type ExtractedFunctionName = {
   pikkuFuncId: string
@@ -8,6 +9,7 @@ export type ExtractedFunctionName = {
   exportedName: string | null
   propertyName: string | null
   isHelper: boolean
+  version: number | null
 }
 
 export function makeContextBasedId(
@@ -40,6 +42,7 @@ export function extractFunctionName(
     propertyName: null,
     explicitName: null,
     isHelper: false,
+    version: null,
   }
 
   const workflowHelpers = new Set([
@@ -143,18 +146,7 @@ export function extractFunctionName(
       // Check for object with 'name' property in first argument
       const firstArg = args[0]
       if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-        for (const prop of firstArg.properties) {
-          if (
-            ts.isPropertyAssignment(prop) &&
-            ts.isIdentifier(prop.name) &&
-            prop.name.text === 'override' &&
-            ts.isStringLiteral(prop.initializer)
-          ) {
-            // Priority 1: Object with override property
-            result.explicitName = prop.initializer.text
-            break
-          }
-        }
+        extractOverrideAndVersion(firstArg, result)
       }
 
       // Special handling for pikkuSessionlessFunc pattern - use the arrow function directly
@@ -367,21 +359,9 @@ export function extractFunctionName(
             ts.isIdentifier(decl.initializer.expression) &&
             decl.initializer.expression.text.startsWith('pikku')
           ) {
-            // Check for object with 'override' property in first argument
             const firstArg = decl.initializer.arguments[0]
             if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-              for (const prop of firstArg.properties) {
-                if (
-                  ts.isPropertyAssignment(prop) &&
-                  ts.isIdentifier(prop.name) &&
-                  prop.name.text === 'override' &&
-                  ts.isStringLiteral(prop.initializer)
-                ) {
-                  // Priority 1: Object with override property
-                  result.explicitName = prop.initializer.text
-                  break
-                }
-              }
+              extractOverrideAndVersion(firstArg, result)
             }
 
             if (decl.initializer.expression.text.startsWith('pikku')) {
@@ -448,18 +428,7 @@ export function extractFunctionName(
   else if (ts.isCallExpression(callExpr)) {
     const firstArg = callExpr.arguments[0]
     if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-      for (const prop of firstArg.properties) {
-        if (
-          ts.isPropertyAssignment(prop) &&
-          ts.isIdentifier(prop.name) &&
-          prop.name.text === 'override' &&
-          ts.isStringLiteral(prop.initializer) &&
-          !result.explicitName // Only set if not already set
-        ) {
-          result.explicitName = prop.initializer.text
-          break
-        }
-      }
+      extractOverrideAndVersion(firstArg, result)
     }
   }
 
@@ -474,6 +443,10 @@ export function extractFunctionName(
     result.pikkuFuncId = `__temp_${randomUUID()}`
   }
 
+  if (result.version !== null) {
+    result.pikkuFuncId = formatVersionedId(result.pikkuFuncId, result.version)
+  }
+
   return result
 }
 
@@ -539,3 +512,29 @@ export function isNamedExport(
 
   return false
 }
+
+function extractOverrideAndVersion(
+  objLiteral: ts.ObjectLiteralExpression,
+  result: ExtractedFunctionName
+): void {
+  for (const prop of objLiteral.properties) {
+    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+      if (
+        prop.name.text === 'override' &&
+        ts.isStringLiteral(prop.initializer) &&
+        !result.explicitName
+      ) {
+        result.explicitName = prop.initializer.text
+      } else if (
+        prop.name.text === 'version' &&
+        ts.isNumericLiteral(prop.initializer) &&
+        result.version === null
+      ) {
+        const parsed = Number(prop.initializer.text)
+        if (Number.isInteger(parsed) && parsed >= 1) {
+          result.version = parsed
+        }
+      }
+    }
+  }
+}

package/src/utils/extract-node-value.test.ts

@@ -0,0 +1,67 @@
+import { test, describe } from 'node:test'
+import { strict as assert } from 'node:assert'
+import * as ts from 'typescript'
+import { extractDescription } from './extract-node-value'
+
+const createChecker = (source: string) => {
+  const sourceFile = ts.createSourceFile(
+    'test.ts',
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  )
+  const host = ts.createCompilerHost({})
+  const originalGetSourceFile = host.getSourceFile
+  host.getSourceFile = (fileName, target) => {
+    if (fileName === 'test.ts') return sourceFile
+    return originalGetSourceFile.call(host, fileName, target)
+  }
+  const program = ts.createProgram(['test.ts'], {}, host)
+  return { checker: program.getTypeChecker(), sourceFile }
+}
+
+const findObjectLiteral = (
+  node: ts.Node
+): ts.ObjectLiteralExpression | undefined => {
+  if (ts.isObjectLiteralExpression(node)) return node
+  let result: ts.ObjectLiteralExpression | undefined
+  ts.forEachChild(node, (child) => {
+    if (!result) result = findObjectLiteral(child)
+  })
+  return result
+}
+
+describe('extractDescription', () => {
+  test('returns null when node is undefined', () => {
+    const { checker } = createChecker('')
+    assert.equal(extractDescription(undefined, checker), null)
+  })
+
+  test('extracts string literal description', () => {
+    const { checker, sourceFile } = createChecker(
+      `const opts = { description: 'my step' }`
+    )
+    const obj = findObjectLiteral(sourceFile)!
+    assert.equal(extractDescription(obj, checker), 'my step')
+  })
+
+  test('returns null for non-literal description value without crashing', () => {
+    const { checker, sourceFile } = createChecker(
+      `const name = 'test'; const data = { description: name + ' addon' }`
+    )
+    const objs: ts.ObjectLiteralExpression[] = []
+    const visit = (node: ts.Node) => {
+      if (ts.isObjectLiteralExpression(node)) objs.push(node)
+      ts.forEachChild(node, visit)
+    }
+    ts.forEachChild(sourceFile, visit)
+    const dataObj = objs[objs.length - 1]!
+    assert.equal(extractDescription(dataObj, checker), null)
+  })
+
+  test('returns null for non-object node', () => {
+    const { checker, sourceFile } = createChecker(`const x = 42`)
+    assert.equal(extractDescription(sourceFile, checker), null)
+  })
+})

package/src/utils/extract-node-value.ts

@@ -110,7 +110,11 @@ export function extractDescription(
   if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
     return null
   }
-  return extractPropertyString(optionsNode, 'description', checker)
+  try {
+    return extractPropertyString(optionsNode, 'description', checker)
+  } catch {
+    return null
+  }
 }
 
 /**

package/src/utils/filter-inspector-state.ts

@@ -191,6 +191,11 @@ export function filterInspectorState(
     return state
   }
 
+  // Snapshot the original workflow graph meta before filtering prunes it
+  const originalGraphMeta = {
+    ...((state as InspectorState).workflows?.graphMeta ?? {}),
+  }
+
   // Create a shallow copy with new Maps/Sets to avoid mutating the original
   const filteredState = {
     ...state,
@@ -201,11 +206,21 @@ export function filterInspectorState(
       usedMiddleware: new Set<string>(),
       usedPermissions: new Set<string>(),
     },
+    functions: {
+      ...state.functions,
+      meta: JSON.parse(JSON.stringify(state.functions.meta)), // Deep clone to avoid mutating original
+      files: new Map(state.functions.files),
+    },
     http: {
       ...state.http,
       meta: JSON.parse(JSON.stringify(state.http.meta)), // Deep clone metadata
       files: new Set<string>(), // Will be repopulated with filtered files
     },
+    workflows: {
+      ...state.workflows,
+      graphMeta: JSON.parse(JSON.stringify(state.workflows?.graphMeta ?? {})),
+      meta: JSON.parse(JSON.stringify(state.workflows?.meta ?? {})),
+    },
     channels: {
       ...state.channels,
       meta: JSON.parse(JSON.stringify(state.channels.meta)),
@@ -240,6 +255,14 @@ export function filterInspectorState(
       agentsMeta: JSON.parse(JSON.stringify(state.agents?.agentsMeta ?? {})),
       files: new Map(),
     },
+    rpc: {
+      ...state.rpc,
+      internalMeta: { ...state.rpc.internalMeta }, // Clone to avoid mutating original
+      internalFiles: new Map(state.rpc.internalFiles),
+      exposedMeta: { ...state.rpc.exposedMeta },
+      exposedFiles: new Map(state.rpc.exposedFiles),
+      invokedFunctions: new Set(state.rpc.invokedFunctions),
+    },
     cli: {
       ...state.cli,
       meta: JSON.parse(JSON.stringify(state.cli.meta)),
@@ -280,6 +303,14 @@ export function filterInspectorState(
           filteredState.serviceAggregation.usedFunctions.add(
             routeMeta.pikkuFuncId
           )
+          // For workflow/agent routes, also add the base name
+          // so the workflow/agent definition survives pruning
+          const colonIdx = routeMeta.pikkuFuncId.indexOf(':')
+          if (colonIdx !== -1) {
+            filteredState.serviceAggregation.usedFunctions.add(
+              routeMeta.pikkuFuncId.slice(colonIdx + 1)
+            )
+          }
         }
         extractWireNames(routeMeta.middleware).forEach((name: string) =>
           filteredState.serviceAggregation.usedMiddleware.add(name)
@@ -291,12 +322,28 @@ export function filterInspectorState(
     }
   }
 
-  // Repopulate http.files if any routes remain
-  const hasHttpRoutes = Object.values(
-    filteredState.http.meta as Record<string, any>
-  ).some((routes) => Object.keys(routes).length > 0)
-  if (hasHttpRoutes) {
-    filteredState.http.files = new Set(state.http.files)
+  // Repopulate http.files with only files that have surviving routes
+  for (const method of Object.keys(filteredState.http.meta)) {
+    const routes = (
+      filteredState.http.meta as Record<
+        string,
+        Record<string, { sourceFile?: string }>
+      >
+    )[method]
+    for (const routeMeta of Object.values(routes)) {
+      if (routeMeta.sourceFile) {
+        filteredState.http.files.add(routeMeta.sourceFile)
+      }
+    }
+  }
+  // Fallback: if no sourceFile info available but routes exist, include all files
+  if (filteredState.http.files.size === 0) {
+    const hasHttpRoutes = Object.values(
+      filteredState.http.meta as Record<string, Record<string, unknown>>
+    ).some((routes) => Object.keys(routes).length > 0)
+    if (hasHttpRoutes) {
+      filteredState.http.files = new Set(state.http.files)
+    }
   }
 
   // Filter channels
@@ -315,11 +362,40 @@ export function filterInspectorState(
     if (!matches) {
       delete filteredState.channels.meta[name]
     } else {
-      if (channelMeta.pikkuFuncId) {
+      // Add all functions referenced by this channel
+      if ('pikkuFuncId' in channelMeta && channelMeta.pikkuFuncId) {
+        filteredState.serviceAggregation.usedFunctions.add(
+          channelMeta.pikkuFuncId as string
+        )
+      }
+      if (channelMeta.connect?.pikkuFuncId) {
+        filteredState.serviceAggregation.usedFunctions.add(
+          channelMeta.connect.pikkuFuncId
+        )
+      }
+      if (channelMeta.disconnect?.pikkuFuncId) {
         filteredState.serviceAggregation.usedFunctions.add(
-          channelMeta.pikkuFuncId
+          channelMeta.disconnect.pikkuFuncId
         )
       }
+      if (channelMeta.message?.pikkuFuncId) {
+        filteredState.serviceAggregation.usedFunctions.add(
+          channelMeta.message.pikkuFuncId
+        )
+      }
+      if (channelMeta.messageWirings) {
+        for (const groupKey of Object.keys(channelMeta.messageWirings)) {
+          const commands = channelMeta.messageWirings[groupKey]
+          for (const cmdKey of Object.keys(commands)) {
+            const wiring = commands[cmdKey]
+            if (wiring.pikkuFuncId) {
+              filteredState.serviceAggregation.usedFunctions.add(
+                wiring.pikkuFuncId
+              )
+            }
+          }
+        }
+      }
       extractWireNames(channelMeta.middleware).forEach((name: string) =>
         filteredState.serviceAggregation.usedMiddleware.add(name)
       )
@@ -413,6 +489,12 @@ export function filterInspectorState(
         filteredState.serviceAggregation.usedFunctions.add(
           workerMeta.pikkuFuncId
         )
+        const colonIdx = workerMeta.pikkuFuncId.indexOf(':')
+        if (colonIdx !== -1) {
+          filteredState.serviceAggregation.usedFunctions.add(
+            workerMeta.pikkuFuncId.slice(colonIdx + 1)
+          )
+        }
       }
       extractWireNames(workerMeta.middleware).forEach((name: string) =>
         filteredState.serviceAggregation.usedMiddleware.add(name)
@@ -616,11 +698,47 @@ export function filterInspectorState(
     filteredState.cli.files = new Set(state.cli.files)
   }
 
-  // Post-filter version expansion: include all versions of matched functions
+  // Direct function filtering: functions that match the names/tags/directories
+  // filters should be included even if no wiring (HTTP, scheduler, etc.) references them.
+  // This ensures standalone RPC-callable functions survive filtering.
+  // Only run when function-level filters are active — httpRoutes/httpMethods work
+  // through the HTTP wiring pass which already adds the right functions.
+  const hasFunctionLevelFilters =
+    (filters.names && filters.names.length > 0) ||
+    (filters.tags && filters.tags.length > 0) ||
+    (filters.directories && filters.directories.length > 0)
+
+  for (const funcId of Object.keys(filteredState.functions.meta)) {
+    if (!hasFunctionLevelFilters) break
+    const funcMeta = filteredState.functions.meta[funcId]
+    const funcFile = filteredState.functions.files.get(funcId)
+    const filePath = funcFile?.path
+
+    const matches = matchesFilters(
+      filters,
+      {
+        type: 'rpc' as PikkuWiringTypes,
+        name: funcId,
+        tags: funcMeta.tags,
+        filePath,
+      },
+      logger
+    )
+
+    if (matches) {
+      filteredState.serviceAggregation.usedFunctions.add(funcId)
+    }
+  }
+
+  // Post-filter version expansion: when an unversioned base name is matched,
+  // include all its versions. Specific version matches (e.g. analyzeData@v1)
+  // do NOT expand to include other versions.
   const includedBaseNames = new Set<string>()
   for (const funcId of filteredState.serviceAggregation.usedFunctions) {
-    const { baseName } = parseVersionedId(funcId)
-    includedBaseNames.add(baseName)
+    const { baseName, version } = parseVersionedId(funcId)
+    if (version === null) {
+      includedBaseNames.add(baseName)
+    }
   }
   if (includedBaseNames.size > 0) {
     for (const funcId of Object.keys(state.functions.meta)) {
@@ -631,6 +749,123 @@ export function filterInspectorState(
     }
   }
 
+  // Prune functions.meta and functions.files to only include used functions
+  if (filteredState.serviceAggregation.usedFunctions.size > 0) {
+    for (const funcId of Object.keys(filteredState.functions.meta)) {
+      if (!filteredState.serviceAggregation.usedFunctions.has(funcId)) {
+        delete filteredState.functions.meta[funcId]
+        filteredState.functions.files.delete(funcId)
+      }
+    }
+
+    // Prune channels whose functions were filtered out
+    for (const name of Object.keys(filteredState.channels.meta)) {
+      const channelMeta = filteredState.channels.meta[name]
+      // Check if any of the channel's functions are in the used set
+      const channelFuncIds: string[] = []
+      if (channelMeta.connect?.pikkuFuncId)
+        channelFuncIds.push(channelMeta.connect.pikkuFuncId)
+      if (channelMeta.disconnect?.pikkuFuncId)
+        channelFuncIds.push(channelMeta.disconnect.pikkuFuncId)
+      if (channelMeta.message?.pikkuFuncId)
+        channelFuncIds.push(channelMeta.message.pikkuFuncId)
+      if (channelMeta.messageWirings) {
+        for (const groupKey of Object.keys(channelMeta.messageWirings)) {
+          const commands = channelMeta.messageWirings[groupKey]
+          for (const cmdKey of Object.keys(commands)) {
+            const wiring = commands[cmdKey]
+            if (wiring.pikkuFuncId) channelFuncIds.push(wiring.pikkuFuncId)
+          }
+        }
+      }
+      const hasUsedFunc = channelFuncIds.some((id) =>
+        filteredState.serviceAggregation.usedFunctions.has(id)
+      )
+      if (channelFuncIds.length > 0 && !hasUsedFunc) {
+        delete filteredState.channels.meta[name]
+      }
+    }
+
+    // Prune workflow graphs whose function was filtered out
+    const workflowKeys = new Set([
+      ...Object.keys(filteredState.workflows.graphMeta),
+      ...Object.keys(filteredState.workflows.meta),
+    ])
+    for (const name of workflowKeys) {
+      const graphMeta = filteredState.workflows.graphMeta[name]
+      const workflowMeta = filteredState.workflows.meta[name]
+      // Check both graphMeta.pikkuFuncId and meta.pikkuFuncId
+      const pikkuFuncId = graphMeta?.pikkuFuncId ?? workflowMeta?.pikkuFuncId
+      if (
+        pikkuFuncId &&
+        !filteredState.serviceAggregation.usedFunctions.has(pikkuFuncId)
+      ) {
+        delete filteredState.workflows.graphMeta[name]
+        delete filteredState.workflows.meta[name]
+      } else if (!pikkuFuncId) {
+        // No function ID found — prune it
+        delete filteredState.workflows.graphMeta[name]
+        delete filteredState.workflows.meta[name]
+      }
+    }
+
+    // Prune RPC meta to only include entries whose target function survived
+    const survivingFuncIds = new Set(Object.keys(filteredState.functions.meta))
+    for (const key of Object.keys(filteredState.rpc.internalMeta)) {
+      const targetFuncId = filteredState.rpc.internalMeta[key]
+      if (!survivingFuncIds.has(targetFuncId) && !survivingFuncIds.has(key)) {
+        delete filteredState.rpc.internalMeta[key]
+        filteredState.rpc.internalFiles.delete(key)
+      }
+    }
+    for (const key of Object.keys(filteredState.rpc.exposedMeta)) {
+      const targetFuncId = filteredState.rpc.exposedMeta[key]
+      if (!survivingFuncIds.has(targetFuncId) && !survivingFuncIds.has(key)) {
+        delete filteredState.rpc.exposedMeta[key]
+        filteredState.rpc.exposedFiles.delete(key)
+      }
+    }
+    // Prune invokedFunctions to match surviving functions
+    for (const funcId of filteredState.rpc.invokedFunctions) {
+      if (!survivingFuncIds.has(funcId)) {
+        filteredState.rpc.invokedFunctions.delete(funcId)
+      }
+    }
+  }
+
+  // Recompute requiredSchemas based on pruned functions.meta
+  if (filteredState.serviceAggregation.usedFunctions.size > 0) {
+    const prunedSchemas = new Set<string>()
+    for (const funcMeta of Object.values(
+      filteredState.functions.meta
+    ) as Array<{ inputs?: string[]; outputs?: string[] }>) {
+      if (funcMeta.inputs?.[0]) prunedSchemas.add(funcMeta.inputs[0])
+      if (funcMeta.outputs?.[0]) prunedSchemas.add(funcMeta.outputs[0])
+    }
+    filteredState.requiredSchemas = prunedSchemas
+  }
+
+  // If any surviving function is a non-inline workflow step, the unit needs
+  // workflowService + queueService even though the function doesn't use them.
+  // Check the ORIGINAL graph meta (before filtering pruned it).
+  const survivingFuncIds = new Set(Object.keys(filteredState.functions.meta))
+  // Use the snapshot taken before filtering
+  for (const graph of Object.values(originalGraphMeta)) {
+    if (!graph.nodes) continue
+    for (const node of Object.values(graph.nodes)) {
+      if (!('rpcName' in node) || !node.rpcName) continue
+      const rpcName = node.rpcName as string
+      if (!survivingFuncIds.has(rpcName)) continue
+      const isInline =
+        (node as { options?: { async?: boolean } }).options?.async !== true &&
+        graph.inline === true
+      if (!isInline) {
+        filteredState.serviceAggregation.requiredServices.add('workflowService')
+        filteredState.serviceAggregation.requiredServices.add('queueService')
+      }
+    }
+  }
+
   // Recalculate requiredServices based on filtered functions/middleware/permissions
   // Need to cast to InspectorState temporarily for aggregateRequiredServices
   const stateForAggregation = filteredState as InspectorState

package/src/utils/load-addon-functions-meta.ts

@@ -45,6 +45,65 @@ export async function loadAddonFunctionsMeta(
           }
         }
       }
+      // Load addon secrets meta
+      try {
+        const secretsMetaPath = require.resolve(
+          `${decl.package}/.pikku/secrets/pikku-secrets-meta.gen.json`
+        )
+        const secretsRaw = await readFile(secretsMetaPath, 'utf-8')
+        const secretsMeta = JSON.parse(secretsRaw)
+        for (const [key, def] of Object.entries<any>(secretsMeta)) {
+          const existing = state.secrets.definitions.find(
+            (d: any) => d.name === key
+          )
+          if (!existing) {
+            state.secrets.definitions.push(def)
+            logger.debug(`Loaded addon secret '${key}' from ${decl.package}`)
+          }
+        }
+      } catch {
+        // No secrets meta — that's fine
+      }
+
+      // Load addon variables meta
+      try {
+        const variablesMetaPath = require.resolve(
+          `${decl.package}/.pikku/variables/pikku-variables-meta.gen.json`
+        )
+        const variablesRaw = await readFile(variablesMetaPath, 'utf-8')
+        const variablesMeta = JSON.parse(variablesRaw)
+        for (const [key, def] of Object.entries<any>(variablesMeta)) {
+          const existing = state.variables.definitions.find(
+            (d: any) => d.name === key
+          )
+          if (!existing) {
+            state.variables.definitions.push(def)
+            logger.debug(`Loaded addon variable '${key}' from ${decl.package}`)
+          }
+        }
+      } catch {
+        // No variables meta — that's fine
+      }
+      // Load addon required parent services from pikku-services.gen
+      try {
+        const servicesGenPath = require.resolve(
+          `${decl.package}/.pikku/pikku-services.gen.js`
+        )
+        const servicesModule = await import(servicesGenPath)
+        if (
+          servicesModule.requiredParentServices &&
+          Array.isArray(servicesModule.requiredParentServices)
+        ) {
+          for (const service of servicesModule.requiredParentServices) {
+            state.addonRequiredParentServices.push(service)
+          }
+          logger.debug(
+            `Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`
+          )
+        }
+      } catch {
+        // No services gen — addon may not have requiredParentServices
+      }
     } catch (error: any) {
       logger.warn(
         `Failed to load addon function metadata for '${namespace}' (${decl.package}): ${error.message}`

package/src/utils/post-process.ts

@@ -221,6 +221,80 @@ export function aggregateRequiredServices(
       }
     })
   }
+
+  // 6. Implicit platform services required by wiring types
+  // Workflows need workflowService + workflowRunService + schedulerService + queueService.
+  // Check workflow definitions, graph meta, AND helper functions (workflowStart:*, etc.)
+  // that wrap workflow operations but don't destructure the services.
+  const hasWorkflows =
+    Object.keys(state.workflows.graphMeta).length > 0 ||
+    Object.keys(state.workflows.meta).length > 0 ||
+    Object.keys(state.functions.meta).some(
+      (id) =>
+        id.startsWith('workflowStart:') ||
+        id.startsWith('workflowStatus:') ||
+        id.startsWith('workflow:')
+    )
+  if (hasWorkflows) {
+    requiredServices.add('workflowService')
+    requiredServices.add('workflowRunService')
+    requiredServices.add('schedulerService')
+    requiredServices.add('queueService')
+  }
+
+  // 6b. Inject synthetic queue workers for workflow graph steps.
+  // Each workflow gets an orchestrator queue and per-step queues.
+  // Without these, the PikkuWorkflowService constructor can't find
+  // per-workflow queue entries and falls back to shared queue names.
+  for (const [, graph] of Object.entries(state.workflows.graphMeta)) {
+    if (!graph.nodes || !graph.name) continue
+
+    const toKebab = (s: string) =>
+      s
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase()
+
+    // Orchestrator queue
+    const orchQueueName = `wf-orchestrator-${toKebab(graph.name)}`
+    if (!state.queueWorkers.meta[orchQueueName]) {
+      state.queueWorkers.meta[orchQueueName] = {
+        name: orchQueueName,
+        pikkuFuncId: `pikkuWorkflowOrchestrator:${graph.name}`,
+      }
+    }
+
+    // Per-step queues
+    for (const node of Object.values(graph.nodes)) {
+      if (!('rpcName' in node) || !node.rpcName) continue
+      const rpcName = node.rpcName as string
+      const stepQueueName = `wf-step-${toKebab(rpcName)}`
+      if (!state.queueWorkers.meta[stepQueueName]) {
+        state.queueWorkers.meta[stepQueueName] = {
+          name: stepQueueName,
+          pikkuFuncId: `pikkuWorkflowWorker:${rpcName}`,
+        }
+      }
+    }
+  }
+
+  // AI agents need aiStorage + aiRunState + agentRunService + aiAgentRunner
+  if (Object.keys(state.agents.agentsMeta).length > 0) {
+    requiredServices.add('aiStorage')
+    requiredServices.add('aiRunState')
+    requiredServices.add('agentRunService')
+    requiredServices.add('aiAgentRunner')
+  }
+
+  // Channels need eventHub for pub/sub
+  if (Object.keys(state.channels.meta).length > 0) {
+    requiredServices.add('eventHub')
+  }
+
+  // 7. Services that addons need from the parent project
+  for (const service of state.addonRequiredParentServices ?? []) {
+    requiredServices.add(service)
+  }
 }
 
 export function validateSecretOverrides(