@pikku/inspector 0.12.11 → 0.12.12

package/dist/utils/filter-inspector-state.js

@@ -1,5 +1,6 @@
 import { parseVersionedId } from '@pikku/core';
 import { aggregateRequiredServices } from './post-process.js';
+import { resolveDeployTarget } from './resolve-deploy-target.js';
 // Module-level Set to track warned groups across multiple filter calls
 const globalWarnedGroups = new Set();
 /**
@@ -27,26 +28,85 @@ function matchesWildcard(value, pattern) {
     }
     return value === pattern;
 }
+function collectSourceFiles(value, sourceFiles = new Set(), seen = new Set()) {
+    if (typeof value === 'string') {
+        return sourceFiles;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectSourceFiles(entry, sourceFiles, seen);
+        }
+        return sourceFiles;
+    }
+    if (!value || typeof value !== 'object') {
+        return sourceFiles;
+    }
+    if (seen.has(value)) {
+        return sourceFiles;
+    }
+    seen.add(value);
+    if ('sourceFile' in value && typeof value.sourceFile === 'string') {
+        sourceFiles.add(value.sourceFile);
+    }
+    for (const nestedValue of Object.values(value)) {
+        collectSourceFiles(nestedValue, sourceFiles, seen);
+    }
+    return sourceFiles;
+}
+function repopulateFileSetFromMeta(meta, fallbackFiles, hasEntries) {
+    const sourceFiles = collectSourceFiles(meta);
+    if (sourceFiles.size > 0) {
+        return sourceFiles;
+    }
+    if (hasEntries) {
+        return new Set(fallbackFiles);
+    }
+    return new Set();
+}
 /**
  * Check if metadata matches the given filters
  */
-function matchesFilters(filters, meta, logger, warnedGroups) {
+function matchesFilters(filters, meta, logger, warnedGroups, 
+// Set of pikkuFuncIds to keep based on the deploy filter; null when
+// the deploy filter is inactive.
+keptByDeploy) {
     // If no filters, allow everything
     if (Object.keys(filters).length === 0)
         return true;
     // If all filter arrays are empty, allow everything
     if ((!filters.names || filters.names.length === 0) &&
         (!filters.tags || filters.tags.length === 0) &&
-        (!filters.types || filters.types.length === 0) &&
+        (!filters.wires || filters.wires.length === 0) &&
+        (!filters.excludeWires || filters.excludeWires.length === 0) &&
         (!filters.directories || filters.directories.length === 0) &&
         (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
-        (!filters.httpMethods || filters.httpMethods.length === 0)) {
+        (!filters.httpMethods || filters.httpMethods.length === 0) &&
+        (!filters.target || filters.target.length === 0) &&
+        (!filters.excludeNames || filters.excludeNames.length === 0) &&
+        (!filters.excludeTags || filters.excludeTags.length === 0) &&
+        (!filters.excludeWires || filters.excludeWires.length === 0) &&
+        (!filters.excludeDirectories || filters.excludeDirectories.length === 0) &&
+        (!filters.excludeHttpRoutes || filters.excludeHttpRoutes.length === 0) &&
+        (!filters.excludeHttpMethods || filters.excludeHttpMethods.length === 0) &&
+        (!filters.excludeTarget || filters.excludeTarget.length === 0)) {
         return true;
     }
-    // Check type filter
-    if (filters.types && filters.types.length > 0) {
-        if (!filters.types.includes(meta.type)) {
-            logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`);
+    // Deploy-target include filter (computed once per filterInspectorState call).
+    if (keptByDeploy && !keptByDeploy.has(meta.name)) {
+        logger.debug(`⒡ Filtered by deploy include: ${meta.type}:${meta.name}`);
+        return false;
+    }
+    // Check wire include filter
+    if (filters.wires && filters.wires.length > 0) {
+        if (!filters.wires.includes(meta.type)) {
+            logger.debug(`⒡ Filtered by wire include: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check wire exclude filter
+    if (filters.excludeWires && filters.excludeWires.length > 0) {
+        if (filters.excludeWires.includes(meta.type)) {
+            logger.debug(`⒡ Filtered by wire exclude: ${meta.type}:${meta.name}`);
             return false;
         }
     }
@@ -62,28 +122,45 @@ function matchesFilters(filters, meta, logger, warnedGroups) {
             return false;
         }
     }
-    // Check tag filter
+    // Check tag include filter
     if (filters.tags && filters.tags.length > 0) {
         if (!meta.tags || !filters.tags.some((tag) => meta.tags.includes(tag))) {
-            logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`);
+            logger.debug(`⒡ Filtered by tags include: ${meta.type}:${meta.name}`);
             return false;
         }
     }
-    // Check name filter (match against both full ID and base name for versioned functions)
+    // Check tag exclude filter
+    if (filters.excludeTags && filters.excludeTags.length > 0) {
+        if (meta.tags &&
+            filters.excludeTags.some((tag) => meta.tags.includes(tag))) {
+            logger.debug(`⒡ Filtered by tags exclude: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    const { baseName } = parseVersionedId(meta.name);
+    const matchesNamePattern = (pattern) => matchesWildcard(meta.name, pattern) ||
+        (baseName !== meta.name && matchesWildcard(baseName, pattern));
+    // Check name include filter (match against both full ID and base name for versioned functions)
     if (filters.names && filters.names.length > 0) {
-        const { baseName } = parseVersionedId(meta.name);
-        const nameMatches = filters.names.some((pattern) => matchesWildcard(meta.name, pattern) ||
-            (baseName !== meta.name && matchesWildcard(baseName, pattern)));
+        const nameMatches = filters.names.some(matchesNamePattern);
         if (!nameMatches) {
-            logger.debug(`⒡ Filtered by name: ${meta.type}:${meta.name}`);
+            logger.debug(`⒡ Filtered by name include: ${meta.type}:${meta.name}`);
             return false;
         }
     }
-    // Check HTTP route filter
+    // Check name exclude filter
+    if (filters.excludeNames && filters.excludeNames.length > 0) {
+        if (filters.excludeNames.some(matchesNamePattern)) {
+            logger.debug(`⒡ Filtered by name exclude: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    const matchesRoutePattern = (pattern) => !!meta.httpRoute && matchesWildcard(meta.httpRoute, pattern);
+    // Check HTTP route include filter
     if (filters.httpRoutes && filters.httpRoutes.length > 0 && meta.httpRoute) {
-        const routeMatches = filters.httpRoutes.some((pattern) => matchesWildcard(meta.httpRoute, pattern));
+        const routeMatches = filters.httpRoutes.some(matchesRoutePattern);
         if (!routeMatches) {
-            logger.debug(`⒡ Filtered by HTTP route: ${meta.httpRoute}`);
+            logger.debug(`⒡ Filtered by HTTP route include: ${meta.httpRoute}`);
             return false;
         }
         // If route is part of a wireHTTPRoutes group, check if filter is at group level
@@ -98,13 +175,31 @@ function matchesFilters(filters, meta, logger, warnedGroups) {
             }
         }
     }
-    // Check HTTP method filter
+    // Check HTTP route exclude filter
+    if (filters.excludeHttpRoutes &&
+        filters.excludeHttpRoutes.length > 0 &&
+        meta.httpRoute) {
+        if (filters.excludeHttpRoutes.some(matchesRoutePattern)) {
+            logger.debug(`⒡ Filtered by HTTP route exclude: ${meta.httpRoute}`);
+            return false;
+        }
+    }
+    const normalizedMethod = meta.httpMethod?.toUpperCase();
+    // Check HTTP method include filter
     if (filters.httpMethods &&
         filters.httpMethods.length > 0 &&
-        meta.httpMethod) {
-        const normalizedMethod = meta.httpMethod.toUpperCase();
+        normalizedMethod) {
         if (!filters.httpMethods.includes(normalizedMethod)) {
-            logger.debug(`⒡ Filtered by HTTP method: ${meta.httpMethod}`);
+            logger.debug(`⒡ Filtered by HTTP method include: ${meta.httpMethod}`);
+            return false;
+        }
+    }
+    // Check HTTP method exclude filter
+    if (filters.excludeHttpMethods &&
+        filters.excludeHttpMethods.length > 0 &&
+        normalizedMethod) {
+        if (filters.excludeHttpMethods.includes(normalizedMethod)) {
+            logger.debug(`⒡ Filtered by HTTP method exclude: ${meta.httpMethod}`);
             return false;
         }
     }
@@ -133,12 +228,44 @@ export function filterInspectorState(state, filters, logger) {
     if (Object.keys(filters).length === 0 ||
         ((!filters.names || filters.names.length === 0) &&
             (!filters.tags || filters.tags.length === 0) &&
-            (!filters.types || filters.types.length === 0) &&
+            (!filters.wires || filters.wires.length === 0) &&
+            (!filters.excludeWires || filters.excludeWires.length === 0) &&
             (!filters.directories || filters.directories.length === 0) &&
             (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
-            (!filters.httpMethods || filters.httpMethods.length === 0))) {
+            (!filters.httpMethods || filters.httpMethods.length === 0) &&
+            (!filters.target || filters.target.length === 0) &&
+            (!filters.excludeNames || filters.excludeNames.length === 0) &&
+            (!filters.excludeTags || filters.excludeTags.length === 0) &&
+            (!filters.excludeWires || filters.excludeWires.length === 0) &&
+            (!filters.excludeDirectories ||
+                filters.excludeDirectories.length === 0) &&
+            (!filters.excludeHttpRoutes || filters.excludeHttpRoutes.length === 0) &&
+            (!filters.excludeHttpMethods ||
+                filters.excludeHttpMethods.length === 0) &&
+            (!filters.excludeTarget || filters.excludeTarget.length === 0))) {
         return state;
     }
+    // Precompute kept-function set for the deploy filter (if active).
+    // resolveDeployTarget throws IncompatibleDeployTargetError when an
+    // explicit deploy: 'serverless' clashes with serverlessIncompatible.
+    let keptByDeploy = null;
+    if ((filters.target && filters.target.length > 0) ||
+        (filters.excludeTarget && filters.excludeTarget.length > 0)) {
+        const allowed = filters.target ? new Set(filters.target) : null;
+        const excluded = filters.excludeTarget
+            ? new Set(filters.excludeTarget)
+            : null;
+        const incompatible = new Set(filters.serverlessIncompatible ?? []);
+        keptByDeploy = new Set();
+        for (const [funcId, funcMeta] of Object.entries(state.functions.meta)) {
+            const target = resolveDeployTarget(funcMeta, incompatible, funcId);
+            if (allowed && !allowed.has(target))
+                continue;
+            if (excluded && excluded.has(target))
+                continue;
+            keptByDeploy.add(funcId);
+        }
+    }
     // Snapshot the original workflow graph meta before filtering prunes it
     const originalGraphMeta = {
         ...(state.workflows?.graphMeta ?? {}),
@@ -230,7 +357,7 @@ export function filterInspectorState(state, filters, logger) {
                 httpRoute: routeMeta.route,
                 httpMethod: routeMeta.method,
                 groupBasePath: routeMeta.groupBasePath,
-            }, logger, globalWarnedGroups);
+            }, logger, globalWarnedGroups, keptByDeploy);
             if (!matches) {
                 delete routes[route];
             }
@@ -273,7 +400,7 @@ export function filterInspectorState(state, filters, logger) {
             type: 'channel',
             name,
             tags: channelMeta.tags,
-        }, logger);
+        }, logger, undefined, keptByDeploy);
         if (!matches) {
             delete filteredState.channels.meta[name];
         }
@@ -306,10 +433,7 @@ export function filterInspectorState(state, filters, logger) {
             extractWireNames(channelMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
         }
     }
-    // Repopulate channels.files if any channels remain
-    if (Object.keys(filteredState.channels.meta).length > 0) {
-        filteredState.channels.files = new Set(state.channels.files);
-    }
+    filteredState.channels.files = repopulateFileSetFromMeta(filteredState.channels.meta, state.channels.files, Object.keys(filteredState.channels.meta).length > 0);
     // Filter triggers
     for (const name of Object.keys(filteredState.triggers.meta)) {
         const triggerMeta = filteredState.triggers.meta[name];
@@ -317,7 +441,7 @@ export function filterInspectorState(state, filters, logger) {
             type: 'trigger',
             name,
             tags: triggerMeta.tags,
-        }, logger);
+        }, logger, undefined, keptByDeploy);
         if (!matches) {
             delete filteredState.triggers.meta[name];
         }
@@ -327,10 +451,7 @@ export function filterInspectorState(state, filters, logger) {
             }
         }
     }
-    // Repopulate triggers.files if any triggers remain
-    if (Object.keys(filteredState.triggers.meta).length > 0) {
-        filteredState.triggers.files = new Set(state.triggers.files);
-    }
+    filteredState.triggers.files = repopulateFileSetFromMeta(filteredState.triggers.meta, state.triggers.files, Object.keys(filteredState.triggers.meta).length > 0);
     // Filter scheduled tasks
     for (const name of Object.keys(filteredState.scheduledTasks.meta)) {
         const taskMeta = filteredState.scheduledTasks.meta[name];
@@ -338,7 +459,7 @@ export function filterInspectorState(state, filters, logger) {
             type: 'scheduler',
             name,
             tags: taskMeta.tags,
-        }, logger);
+        }, logger, undefined, keptByDeploy);
         if (!matches) {
             delete filteredState.scheduledTasks.meta[name];
         }
@@ -349,10 +470,7 @@ export function filterInspectorState(state, filters, logger) {
             extractWireNames(taskMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
         }
     }
-    // Repopulate scheduledTasks.files if any tasks remain
-    if (Object.keys(filteredState.scheduledTasks.meta).length > 0) {
-        filteredState.scheduledTasks.files = new Set(state.scheduledTasks.files);
-    }
+    filteredState.scheduledTasks.files = repopulateFileSetFromMeta(filteredState.scheduledTasks.meta, state.scheduledTasks.files, Object.keys(filteredState.scheduledTasks.meta).length > 0);
     // Filter queue workers
     for (const name of Object.keys(filteredState.queueWorkers.meta)) {
         const workerMeta = filteredState.queueWorkers.meta[name];
@@ -360,7 +478,7 @@ export function filterInspectorState(state, filters, logger) {
             type: 'queue',
             name,
             tags: workerMeta.tags,
-        }, logger);
+        }, logger, undefined, keptByDeploy);
         if (!matches) {
             delete filteredState.queueWorkers.meta[name];
         }
@@ -375,10 +493,7 @@ export function filterInspectorState(state, filters, logger) {
             extractWireNames(workerMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
         }
     }
-    // Repopulate queueWorkers.files if any workers remain
-    if (Object.keys(filteredState.queueWorkers.meta).length > 0) {
-        filteredState.queueWorkers.files = new Set(state.queueWorkers.files);
-    }
+    filteredState.queueWorkers.files = repopulateFileSetFromMeta(filteredState.queueWorkers.meta, state.queueWorkers.files, Object.keys(filteredState.queueWorkers.meta).length > 0);
     // Filter MCP tools
     for (const name of Object.keys(filteredState.mcpEndpoints.toolsMeta)) {
         const toolMeta = filteredState.mcpEndpoints.toolsMeta[name];
@@ -386,7 +501,7 @@ export function filterInspectorState(state, filters, logger) {
             type: 'mcp',
             name,
             tags: toolMeta.tags,
-        }, logger);
+        }, logger, undefined, keptByDeploy);
         if (!matches) {
             delete filteredState.mcpEndpoints.toolsMeta[name];
         }
@@ -405,7 +520,7 @@ export function filterInspectorState(state, filters, logger) {
             type: 'mcp',
             name,
             tags: resourceMeta.tags,
-        }, logger);
+        }, logger, undefined, keptByDeploy);
         if (!matches) {
             delete filteredState.mcpEndpoints.resourcesMeta[name];
         }
@@ -424,7 +539,7 @@ export function filterInspectorState(state, filters, logger) {
             type: 'mcp',
             name,
             tags: promptMeta.tags,
-        }, logger);
+        }, logger, undefined, keptByDeploy);
         if (!matches) {
             delete filteredState.mcpEndpoints.promptsMeta[name];
         }
@@ -436,13 +551,15 @@ export function filterInspectorState(state, filters, logger) {
             extractWireNames(promptMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
         }
     }
-    // Repopulate mcpEndpoints.files if any MCP endpoints remain
+    // Repopulate mcpEndpoints.files from surviving endpoint metadata
     const hasMcpEndpoints = Object.keys(filteredState.mcpEndpoints.toolsMeta).length > 0 ||
         Object.keys(filteredState.mcpEndpoints.resourcesMeta).length > 0 ||
         Object.keys(filteredState.mcpEndpoints.promptsMeta).length > 0;
-    if (hasMcpEndpoints) {
-        filteredState.mcpEndpoints.files = new Set(state.mcpEndpoints.files);
-    }
+    filteredState.mcpEndpoints.files = repopulateFileSetFromMeta({
+        toolsMeta: filteredState.mcpEndpoints.toolsMeta,
+        resourcesMeta: filteredState.mcpEndpoints.resourcesMeta,
+        promptsMeta: filteredState.mcpEndpoints.promptsMeta,
+    }, state.mcpEndpoints.files, hasMcpEndpoints);
     // Filter AI agents
     for (const name of Object.keys(filteredState.agents.agentsMeta)) {
         const agentMeta = filteredState.agents.agentsMeta[name];
@@ -450,7 +567,7 @@ export function filterInspectorState(state, filters, logger) {
             type: 'agent',
             name,
             tags: agentMeta.tags,
-        }, logger);
+        }, logger, undefined, keptByDeploy);
         if (!matches) {
             delete filteredState.agents.agentsMeta[name];
         }
@@ -476,7 +593,7 @@ export function filterInspectorState(state, filters, logger) {
                 type: 'cli',
                 name: commandName,
                 tags: commandMeta.tags,
-            }, logger);
+            }, logger, undefined, keptByDeploy);
             if (!matches) {
                 delete programMeta.commands[commandName];
             }
@@ -502,12 +619,10 @@ export function filterInspectorState(state, filters, logger) {
             delete filteredState.cli.meta.renderers[rendererName];
         }
     }
-    // Repopulate cli.files if any CLI programs or referenced renderers remain
+    // Repopulate cli.files from surviving program/renderer metadata
     const hasCliPrograms = Object.keys(filteredState.cli.meta.programs).length > 0;
     const hasCliRenderers = Object.keys(filteredState.cli.meta.renderers || {}).length > 0;
-    if (hasCliPrograms || hasCliRenderers) {
-        filteredState.cli.files = new Set(state.cli.files);
-    }
+    filteredState.cli.files = repopulateFileSetFromMeta(filteredState.cli.meta, state.cli.files, hasCliPrograms || hasCliRenderers);
     // 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.
@@ -527,7 +642,7 @@ export function filterInspectorState(state, filters, logger) {
             name: funcId,
             tags: funcMeta.tags,
             filePath,
-        }, logger);
+        }, logger, undefined, keptByDeploy);
         if (matches) {
             filteredState.serviceAggregation.usedFunctions.add(funcId);
         }
@@ -584,12 +699,18 @@ export function filterInspectorState(state, filters, logger) {
                 delete filteredState.channels.meta[name];
             }
         }
-        // Prune workflow graphs whose function was filtered out
+        // Prune workflow graphs whose function was filtered out — UNLESS the
+        // workflow's own name is in the filter (covers pikkuWorkflowGraph,
+        // which doesn't register a function meta, so its pikkuFuncId never
+        // ends up in usedFunctions even when callers explicitly want it).
+        const filterNamesSet = new Set(filters.names ?? []);
         const workflowKeys = new Set([
             ...Object.keys(filteredState.workflows.graphMeta),
             ...Object.keys(filteredState.workflows.meta),
         ]);
         for (const name of workflowKeys) {
+            if (filterNamesSet.has(name))
+                continue;
             const graphMeta = filteredState.workflows.graphMeta[name];
             const workflowMeta = filteredState.workflows.meta[name];
             // Check both graphMeta.pikkuFuncId and meta.pikkuFuncId
@@ -661,6 +782,13 @@ export function filterInspectorState(state, filters, logger) {
             }
         }
     }
+    // workflowService internally calls queueService (via queueStepWorker /
+    // queueOrchestrator). Any unit that needs workflowService also needs
+    // queueService for the transitive enqueue calls — covers
+    // workflow-starter, graph-starter, workflow-runner, etc.
+    if (filteredState.serviceAggregation.requiredServices.has('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;

package/dist/utils/filter-utils.js

@@ -40,16 +40,24 @@ export const matchesFilters = (filters, params, meta, logger) => {
     // If all filter arrays are empty, allow everything
     if ((!filters.names || filters.names.length === 0) &&
         (!filters.tags || filters.tags.length === 0) &&
-        (!filters.types || filters.types.length === 0) &&
+        (!filters.wires || filters.wires.length === 0) &&
+        (!filters.excludeWires || filters.excludeWires.length === 0) &&
         (!filters.directories || filters.directories.length === 0) &&
         (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
         (!filters.httpMethods || filters.httpMethods.length === 0)) {
         return true;
     }
-    // Check type filter
-    if (filters.types && filters.types.length > 0) {
-        if (!filters.types.includes(meta.type)) {
-            logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`);
+    // Check wire include filter
+    if (filters.wires && filters.wires.length > 0) {
+        if (!filters.wires.includes(meta.type)) {
+            logger.debug(`⒡ Filtered by wire include: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check wire exclude filter
+    if (filters.excludeWires && filters.excludeWires.length > 0) {
+        if (filters.excludeWires.includes(meta.type)) {
+            logger.debug(`⒡ Filtered by wire exclude: ${meta.type}:${meta.name}`);
             return false;
         }
     }

package/dist/utils/get-property-value.d.ts

@@ -4,6 +4,16 @@ import { ErrorCode } from '../error-codes.js';
  * Extracts an array of strings from an object property.
  */
 export declare const getArrayPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string[] | null;
+/**
+ * Wiring identity fields (`name`, `secretId`, `variableId`, …) are read
+ * STATICALLY from source — a const or variable reference is keyed by its
+ * identifier text, not its runtime value, so the wiring is silently skipped at
+ * runtime (`metadata not found`). If the named property exists but is not an
+ * inline literal, raise a fatal diagnostic so the build fails instead.
+ */
+export declare const assertStringLiteralProperty: (obj: ts.ObjectLiteralExpression, propertyName: string, wiringType: string, logger?: {
+    critical: (code: ErrorCode, message: string) => void;
+}) => void;
 export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | number | null | boolean;
 /**
  * Extracts common wire metadata (title, tags, summary, description, errors) directly from an object

package/dist/utils/get-property-value.js

@@ -17,6 +17,35 @@ export const getArrayPropertyValue = (obj, propertyName) => {
     }
     return null;
 };
+/**
+ * Wiring identity fields (`name`, `secretId`, `variableId`, …) are read
+ * STATICALLY from source — a const or variable reference is keyed by its
+ * identifier text, not its runtime value, so the wiring is silently skipped at
+ * runtime (`metadata not found`). If the named property exists but is not an
+ * inline literal, raise a fatal diagnostic so the build fails instead.
+ */
+export const assertStringLiteralProperty = (obj, propertyName, wiringType, logger) => {
+    const property = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === propertyName);
+    if (!property || !ts.isPropertyAssignment(property)) {
+        return;
+    }
+    const init = property.initializer;
+    const isStaticLiteral = ts.isStringLiteral(init) ||
+        ts.isNoSubstitutionTemplateLiteral(init) ||
+        ts.isNumericLiteral(init);
+    if (isStaticLiteral) {
+        return;
+    }
+    const errorMsg = `${wiringType} has a non-literal '${propertyName}': \`${init.getText()}\`. Wiring identity fields must be inline string literals — the inspector reads them statically from source, so a const or variable reference is keyed by its identifier text and the wiring is silently skipped at runtime. Inline the literal instead, e.g. ${propertyName}: 'my-wiring-name'.`;
+    if (logger) {
+        logger.critical(ErrorCode.NON_LITERAL_WIRE_NAME, errorMsg);
+    }
+    else {
+        console.error(errorMsg);
+    }
+};
 export const getPropertyValue = (obj, propertyName) => {
     const property = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
         ts.isIdentifier(p.name) &&
@@ -67,6 +96,7 @@ export const getPropertyValue = (obj, propertyName) => {
  */
 export const getCommonWireMetaData = (obj, wiringType, wiringName, logger) => {
     const metadata = {};
+    assertStringLiteralProperty(obj, 'name', wiringType, logger);
     obj.properties.forEach((prop) => {
         if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
             const propName = prop.name.text;

package/dist/utils/post-process.d.ts

@@ -1,4 +1,4 @@
-import type { InspectorState, InspectorLogger, InspectorOptions, InspectorModelConfig } from '../types.js';
+import type { InspectorState, InspectorLogger, InspectorOptions } from '../types.js';
 import type { MiddlewareMetadata, PermissionMetadata } from '@pikku/core';
 /**
  * Helper to extract wire-level middleware/permission names from metadata.
@@ -21,8 +21,7 @@ export declare function computeResolvedIOTypes(state: InspectorState): void;
 export declare function computeMiddlewareGroupsMeta(state: InspectorState): void;
 export declare function computePermissionsGroupsMeta(state: InspectorState): void;
 export declare function computeRequiredSchemas(state: InspectorState, options: InspectorOptions): void;
-export declare function validateAgentModels(logger: InspectorLogger, state: InspectorState | Omit<InspectorState, 'typesLookup'>, modelConfig?: InspectorModelConfig): void;
-export declare function validateAgentOverrides(logger: InspectorLogger, state: InspectorState | Omit<InspectorState, 'typesLookup'>, modelConfig?: InspectorModelConfig): void;
+export declare function validateAgentModels(logger: InspectorLogger, state: InspectorState | Omit<InspectorState, 'typesLookup'>): void;
 /**
  * Validates that Zod schemas and wiring side-effects (wireHTTPRoutes,
  * addPermission, addHTTPMiddleware, etc.) do not coexist in the same file.

package/dist/utils/post-process.js

@@ -425,35 +425,15 @@ export function computeRequiredSchemas(state, options) {
         ...Array.from(schemaLookup.keys()),
     ]);
 }
-export function validateAgentModels(logger, state, modelConfig) {
-    const aliases = modelConfig?.models ?? {};
+export function validateAgentModels(logger, state) {
     for (const [, meta] of Object.entries(state.agents.agentsMeta)) {
         const model = meta.model;
         if (!model) {
             logger.critical(ErrorCode.MISSING_MODEL, `AI agent '${meta.name}' is missing the 'model' property.`);
             continue;
         }
-        if (model.includes('/'))
-            continue;
-        if (!aliases[model]) {
-            const available = Object.keys(aliases);
-            logger.critical(ErrorCode.INVALID_MODEL, `AI agent '${meta.name}' uses model alias '${model}' which is not defined in pikku.config.json models. ` +
-                `Available aliases: ${available.join(', ') || 'none'}`);
-        }
-    }
-}
-export function validateAgentOverrides(logger, state, modelConfig) {
-    const overrides = modelConfig?.agentOverrides ?? {};
-    const aliases = modelConfig?.models ?? {};
-    const agentNames = new Set(Object.values(state.agents.agentsMeta).map((m) => m.name));
-    for (const [agentName, override] of Object.entries(overrides)) {
-        if (!agentNames.has(agentName)) {
-            logger.warn(`agentOverrides references unknown agent '${agentName}'`);
-        }
-        if (override.model &&
-            !override.model.includes('/') &&
-            !aliases[override.model]) {
-            logger.critical(ErrorCode.INVALID_MODEL, `agentOverrides['${agentName}'].model uses alias '${override.model}' which is not defined in models.`);
+        if (!model.includes('/')) {
+            logger.critical(ErrorCode.INVALID_MODEL, `AI agent '${meta.name}' uses model '${model}', which must be provider-qualified as '<provider>/<model>' (e.g. 'openai/gpt-4').`);
         }
     }
 }

package/dist/utils/resolve-addon-package.d.ts

@@ -2,11 +2,10 @@ import * as ts from 'typescript';
 /**
  * Resolve the addon package name from an imported identifier.
  * Checks if the identifier's import module specifier matches any
- * configured addon package.
- *
- * This is a general utility — any wire handler that processes a `func`
- * property can use it to detect when the function comes from an
- * addon package.
+ * configured addon package — and if the import is relative (because
+ * the identifier resolves to a source file inside the addon package
+ * itself), walks up to the nearest package.json to obtain the real
+ * package name.
  */
 export declare const resolveAddonName: (identifier: ts.Identifier, checker: ts.TypeChecker, wireAddonDeclarations?: Map<string, {
     package: string;