@pikku/skills 0.12.9 → 0.12.10

package/skills/pikku-kysely/SKILL.md

@@ -28,25 +28,29 @@ Use this skill as an execution checklist, not reference material.
 
 ## Writing Queries — the Kysely query builder
 
-In a Pikku function body the injected `kysely` IS the `Kysely<DB>` instance — query it directly. Every connection factory below wires the **CamelCasePlugin** by default, so you write **camelCase everywhere in TS** (columns, aliases) and raw **snake_case ONLY inside a `` sql`` `` literal**. If a project opted out (`createNodeSqliteKysely({ camelCase: false })`), that inverts — check how the instance was built before assuming. Kysely is a query builder, NOT an ORM — there are no relations; shape nested data with the JSON helpers below. Never hand-roll SQL strings; never annotate the return type (in Pikku the output zod schema IS the type).
+In a Pikku function body the injected `kysely` IS the `Kysely<DB>` instance — query it directly. Every connection factory below wires the **CamelCasePlugin** by default, so you write **camelCase everywhere in TS** (columns, aliases) and raw **snake_case ONLY inside a ` sql` `` literal**. If a project opted out (`createNodeSqliteKysely({ camelCase: false })`), that inverts — check how the instance was built before assuming. Kysely is a query builder, NOT an ORM — there are no relations; shape nested data with the JSON helpers below. Never hand-roll SQL strings; never annotate the return type (in Pikku the output zod schema IS the type).
 
 ```typescript
 import { sql } from 'kysely'
 // Relation helpers are ENGINE-SPECIFIC — import the matching path:
-import { jsonArrayFrom, jsonObjectFrom } from 'kysely/helpers/sqlite'   // SQLite / libSQL
+import { jsonArrayFrom, jsonObjectFrom } from 'kysely/helpers/sqlite' // SQLite / libSQL
 // import { jsonArrayFrom, jsonObjectFrom } from 'kysely/helpers/postgres' // Postgres
 ```
 
 ```typescript
 // SELECT + where/orderBy/limit/offset. Terminals: .execute() | .executeTakeFirst()
 // | .executeTakeFirstOrThrow(() => new NotFoundError()) — pass an error factory.
-const rows = await kysely.selectFrom('item')
+const rows = await kysely
+  .selectFrom('item')
   .select(['id', 'name', 'quantity'])
   .where('warehouseId', '=', warehouseId)
-  .orderBy('name').limit(50).execute()
+  .orderBy('name')
+  .limit(50)
+  .execute()
 
 // JOINS + aliased selects (qualify columns once a join exists)
-await kysely.selectFrom('stock')
+await kysely
+  .selectFrom('stock')
   .innerJoin('item', 'item.id', 'stock.itemId')
   .leftJoin('bin as b', 'b.id', 'stock.binId')
   .select(['stock.id', 'item.name as itemName', 'b.code as binCode'])
@@ -54,41 +58,64 @@ await kysely.selectFrom('stock')
 
 // AGGREGATES via the fn helper + groupBy/having. eb.fn.count returns string|number —
 // cast if you need a JS number (SQLite: CAST(... AS INTEGER)).
-await kysely.selectFrom('stock')
+await kysely
+  .selectFrom('stock')
   .select((eb) => ['itemId', eb.fn.sum<number>('quantity').as('onHand')])
   .groupBy('itemId')
-  .having((eb) => eb.fn.sum('quantity'), '<', 10)   // low-stock
+  .having((eb) => eb.fn.sum('quantity'), '<', 10) // low-stock
   .execute()
 
 // INSERT + RETURNING (one round-trip; works on SQLite & Postgres)
-const created = await kysely.insertInto('item')
+const created = await kysely
+  .insertInto('item')
   .values({ name: input.name, warehouseId })
-  .returning(['id', 'name']).executeTakeFirstOrThrow()
+  .returning(['id', 'name'])
+  .executeTakeFirstOrThrow()
 
 // UPDATE + RETURNING, DELETE
-await kysely.updateTable('item').set({ quantity: input.quantity })
-  .where('id', '=', input.id).returning(['id', 'quantity']).executeTakeFirstOrThrow()
+await kysely
+  .updateTable('item')
+  .set({ quantity: input.quantity })
+  .where('id', '=', input.id)
+  .returning(['id', 'quantity'])
+  .executeTakeFirstOrThrow()
 await kysely.deleteFrom('item').where('id', '=', input.id).execute()
 
 // EXPRESSION BUILDER for and/or; $if for conditional building; sql for raw fragments
-await kysely.selectFrom('item')
+await kysely
+  .selectFrom('item')
   .selectAll()
   .where((eb) => eb.or([eb('quantity', '=', 0), eb('discontinued', '=', true)]))
   .$if(!!input.search, (qb) => qb.where('name', 'like', `%${input.search}%`))
-  .select(sql<number>`quantity * unit_cost`.as('value'))   // snake_case ok inside sql``
+  .select(sql<number>`quantity * unit_cost`.as('value')) // snake_case ok inside sql``
   .execute()
 
 // NESTED DATA (no relations) — jsonObjectFrom (one) / jsonArrayFrom (many)
-await kysely.selectFrom('warehouse')
-  .select((eb) => ['warehouse.id', 'warehouse.name',
-    jsonArrayFrom(eb.selectFrom('bin').select(['bin.id', 'bin.code'])
-      .whereRef('bin.warehouseId', '=', 'warehouse.id')).as('bins')])
+await kysely
+  .selectFrom('warehouse')
+  .select((eb) => [
+    'warehouse.id',
+    'warehouse.name',
+    jsonArrayFrom(
+      eb
+        .selectFrom('bin')
+        .select(['bin.id', 'bin.code'])
+        .whereRef('bin.warehouseId', '=', 'warehouse.id')
+    ).as('bins'),
+  ])
   .execute()
 
 // TRANSACTION — multi-write atomicity. Use trx (not kysely) inside.
 await kysely.transaction().execute(async (trx) => {
-  await trx.updateTable('stock').set({ quantity: 0 }).where('itemId', '=', id).execute()
-  await trx.insertInto('stockMove').values({ itemId: id, delta: -qty }).execute()
+  await trx
+    .updateTable('stock')
+    .set({ quantity: 0 })
+    .where('itemId', '=', id)
+    .execute()
+  await trx
+    .insertInto('stockMove')
+    .values({ itemId: id, delta: -qty })
+    .execute()
 })
 ```
 
@@ -151,10 +178,10 @@ import { createNodeSqliteKysely } from '@pikku/kysely-node-sqlite'
 
 // Your application DB — CamelCasePlugin on by default
 const kysely = createNodeSqliteKysely<DB>({
-  filename: 'app.db',       // or ':memory:'
+  filename: 'app.db', // or ':memory:'
   camelCase: true,
-  plugins: [],              // layered on top
-  functions: {},            // scalar UDFs, registered as deterministic (Node only)
+  plugins: [], // layered on top
+  functions: {}, // scalar UDFs, registered as deterministic (Node only)
 })
 ```
 
@@ -175,29 +202,29 @@ functions query.
 
 Each database variant exports these services with a prefix (`Pg`, `MySQL`, `SQLite`, or base `Kysely`):
 
-| Service               | Interface                             | Purpose                                        |
-| --------------------- | ------------------------------------- | ---------------------------------------------- |
-| `*ChannelStore`       | `ChannelStore`                        | WebSocket channel state persistence            |
-| `*EventHubStore`      | `EventHubStore`                       | Event hub state persistence                    |
-| `*WorkflowService`    | `PikkuWorkflowService`                | Workflow definition storage                    |
-| `*WorkflowRunService` | `WorkflowRunService`                  | Workflow execution tracking                    |
-| `*DeploymentService`  | `DeploymentService`                   | Deployment state management                    |
-| `*AIStorageService`   | `AIStorageService, AIRunStateService` | AI conversation/run storage                    |
-| `*AgentRunService`    | `AgentRunService`                     | Agent execution tracking                       |
-| `*SecretService`      | `SecretService`                       | Encrypted secret storage (envelope encryption) |
+| Service                | Interface                                   | Purpose                                        |
+| ---------------------- | ------------------------------------------- | ---------------------------------------------- |
+| `*ChannelStore`        | `ChannelStore`                              | WebSocket channel state persistence            |
+| `*EventHubStore`       | `EventHubStore`                             | Event hub state persistence                    |
+| `*WorkflowService`     | `PikkuWorkflowService`                      | Workflow definition storage                    |
+| `*WorkflowRunService`  | `WorkflowRunService`                        | Workflow execution tracking                    |
+| `*DeploymentService`   | `DeploymentService`                         | Deployment state management                    |
+| `*AgentStorageService` | `AgentStorageService, AgentRunStateService` | AI conversation/run storage                    |
+| `*AgentRunService`     | `AgentRunService`                           | Agent execution tracking                       |
+| `*SecretService`       | `SecretService`                             | Encrypted secret storage (envelope encryption) |
 
 A handful more live only on the base package — there is no `Pg`/`MySQL`/`SQLite`
 variant to reach for, you import them from `@pikku/kysely` whatever the engine:
 
-| Service                    | Purpose                                       |
-| -------------------------- | --------------------------------------------- |
-| `KyselySessionStore`        | Persisted user sessions                       |
-| `KyselyScopeService`        | Scope and role storage                        |
-| `KyselyWebhookService`      | Webhook registrations and deliveries          |
-| `KyselyCredentialService`   | Encrypted third-party credentials             |
-| `KyselyAIRunStateService`   | AI run state (also implemented by AIStorage)  |
-| `KyselyWorkflowMirror`      | Mirrors workflow runs into queryable tables   |
-| `KyselyAuditService`        | Durable audit sink (see `pikku-audit`)        |
+| Service                      | Purpose                                      |
+| ---------------------------- | -------------------------------------------- |
+| `KyselySessionStore`         | Persisted user sessions                      |
+| `KyselyScopeService`         | Scope and role storage                       |
+| `KyselyWebhookService`       | Webhook registrations and deliveries         |
+| `KyselyCredentialService`    | Encrypted third-party credentials            |
+| `KyselyAgentRunStateService` | AI run state (also implemented by AIStorage) |
+| `KyselyWorkflowMirror`       | Mirrors workflow runs into queryable tables  |
+| `KyselyAuditService`         | Durable audit sink (see `pikku-audit`)       |
 
 All services take a `Kysely<KyselyPikkuDB>` instance in their constructor and have an `init()` method that creates tables if needed.
 

package/skills/pikku-machine-auth/SKILL.md

@@ -16,10 +16,10 @@ description: >-
 Unified authentication for humans **and** machines against a Pikku + better-auth
 server. Two paths, two headers, one resolver:
 
-| Caller | Credential | Header | Obtained by |
-|---|---|---|---|
-| **Human** (CLI, dev) | better-auth session token | `Authorization: Bearer <token>` | `pikku login` (device flow) → `~/.pikku/session.json` |
-| **Machine** (agent, sandbox, worker) | scoped API key | `x-api-key: <key>` | `createApiKey` (server-side, at provision/spawn) |
+| Caller                               | Credential                | Header                          | Obtained by                                           |
+| ------------------------------------ | ------------------------- | ------------------------------- | ----------------------------------------------------- |
+| **Human** (CLI, dev)                 | better-auth session token | `Authorization: Bearer <token>` | `pikku login` (device flow) → `~/.pikku/session.json` |
+| **Machine** (agent, sandbox, worker) | scoped API key            | `x-api-key: <key>`              | `createApiKey` (server-side, at provision/spawn)      |
 
 Both resolve to a Pikku `UserSession` through one middleware:
 `betterAuthSession({ mapSession, apiKey: { mapKey } })`.
@@ -83,7 +83,7 @@ import { apiKey } from '@better-auth/api-key'
 betterAuth({
   plugins: [
     apiKey({
-      enableMetadata: true,          // REQUIRED to store scope on the key
+      enableMetadata: true, // REQUIRED to store scope on the key
       enableSessionForAPIKeys: true, // lets a key resolve via getSession too
     }),
   ],
@@ -104,10 +104,10 @@ one for a non-existent `userId` is created but will not resolve.
 // `auth` is the better-auth instance (injected service)
 const { key } = await auth.api.createApiKey({
   body: {
-    userId: sandboxRuntimeUserId,        // a stable service user
+    userId: sandboxRuntimeUserId, // a stable service user
     name: `sandbox:${sandboxId}`,
-    expiresIn: 60 * 60,                   // seconds
-    metadata: { sandboxId },             // keep only STABLE ids here
+    expiresIn: 60 * 60, // seconds
+    metadata: { sandboxId }, // keep only STABLE ids here
     permissions: { sandbox: ['read', 'write'] },
   },
 })
@@ -159,7 +159,7 @@ When the api-key header is present it is authoritative — the middleware never
 falls through to `getSession` (a bare mock session would shadow the scoped one).
 When it is absent, the human `getSession` path runs as normal. Either way the
 middleware bails out entirely if a session is already set, and it checks the
-*live* session rather than the wire's construction-time snapshot, so it can't
+_live_ session rather than the wire's construction-time snapshot, so it can't
 clobber one an earlier middleware resolved.
 
 ### Restricting a key below its owner
@@ -182,7 +182,7 @@ power — the restriction lives on the key, not on a proliferation of identities
 ### Failure handling is deliberately split
 
 A key that fails to verify is logged and treated as an ordinary "not
-authenticated" — an unusable credential is not an outage. A failure *inside*
+authenticated" — an unusable credential is not an outage. A failure _inside_
 `mapKey` (your scope store is down) propagates as a real error instead. That
 asymmetry is on purpose: a scope lookup that silently failed would serve the
 request anonymously, which is exactly the wrong direction to fail in.

package/skills/pikku-mcp/SKILL.md

@@ -6,7 +6,7 @@ description: >-
   wireMCPPrompt, the MCP wire object and PikkuMCPServer. TRIGGER when: code uses mcp: true or any
   pikkuMCP*Func/wireMCP* helper, user asks about MCP, Model Context Protocol, AI tool integration,
   or exposing functions to Claude/ChatGPT. DO NOT TRIGGER when: user asks about AI agents (use
-  pikku-ai-agent) or general function definitions (use pikku-concepts).
+  pikku-agent) or general function definitions (use pikku-concepts).
 installGroups: [core]
 ---
 
@@ -37,11 +37,11 @@ See `pikku-concepts` for the core mental model.
 
 MCP has three surfaces, and Pikku wires them differently:
 
-| Surface | Function factory | Wiring | Return type |
-| --- | --- | --- | --- |
-| **Tool** | `mcp: true` on a `pikkuFunc`, or `pikkuMCPToolFunc` | none — the function *is* the registration | the func's own output, or MCP content blocks |
-| **Resource** | `pikkuMCPResourceFunc` | `wireMCPResource({ uri, title, … })` | `Array<{ uri, text }>` |
-| **Prompt** | `pikkuMCPPromptFunc` | `wireMCPPrompt({ name, description, … })` | `Array<MCPPromptMessage>` |
+| Surface      | Function factory                                    | Wiring                                    | Return type                                  |
+| ------------ | --------------------------------------------------- | ----------------------------------------- | -------------------------------------------- |
+| **Tool**     | `mcp: true` on a `pikkuFunc`, or `pikkuMCPToolFunc` | none — the function _is_ the registration | the func's own output, or MCP content blocks |
+| **Resource** | `pikkuMCPResourceFunc`                              | `wireMCPResource({ uri, title, … })`      | `Array<{ uri, text }>`                       |
+| **Prompt**   | `pikkuMCPPromptFunc`                                | `wireMCPPrompt({ name, description, … })` | `Array<MCPPromptMessage>`                    |
 
 Tools are the odd one out — there is no `wireMCPTool`. Resources and prompts
 carry protocol metadata (a URI template, a prompt name) that belongs to the
@@ -58,8 +58,8 @@ Add `mcp: true` to any existing function:
 
 ```typescript
 export const createTodo = pikkuFunc({
-  description: 'Create a new todo item',   // becomes the MCP tool description
-  input: CreateTodoInput,                  // becomes the MCP tool input schema
+  description: 'Create a new todo item', // becomes the MCP tool description
+  input: CreateTodoInput, // becomes the MCP tool input schema
   output: CreateTodoOutput,
   mcp: true,
   func: async ({ db }, { text, priority }) => db.createTodo({ text, priority }),
@@ -141,7 +141,10 @@ import { pikkuMCPPromptFunc, wireMCPPrompt } from '#pikku'
 export const planDayPrompt = pikkuMCPPromptFunc({
   input: UserIdInputSchema,
   func: async (_services, { userId }, { rpc }) => {
-    const { todos } = await rpc.invoke('listTodos', { userId, completed: false })
+    const { todos } = await rpc.invoke('listTodos', {
+      userId,
+      completed: false,
+    })
     return [
       {
         role: 'user' as const,
@@ -242,10 +245,10 @@ anything logs.
 
 ## Red flags
 
-| Symptom | Cause |
-| --- | --- |
-| `wireMCPTool` is not exported | There is no tool wiring — use `mcp: true` or `pikkuMCPToolFunc` |
-| `uri`/`title` rejected on `pikkuMCPResourceFunc` | Those belong on `wireMCPResource` |
-| Resource returning `{ uri, blob, mimeType }` | Resources are text only: `{ uri, text }` |
-| Client sees a tool with no description | `mcp: true` without a `description` — check the codegen warning |
-| stdio client disconnects on the first log line | Logger still writing to stdout; use `createMCPLogger()` |
+| Symptom                                          | Cause                                                           |
+| ------------------------------------------------ | --------------------------------------------------------------- |
+| `wireMCPTool` is not exported                    | There is no tool wiring — use `mcp: true` or `pikkuMCPToolFunc` |
+| `uri`/`title` rejected on `pikkuMCPResourceFunc` | Those belong on `wireMCPResource`                               |
+| Resource returning `{ uri, blob, mimeType }`     | Resources are text only: `{ uri, text }`                        |
+| Client sees a tool with no description           | `mcp: true` without a `description` — check the codegen warning |
+| stdio client disconnects on the first log line   | Logger still writing to stdout; use `createMCPLogger()`         |

package/skills/pikku-middleware/SKILL.md

@@ -48,6 +48,7 @@ const telemetryMiddleware = pikkuMiddleware({
 ```
 
 The `wire` object gives you:
+
 - `wire.http` — inbound HTTP context (headers, URL, cookies)
 - `wire.setSession(session)` — set the session for this request
 - `wire.getSession()` — read the current session
@@ -70,7 +71,7 @@ addHTTPMiddleware('*', [cors(), authBearer()])
 addHTTPMiddleware('/admin/*', [auditLog])
 
 // 4. Tag-based: any wiring with matching tag
-addTagMiddleware('machine-agent', [bearerAuth])  // tag on function or wire
+addTagMiddleware('machine-agent', [bearerAuth]) // tag on function or wire
 
 // 5. Inline: per-wiring
 wireHTTP({
@@ -88,8 +89,8 @@ Runs before everything else, across every wire type: HTTP, Queue, Channel, Trigg
 import { addGlobalMiddleware } from '@pikku/core'
 import { telemetryOuter, telemetryInner } from '@pikku/core/middleware'
 
-addGlobalMiddleware([telemetryOuter({ environmentId: env.STAGE_ID })])  // wraps the full call
-addGlobalMiddleware([telemetryInner({ environmentId: env.STAGE_ID })])  // closest to the function body
+addGlobalMiddleware([telemetryOuter({ environmentId: env.STAGE_ID })]) // wraps the full call
+addGlobalMiddleware([telemetryInner({ environmentId: env.STAGE_ID })]) // closest to the function body
 ```
 
 `telemetryOuter` ships with `priority: 'highest'`, `telemetryInner` with `priority: 'lowest'` — so priority sorting places outer first regardless of array/call order.
@@ -101,7 +102,9 @@ import { addHTTPMiddleware } from '@pikku/core/http'
 import { cors, authBearer } from '@pikku/core/middleware'
 
 // All routes
-addHTTPMiddleware('*', [cors({ origin: 'https://app.example.com', credentials: true })])
+addHTTPMiddleware('*', [
+  cors({ origin: 'https://app.example.com', credentials: true }),
+])
 
 // Scoped to /api/* prefix
 addHTTPMiddleware('/api/*', [rateLimit({ maxRequests: 100, windowMs: 60_000 })])
@@ -161,7 +164,7 @@ highest → high → medium (default) → low → lowest
 
 **Priority is the primary key across every scope, not within one.** The collected
 list is flattened first and sorted once, so a `priority: 'lowest'` global
-middleware runs *after* an inline per-route middleware of default priority — the
+middleware runs _after_ an inline per-route middleware of default priority — the
 narrower scope does not win. Scope order survives only as the tiebreaker between
 middleware of equal priority, because the sort is stable.
 
@@ -190,7 +193,9 @@ A server that exposes RPCs only to a trusted caller (e.g. an API calling a machi
 ```typescript
 // lib/host-token.ts
 let _token: string | null = null
-export const setToken = (t: string) => { _token = t }
+export const setToken = (t: string) => {
+  _token = t
+}
 export const getToken = () => _token
 ```
 
@@ -202,7 +207,9 @@ import { UnauthorizedError } from '@pikku/core/errors'
 import { getToken } from '../lib/host-token.js'
 
 const bearerAuth = pikkuMiddleware(async (_services, { http }, next) => {
-  const authHeader = http?.request?.header?.('authorization') || http?.request?.header?.('Authorization')
+  const authHeader =
+    http?.request?.header?.('authorization') ||
+    http?.request?.header?.('Authorization')
   const token = getToken()
   const expected = token ? `Bearer ${token}` : null
   if (

package/skills/pikku-mongodb/SKILL.md

@@ -49,17 +49,17 @@ await mongo.close()
 
 ### Available Services
 
-| Service                     | Interface                             | Purpose                                        |
-| --------------------------- | ------------------------------------- | ---------------------------------------------- |
-| `MongoDBChannelStore`       | `ChannelStore`                        | WebSocket channel state persistence            |
-| `MongoDBEventHubStore`      | `EventHubStore`                       | Event hub state persistence                    |
-| `MongoDBWorkflowService`    | `PikkuWorkflowService`                | Workflow definition storage                    |
-| `MongoDBWorkflowRunService` | `WorkflowRunService`                  | Workflow execution tracking                    |
-| `MongoDBDeploymentService`  | `DeploymentService`                   | Deployment state management                    |
-| `MongoDBAIStorageService`   | `AIStorageService, AIRunStateService` | AI conversation/run storage                    |
-| `MongoDBAgentRunService`    | `AgentRunService`                     | Agent execution tracking                       |
-| `MongoDBSecretService`      | `SecretService`                       | Encrypted secret storage (envelope encryption) |
-| `MongoDBSessionStore`       | `SessionStore`                        | Persisted user sessions                        |
+| Service                      | Interface                                   | Purpose                                        |
+| ---------------------------- | ------------------------------------------- | ---------------------------------------------- |
+| `MongoDBChannelStore`        | `ChannelStore`                              | WebSocket channel state persistence            |
+| `MongoDBEventHubStore`       | `EventHubStore`                             | Event hub state persistence                    |
+| `MongoDBWorkflowService`     | `PikkuWorkflowService`                      | Workflow definition storage                    |
+| `MongoDBWorkflowRunService`  | `WorkflowRunService`                        | Workflow execution tracking                    |
+| `MongoDBDeploymentService`   | `DeploymentService`                         | Deployment state management                    |
+| `MongoDBAgentStorageService` | `AgentStorageService, AgentRunStateService` | AI conversation/run storage                    |
+| `MongoDBAgentRunService`     | `AgentRunService`                           | Agent execution tracking                       |
+| `MongoDBSecretService`       | `SecretService`                             | Encrypted secret storage (envelope encryption) |
+| `MongoDBSessionStore`        | `SessionStore`                              | Persisted user sessions                        |
 
 All services take a `Db` instance in their constructor and have an `init()` method that creates collections/indexes.
 

package/skills/pikku-n8n-import/references/addon-mapping.md

@@ -18,9 +18,11 @@ rewrite the stub.
      "n8nType": "n8n-nodes-base.gmailTool",
      "n8nName": "Send a message in Gmail",
      "parameters": { "sendTo": "...", "message": "...", "subject": "..." },
-     "credentials": { "gmailOAuth2": { "id": "...", "name": "Personal Gmail" } },
+     "credentials": {
+       "gmailOAuth2": { "id": "...", "name": "Personal Gmail" },
+     },
      "isAgentTool": true,
-     "agentName": "Inbox Assistant"
+     "agentName": "Inbox Assistant",
    }
    ```
 2. **Installed addons** — `@pikku/addon-*` in the project's `package.json`
@@ -35,12 +37,12 @@ rewrite the stub.
 Map `n8nType` to a package by reading its source. Common shapes (**guesses, not
 authoritative** — always verify against installed source):
 
-| n8n type prefix | typical addon candidate |
-|---|---|
-| `n8n-nodes-base.gmail` / `gmailTool` | `@pikku/addon-email-gmail` |
-| `n8n-nodes-base.slack` / `slackTool` | `@pikku/addon-chat-slack` |
-| `n8n-nodes-base.googleSheets` / `…Tool` | `@pikku/addon-sheets-google` |
-| `n8n-nodes-base.notion` / `notionTool` | `@pikku/addon-docs-notion` |
+| n8n type prefix                            | typical addon candidate      |
+| ------------------------------------------ | ---------------------------- |
+| `n8n-nodes-base.gmail` / `gmailTool`       | `@pikku/addon-email-gmail`   |
+| `n8n-nodes-base.slack` / `slackTool`       | `@pikku/addon-chat-slack`    |
+| `n8n-nodes-base.googleSheets` / `…Tool`    | `@pikku/addon-sheets-google` |
+| `n8n-nodes-base.notion` / `notionTool`     | `@pikku/addon-docs-notion`   |
 | `n8n-nodes-base.telegram` / `telegramTool` | `@pikku/addon-chat-telegram` |
 
 If no installed addon plausibly covers the n8n type, stop and report it — do not
@@ -74,6 +76,7 @@ over guessing.
 Two outcomes, by `isAgentTool`:
 
 **A) `isAgentTool: true`** — the stub is an agent tool referenced via `ref()`:
+
 1. Delete the stub file.
 2. In the agent file, replace `ref('agentGmailtool__sendAMessageInGmail')` in
    `tools: [...]` with `ref('messageSend')` (the resolved addon function).
@@ -81,13 +84,16 @@ Two outcomes, by `isAgentTool`:
    `node_modules/@pikku/addon-*`).
 
 If you can't delete safely, leave a one-line re-export instead of a stub:
+
 ```ts
 import { messageSend } from '@pikku/addon-email-gmail'
 export const agentGmailtool__sendAMessageInGmail = messageSend
 ```
+
 Default is delete + retarget; wrappers add maintenance burden.
 
 **B) `isAgentTool: false`** — the stub is a graph node:
+
 1. Open `<workflow>.graph.ts`.
 2. In `nodes: { … }` find the entry whose value is the stub rpc name.
 3. Replace it with the addon function name (`'messageSend'`).