@pikku/cli 0.12.156 → 0.12.159

package/dist/src/fabric/fabric-commands.js

@@ -116,6 +116,9 @@ export const fabricCommands = defineCLICommands({
                 description: 'Override the project display name (defaults to repo name)',
             },
             branch: { description: 'Default branch (defaults to main)' },
+            organization: {
+                description: 'Organization to import into — slug, name or id (defaults to the one your session is in)',
+            },
             force: {
                 description: 'Replace existing fabric.config.json',
                 default: false,
@@ -138,6 +141,9 @@ export const fabricCommands = defineCLICommands({
             repoName: {
                 description: 'Name for a repo created by --gitea (defaults to the directory name)',
             },
+            organization: {
+                description: 'Organization to import into — slug, name or id (defaults to the one your session is in)',
+            },
             apiUrl: {
                 description: 'Override the fabric-api URL stored in fabric.config.json',
             },
@@ -591,9 +597,13 @@ export const fabricCommands = defineCLICommands({
                 options: {
                     changeId: { description: 'The item the question is about' },
                     question: {
-                        description: 'One decision, in the filer’s vocabulary, with the options named',
+                        description: 'One decision, in the filer’s vocabulary. Name the choices with --option, not as “(a) … (b) …” inside this text',
                         short: 'q',
                     },
+                    option: {
+                        description: 'A choice the filer can click, repeatable — e.g. --option "Reprice them" --option "Leave them". Without these they have to type an answer',
+                        type: 'string[]',
+                    },
                     authorName: { description: 'Who is asking, e.g. claude-code' },
                     apiUrl: { description: 'Override the fabric-api URL for this call' },
                 },

package/dist/src/fabric/functions/changes-ask.function.d.ts

@@ -4,6 +4,7 @@ export declare const FabricChangesAskInput: z.ZodObject<{
     apiUrl: z.ZodOptional<z.ZodString>;
     changeId: z.ZodString;
     question: z.ZodString;
+    option: z.ZodOptional<z.ZodArray<z.ZodString>>;
     authorName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const FabricChangesAskOutput: z.ZodObject<{
@@ -13,6 +14,7 @@ export declare const FabricChangesAsk: import("../../../.pikku/function/pikku-fu
     apiUrl?: string | undefined;
     changeId: string;
     question: string;
+    option?: string[] | undefined;
     authorName?: string | undefined;
 }, {
     message: any;
@@ -20,6 +22,7 @@ export declare const FabricChangesAsk: import("../../../.pikku/function/pikku-fu
     apiUrl?: string | undefined;
     changeId: string;
     question: string;
+    option?: string[] | undefined;
     authorName?: string | undefined;
 }, {
     message: any;
@@ -27,6 +30,7 @@ export declare const FabricChangesAsk: import("../../../.pikku/function/pikku-fu
     apiUrl?: string | undefined;
     changeId: string;
     question: string;
+    option?: string[] | undefined;
     authorName?: string | undefined;
 }, {
     message: any;

package/dist/src/fabric/functions/changes-ask.function.js

@@ -1,11 +1,12 @@
 import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { changesContext } from '../lib/changes.js';
-import { dim, safeBlock } from '../lib/output.js';
+import { dim, safe, safeBlock } from '../lib/output.js';
 export const FabricChangesAskInput = z.object({
     apiUrl: z.string().optional(),
     changeId: z.string(),
     question: z.string().trim().min(1, 'Ask something — the question is empty.'),
+    option: z.array(z.string().trim().min(1)).max(6).optional(),
     authorName: z.string().optional(),
 });
 export const FabricChangesAskOutput = z.object({
@@ -21,10 +22,15 @@ export const FabricChangesAsk = pikkuSessionlessFunc({
             changeId: input.changeId,
             question: input.question,
             authorName: input.authorName ?? 'pikku-cli',
+            ...(input.option?.length ? { option: input.option } : {}),
         });
     },
 });
 export const renderChangesAsk = (_s, { message }) => {
+    const options = (message.attachments ?? []).filter((attachment) => attachment.kind === 'option');
     console.log('Asked — the item now shows as needing an answer in the panel.');
     console.log(dim(`  ${safeBlock(message.body)}`));
+    if (options.length) {
+        console.log(dim(`  they can click: ${options.map(({ label }) => safe(label)).join(' · ')}`));
+    }
 };

package/dist/src/fabric/functions/init.function.d.ts

@@ -5,6 +5,7 @@ export declare const FabricInitInput: z.ZodObject<{
     branch: z.ZodOptional<z.ZodString>;
     force: z.ZodOptional<z.ZodBoolean>;
     apiUrl: z.ZodOptional<z.ZodString>;
+    organization: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const FabricInitOutput: z.ZodObject<{
     projectId: z.ZodString;
@@ -24,6 +25,7 @@ export declare const FabricInit: import("../../../.pikku/function/pikku-function
     branch?: string | undefined;
     force?: boolean | undefined;
     apiUrl?: string | undefined;
+    organization?: string | undefined;
 }, {
     projectId: string;
     projectSlug: string;
@@ -34,6 +36,7 @@ export declare const FabricInit: import("../../../.pikku/function/pikku-function
     branch?: string | undefined;
     force?: boolean | undefined;
     apiUrl?: string | undefined;
+    organization?: string | undefined;
 }, {
     projectId: string;
     projectSlug: string;
@@ -44,6 +47,7 @@ export declare const FabricInit: import("../../../.pikku/function/pikku-function
     branch?: string | undefined;
     force?: boolean | undefined;
     apiUrl?: string | undefined;
+    organization?: string | undefined;
 }, {
     projectId: string;
     projectSlug: string;

package/dist/src/fabric/functions/init.function.js

@@ -3,12 +3,14 @@ import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { findProjectConfig, isLinkedProjectId, resolveApiContext, writeProjectConfig, } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
 import { FabricPreconditionError } from '../lib/errors.js';
+import { resolveOrganizationId } from '../lib/organization.js';
 export const FabricInitInput = z.object({
     repo: z.string(),
     name: z.string().optional(),
     branch: z.string().optional(),
     force: z.boolean().optional(),
     apiUrl: z.string().optional(),
+    organization: z.string().optional(),
 });
 export const FabricInitOutput = z.object({
     projectId: z.string(),
@@ -26,7 +28,7 @@ export const FabricInit = pikkuSessionlessFunc({
     description: 'Adopt an existing repo as a fabric project (writes fabric.config.json).',
     input: FabricInitInput,
     output: FabricInitOutput,
-    func: async (_services, { repo, name, branch, force, apiUrl: apiUrlOverride }) => {
+    func: async (_services, { repo, name, branch, force, apiUrl: apiUrlOverride, organization }) => {
         const ctx = await resolveApiContext({ apiUrlOverride });
         if (!ctx.token)
             throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
@@ -35,11 +37,13 @@ export const FabricInit = pikkuSessionlessFunc({
             throw new FabricPreconditionError(`Already linked: ${existing.config.projectId} at ${existing.path}. Pass --force to replace.`);
         }
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const organizationId = await resolveOrganizationId(rpc, organization);
         const result = await rpc.invoke('importProject', {
             repoUrl: repo,
             name,
             defaultBranch: branch,
             productionBranch: 'main',
+            ...(organizationId ? { organizationId } : {}),
         });
         const path = await writeProjectConfig(process.cwd(), {
             projectId: result.projectId,

package/dist/src/fabric/functions/link.function.d.ts

@@ -4,6 +4,7 @@ export declare const FabricLinkInput: z.ZodObject<{
     github: z.ZodOptional<z.ZodBoolean>;
     gitea: z.ZodOptional<z.ZodBoolean>;
     repoName: z.ZodOptional<z.ZodString>;
+    organization: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const FabricLinkOutput: z.ZodObject<{
     projectId: z.ZodString;
@@ -16,6 +17,7 @@ export declare const FabricLink: import("../../../.pikku/function/pikku-function
     github?: boolean | undefined;
     gitea?: boolean | undefined;
     repoName?: string | undefined;
+    organization?: string | undefined;
 }, {
     projectId: string;
     projectSlug: string;
@@ -26,6 +28,7 @@ export declare const FabricLink: import("../../../.pikku/function/pikku-function
     github?: boolean | undefined;
     gitea?: boolean | undefined;
     repoName?: string | undefined;
+    organization?: string | undefined;
 }, {
     projectId: string;
     projectSlug: string;
@@ -36,6 +39,7 @@ export declare const FabricLink: import("../../../.pikku/function/pikku-function
     github?: boolean | undefined;
     gitea?: boolean | undefined;
     repoName?: string | undefined;
+    organization?: string | undefined;
 }, {
     projectId: string;
     projectSlug: string;

package/dist/src/fabric/functions/link.function.js

@@ -5,6 +5,7 @@ import { resolveApiContext, writeProjectConfig } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
 import { addRemote, assertDeploySafety, currentBranch, getRemoteUrl, hasCommits, hasRemote, isWorkingTreeClean, pushWithCredential, removeRemote, } from '../lib/git.js';
 import { FabricPreconditionError } from '../lib/errors.js';
+import { resolveOrganizationId } from '../lib/organization.js';
 import { promptConfirm } from '../lib/prompt.js';
 export const FabricLinkInput = z.object({
     apiUrl: z.string().optional(),
@@ -14,6 +15,8 @@ export const FabricLinkInput = z.object({
     gitea: z.boolean().optional(),
     /** Name for a repo created here. Defaults to the directory name. */
     repoName: z.string().optional(),
+    /** Slug, name or id of the organization to import into. Defaults to the session's. */
+    organization: z.string().optional(),
 });
 export const FabricLinkOutput = z.object({
     projectId: z.string(),
@@ -29,7 +32,7 @@ export const FabricLink = pikkuSessionlessFunc({
     description: 'Register the current git repo as a fabric project and queue an initial deploy.',
     input: FabricLinkInput,
     output: FabricLinkOutput,
-    func: async (_services, { apiUrl: apiUrlOverride, github, gitea, repoName }) => {
+    func: async (_services, { apiUrl: apiUrlOverride, github, gitea, repoName, organization }) => {
         const ctx = await resolveApiContext({ apiUrlOverride });
         if (!ctx.token) {
             throw new FabricPreconditionError('Not logged in. Run `pikku fabric login` first.');
@@ -48,6 +51,10 @@ export const FabricLink = pikkuSessionlessFunc({
         if (!(await isWorkingTreeClean())) {
             throw new FabricPreconditionError('Deployment blocked: uncommitted changes detected.\nCommit and push your changes before deploying.');
         }
+        // Resolved here for the same reason, since `--gitea` reaches `createRemote`
+        // below: a misspelt organization must not cost the user a repository they
+        // then have to go and delete.
+        const organizationId = await resolveOrganizationId(rpc, organization);
         const remoteUrl = (await hasRemote())
             ? await adoptExistingRemote({ github, gitea })
             : await createRemote({ rpc, github, gitea, repoName });
@@ -85,6 +92,7 @@ export const FabricLink = pikkuSessionlessFunc({
         const project = await rpc.invoke('importProject', {
             repoUrl: remoteUrl,
             productionBranch: 'main',
+            ...(organizationId ? { organizationId } : {}),
         });
         await writeProjectConfig(process.cwd(), {
             projectId: project.projectId,

package/dist/src/fabric/lib/organization.d.ts

@@ -0,0 +1,8 @@
+import type { getFabricRPC } from './http.js';
+/**
+ * Turn `--organization` into an id. Fabric derives the owning org from the
+ * session when the flag is absent, which silently imports into whichever org
+ * the token happens to be scoped to — the flag is how a repo belonging to a
+ * different org gets linked without re-logging-in.
+ */
+export declare function resolveOrganizationId(rpc: ReturnType<typeof getFabricRPC>, organization: string | undefined): Promise<string | undefined>;

package/dist/src/fabric/lib/organization.js

@@ -0,0 +1,26 @@
+import { FabricPreconditionError } from './errors.js';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Turn `--organization` into an id. Fabric derives the owning org from the
+ * session when the flag is absent, which silently imports into whichever org
+ * the token happens to be scoped to — the flag is how a repo belonging to a
+ * different org gets linked without re-logging-in.
+ */
+export async function resolveOrganizationId(rpc, organization) {
+    if (!organization)
+        return undefined;
+    if (UUID.test(organization))
+        return organization;
+    const { organizations } = await rpc.invoke('listMyOrganizations', {});
+    const wanted = organization.toLowerCase();
+    const matches = organizations.filter((org) => org.slug.toLowerCase() === wanted || org.name.toLowerCase() === wanted);
+    if (matches.length === 0) {
+        const known = organizations.map((org) => org.slug).join(', ');
+        throw new FabricPreconditionError(`No organization named "${organization}".\nYou belong to: ${known || '(none)'}`);
+    }
+    if (matches.length > 1) {
+        const ids = matches.map((org) => org.organizationId).join(', ');
+        throw new FabricPreconditionError(`"${organization}" matches more than one organization. Pass the id instead: ${ids}`);
+    }
+    return matches[0].organizationId;
+}

package/dist/src/functions/commands/deploy-apply.js

@@ -5,17 +5,18 @@ import { readFile } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
 import { pikkuSessionlessFunc } from '#pikku/function';
 import { runBuildPipeline, describeBuildFailure, PikkuDeployBuildFailedError, } from '../../deploy/build-pipeline.js';
+// A bundler reads anything not starting with `./` or `../` as a bare package
+// specifier, and a path into a dot-directory (`.pikku/...`) starts with a dot
+// without being relative — so testing for `.` alone silently emits an import
+// no bundler can resolve.
 function toRelativeImport(fromDir, toFile) {
     let rel = relative(fromDir, toFile).replace(/\\/g, '/');
-    if (!rel.startsWith('.'))
+    if (!rel.startsWith('./') && !rel.startsWith('../'))
         rel = `./${rel}`;
     return rel.replace(/\.ts$/, '.js');
 }
 export function getEntryContext(unitDir, pikkuDir, unit, inspectorState) {
-    const bootstrapRelative = relative(unitDir, join(pikkuDir, 'pikku-bootstrap.gen.js'));
-    const bootstrapPath = bootstrapRelative.startsWith('./') || bootstrapRelative.startsWith('../')
-        ? bootstrapRelative
-        : `./${bootstrapRelative}`;
+    const bootstrapPath = toRelativeImport(unitDir, join(pikkuDir, 'pikku-bootstrap.gen.js'));
     const { pikkuConfigFactory, singletonServicesFactory, singletonServicesType, } = inspectorState.filesAndMethods;
     if (!pikkuConfigFactory || !singletonServicesFactory) {
         throw new Error('Cannot generate deploy entries: createConfig and createSingletonServices must be defined in your project');
@@ -28,14 +29,22 @@ export function getEntryContext(unitDir, pikkuDir, unit, inspectorState) {
     const servicesType = singletonServicesType
         ? `Partial<${singletonServicesType.type}>`
         : 'Record<string, unknown>';
-    // MCP: when the unit's .pikku has a non-empty mcp.gen.json, import it and pass
-    // it to the generated server so PikkuNodeHTTPServer mounts /mcp. Without this
-    // the deployed bundle never serves MCP even though the dev server does.
+    // MCP: when the unit's surface manifest is non-empty, import it and pass it
+    // to the generated server so it mounts the surface. Without this the deployed
+    // bundle never serves MCP even though the dev server does.
+    //
+    // An `mcp` unit serves exactly the one surface it was emitted for — its name
+    // carries that surface's slug, which is also the manifest's filename. Any
+    // other unit (a monolith, say) serves the default surface, as before.
     let mcpImport = '';
     let mcpServerOption = '';
-    const mcpJsonAbs = join(pikkuDir, 'mcp', 'mcp.gen.json');
+    const mcpSlug = unit.role === 'mcp' && unit.name !== 'mcp-server'
+        ? unit.name.replace(/^mcp-/, '')
+        : undefined;
+    const mcpJsonAbs = join(pikkuDir, 'mcp', mcpSlug ? `mcp.${mcpSlug}.gen.json` : 'mcp.gen.json');
     if (existsSync(mcpJsonAbs)) {
         let hasMcp = false;
+        let mcpPath = '/mcp';
         try {
             const parsed = JSON.parse(readFileSync(mcpJsonAbs, 'utf-8'));
             hasMcp =
@@ -43,15 +52,18 @@ export function getEntryContext(unitDir, pikkuDir, unit, inspectorState) {
                     (parsed.resources?.length ?? 0) +
                     (parsed.prompts?.length ?? 0) >
                     0;
+            mcpPath = parsed.mcpPath ?? mcpPath;
         }
         catch (err) {
             console.warn(`[pikku] could not parse ${mcpJsonAbs} — skipping MCP mount: ${err instanceof Error ? err.message : String(err)}`);
         }
         if (hasMcp) {
-            const rel = relative(unitDir, mcpJsonAbs).replace(/\\/g, '/');
-            const relImport = rel.startsWith('.') ? rel : `./${rel}`;
+            const relImport = toRelativeImport(unitDir, mcpJsonAbs);
             mcpImport = `import mcpJson from '${relImport}' with { type: 'json' }`;
-            mcpServerOption = 'mcpJson, ';
+            mcpServerOption =
+                mcpPath === '/mcp'
+                    ? 'mcpJson, '
+                    : `mcpJson, mcpPath: ${JSON.stringify(mcpPath)}, `;
         }
     }
     return {
@@ -103,7 +115,105 @@ async function resolveProjectId(projectDir) {
  * configured provider may also be a URL, and a runtime whose `require.resolve`
  * hands a bare specifier straight back for its own built-ins has resolved
  * nothing. Both of those import as written.
+ *
+ * `require.resolve` applies the `require` condition, so an ESM-only provider —
+ * one whose exports map offers `types` and `import` and nothing else, which is
+ * a perfectly ordinary way to publish — does not resolve there even though it
+ * is installed and importable. Falling through to the bare import does not
+ * rescue it, because that resolves from the CLI rather than the project, so
+ * `resolveEsmOnlyEntry` reads the package's own entry instead. It has to walk
+ * the resolution paths by hand: the exports map that blocked the package also
+ * blocks `<name>/package.json`.
+ *
+ * Which is why it runs on any resolution failure rather than on one code. Node
+ * reports this as ERR_PACKAGE_PATH_NOT_EXPORTED and bun as a plain
+ * MODULE_NOT_FOUND, indistinguishable from a package that is genuinely absent.
+ * Telling them apart is what the filesystem is for: a package that is not there
+ * yields no entry and the bare import still runs, unchanged.
+ */
+/**
+ * The conditions that are true for the `import()` this resolution ends in.
+ * `default` matches unconditionally and is handled by the resolver rather than
+ * listed here, because node treats it as the fallthrough rather than as a name.
+ */
+const ACTIVE_EXPORT_CONDITIONS = new Set(['node', 'import']);
+/**
+ * Picks an export target the way node does: a conditions object is walked in
+ * DECLARATION order and the first key that is active wins, nesting included.
+ *
+ * The order is the package author's, not ours. `{ "import": { "node": "./n.js",
+ * "default": "./browser.js" } }` resolves to `./n.js`, because `node` is listed
+ * first and is true here — preferring a fixed list of condition names instead
+ * would hand back the browser build and load a different provider than the one
+ * node would have.
+ *
+ * An array is a list of fallbacks, and `null` is a deliberate block, so both
+ * carry on to the next candidate rather than ending the walk.
  */
+const resolveExportTarget = (target) => {
+    if (typeof target === 'string')
+        return target;
+    if (target === null || target === undefined)
+        return undefined;
+    if (Array.isArray(target)) {
+        for (const candidate of target) {
+            const resolved = resolveExportTarget(candidate);
+            if (resolved !== undefined)
+                return resolved;
+        }
+        return undefined;
+    }
+    if (typeof target !== 'object')
+        return undefined;
+    for (const [condition, value] of Object.entries(target)) {
+        if (condition !== 'default' && !ACTIVE_EXPORT_CONDITIONS.has(condition)) {
+            continue;
+        }
+        const resolved = resolveExportTarget(value);
+        if (resolved !== undefined)
+            return resolved;
+    }
+    return undefined;
+};
+/**
+ * The entry an exports map offers to `import`, or, for a package with no
+ * exports map at all, its legacy main. A map that deliberately omits a root
+ * entry offers nothing: falling back to `main` there would reach past the
+ * encapsulation the package asked for, so this reports no entry and the caller
+ * treats the provider as missing.
+ */
+const esmEntryFromManifest = (manifest) => {
+    const exportsField = manifest.exports;
+    if (exportsField === undefined || exportsField === null) {
+        const legacy = manifest.module ?? manifest.main;
+        return typeof legacy === 'string' ? legacy : undefined;
+    }
+    const isSubpathMap = typeof exportsField === 'object' &&
+        !Array.isArray(exportsField) &&
+        Object.keys(exportsField).some((key) => key.startsWith('.'));
+    const root = isSubpathMap ? exportsField['.'] : exportsField;
+    return resolveExportTarget(root);
+};
+const resolveEsmOnlyEntry = (require, packageName) => {
+    const searchPaths = require.resolve.paths(packageName) ?? [];
+    for (const searchPath of searchPaths) {
+        const packageJsonPath = join(searchPath, packageName, 'package.json');
+        if (!existsSync(packageJsonPath))
+            continue;
+        let manifest;
+        try {
+            manifest = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        }
+        catch {
+            return undefined;
+        }
+        const entry = esmEntryFromManifest(manifest);
+        if (!entry)
+            return undefined;
+        return join(searchPath, packageName, entry);
+    }
+    return undefined;
+};
 const importProviderPackage = async (packageName, projectDir) => {
     const require = createRequire(join(projectDir ?? process.cwd(), 'package.json'));
     try {
@@ -115,9 +225,14 @@ const importProviderPackage = async (packageName, projectDir) => {
     catch (e) {
         const err = e;
         if (err?.code !== 'ERR_MODULE_NOT_FOUND' &&
-            err?.code !== 'MODULE_NOT_FOUND') {
+            err?.code !== 'MODULE_NOT_FOUND' &&
+            err?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
             throw e;
         }
+        const entry = resolveEsmOnlyEntry(require, packageName);
+        if (entry && existsSync(entry)) {
+            return await import(pathToFileURL(entry).href);
+        }
     }
     return await import(packageName);
 };

package/dist/src/functions/commands/dev-mcp-manifests.d.ts

@@ -0,0 +1,27 @@
+export type McpManifest = {
+    mcpPath?: string;
+    tools?: unknown[];
+    resources?: unknown[];
+    prompts?: unknown[];
+};
+export type McpSurfaceMount = {
+    mcpJson: McpManifest;
+    mcpPath: string;
+};
+/**
+ * Every MCP endpoint the generated tree describes: the default one, plus one
+ * per surface for a project that serves several connectors.
+ *
+ * Dev mounts all of them so a connector can be pointed at `pikku dev` and tried
+ * before it is deployed. Without the surfaces, a project that moved its tools
+ * onto their own endpoints would serve nothing locally at all — the default
+ * manifest it does read is empty precisely because they moved.
+ *
+ * A surface manifest without an `mcpPath` is skipped rather than guessed at: the
+ * path is what the deployed unit is routed on, and a mount at a different path
+ * would make dev disagree with production.
+ */
+export declare const readMcpManifests: (pikkuDir: string, onWarning: (message: string) => void) => {
+    mcpJson?: McpManifest;
+    mcpSurfaces: McpSurfaceMount[];
+};

package/dist/src/functions/commands/dev-mcp-manifests.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'path';
+/**
+ * A manifest with nothing in it reads as "no MCP here": the transports mount
+ * only when there is something to serve, so an empty one would announce an
+ * endpoint that answers every call with a missing tool.
+ *
+ * Absent or unparseable is not an error either — an app with no MCP wirings
+ * has no manifest, and that is the common case.
+ */
+const readMcpManifest = (file, onWarning) => {
+    if (!existsSync(file))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf-8'));
+        const count = (parsed.tools?.length ?? 0) +
+            (parsed.resources?.length ?? 0) +
+            (parsed.prompts?.length ?? 0);
+        return count > 0 ? parsed : undefined;
+    }
+    catch (err) {
+        onWarning(`[pikku] could not parse ${file} — MCP will not be served: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
+};
+/**
+ * Every MCP endpoint the generated tree describes: the default one, plus one
+ * per surface for a project that serves several connectors.
+ *
+ * Dev mounts all of them so a connector can be pointed at `pikku dev` and tried
+ * before it is deployed. Without the surfaces, a project that moved its tools
+ * onto their own endpoints would serve nothing locally at all — the default
+ * manifest it does read is empty precisely because they moved.
+ *
+ * A surface manifest without an `mcpPath` is skipped rather than guessed at: the
+ * path is what the deployed unit is routed on, and a mount at a different path
+ * would make dev disagree with production.
+ */
+export const readMcpManifests = (pikkuDir, onWarning) => {
+    const mcpDir = join(pikkuDir, 'mcp');
+    const mcpJson = readMcpManifest(join(mcpDir, 'mcp.gen.json'), onWarning);
+    const mcpSurfaces = (existsSync(mcpDir) ? readdirSync(mcpDir) : [])
+        .filter((name) => /^mcp\..+\.gen\.json$/.test(name))
+        .sort()
+        .flatMap((name) => {
+        const parsed = readMcpManifest(join(mcpDir, name), onWarning);
+        if (!parsed?.mcpPath)
+            return [];
+        return [{ mcpJson: parsed, mcpPath: parsed.mcpPath }];
+    });
+    return { mcpJson, mcpSurfaces };
+};

package/dist/src/functions/commands/dev.js

@@ -1,5 +1,5 @@
 import { join, resolve } from 'path';
-import { existsSync, readFileSync } from 'node:fs';
+import { readMcpManifests } from './dev-mcp-manifests.js';
 import { pikkuSessionlessFunc } from '#pikku/function';
 import chokidar from 'chokidar';
 import { pikkuDevReloader, reloadGeneratedMeta, reconcileAddonRegistry, } from '@pikku/core/dev';
@@ -308,45 +308,25 @@ export const dev = pikkuSessionlessFunc({
             ...(consoleMount ? [consoleMount] : []),
         ];
         /**
-         * Hand the server the generated MCP manifest so it actually serves MCP.
+         * Hand the server the generated MCP manifests so it actually serves MCP.
          *
          * Codegen reports "N MCP endpoints" and both transports mount them at
-         * `mcpPath` — but only when given `mcpJson`, and dev never passed it.
+         * `mcpPath` — but only when given the manifest, and dev never passed it.
          *
-         * It goes in the runner *options*, not in the config: the transport reads it
-         * off its third argument, and the runners forward a hand-picked list of
-         * fields. Putting it in `config` type-checks and is discarded in silence.
-         * So every pikku app announced an MCP surface at startup and served a 404,
-         * and the only way to exercise a tool was to deploy. `deploy-apply` even
-         * carries a comment saying the deployed bundle should match "the dev server"
-         * — which had never served it either.
-         *
-         * Absent or unparseable is not an error: an app with no MCP wirings has no
-         * manifest, and that is the common case.
+         * They go in the runner *options*, not in the config: the transport reads
+         * them off its third argument, and the runners forward a hand-picked list
+         * of fields. Putting them in `config` type-checks and is discarded in
+         * silence. So every pikku app announced an MCP surface at startup and
+         * served a 404, and the only way to exercise a tool was to deploy.
          */
-        const mcpJson = await (async () => {
-            const file = join(pikkuDir, 'mcp', 'mcp.gen.json');
-            if (!existsSync(file))
-                return undefined;
-            try {
-                const parsed = JSON.parse(readFileSync(file, 'utf-8'));
-                const count = (parsed.tools?.length ?? 0) +
-                    (parsed.resources?.length ?? 0) +
-                    (parsed.prompts?.length ?? 0);
-                return count > 0 ? parsed : undefined;
-            }
-            catch (err) {
-                logger.warn(`[pikku] could not parse ${file} — MCP will not be served: ${err instanceof Error ? err.message : String(err)}`);
-                return undefined;
-            }
-        })();
+        const { mcpJson, mcpSurfaces } = readMcpManifests(pikkuDir, (message) => logger.warn(message));
         const pikkuServer = devServerRunner.createServer({
             ...userConfig,
             hostname: bindHostname,
             port: resolvedPort,
             content: localContentConfig,
             ...(staticMounts.length > 0 ? { staticMounts } : {}),
-        }, logger, { contentSigningJWT, mcpJson });
+        }, logger, { contentSigningJWT, mcpJson, mcpSurfaces });
         const lifecycle = await loadLifecycle();
         await pikkuServer.init();
         await lifecycle?.beforeStart?.(resolvedServices);

package/dist/src/functions/commands/knowledge-reconcile.d.ts

@@ -1,5 +1,7 @@
 import { renderKnowledgeReconcile } from '../knowledge/render.js';
-export declare const knowledgeReconcile: import("#pikku/function").PikkuFunctionConfig<Record<string, never>, {
+export declare const knowledgeReconcile: import("#pikku/function").PikkuFunctionConfig<{
+    require?: string | undefined;
+}, {
     kind: "ask-user" | "dispatch" | "hold" | "idle" | "repair-note" | "write-plan";
     reason: string;
     note?: string | undefined;
@@ -13,7 +15,11 @@ export declare const knowledgeReconcile: import("#pikku/function").PikkuFunction
             description?: string | undefined;
         }[];
     } | undefined;
-}, "rpc" | "session", import("#pikku/function").PikkuFunction<Record<string, never>, {
+    satisfied?: boolean | undefined;
+    required?: string[] | undefined;
+}, "rpc" | "session", import("#pikku/function").PikkuFunction<{
+    require?: string | undefined;
+}, {
     kind: "ask-user" | "dispatch" | "hold" | "idle" | "repair-note" | "write-plan";
     reason: string;
     note?: string | undefined;
@@ -27,7 +33,11 @@ export declare const knowledgeReconcile: import("#pikku/function").PikkuFunction
             description?: string | undefined;
         }[];
     } | undefined;
-}, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<Record<string, never>, {
+    satisfied?: boolean | undefined;
+    required?: string[] | undefined;
+}, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<{
+    require?: string | undefined;
+}, {
     kind: "ask-user" | "dispatch" | "hold" | "idle" | "repair-note" | "write-plan";
     reason: string;
     note?: string | undefined;
@@ -41,5 +51,7 @@ export declare const knowledgeReconcile: import("#pikku/function").PikkuFunction
             description?: string | undefined;
         }[];
     } | undefined;
+    satisfied?: boolean | undefined;
+    required?: string[] | undefined;
 }, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
 export { renderKnowledgeReconcile };