pome-sh 0.6.6

package/node_modules/@pome-sh/twin-github/node_modules/@hono/node-server/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@hono/node-server",
+  "version": "1.19.14",
+  "description": "Node.js Adapter for Hono",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    },
+    "./serve-static": {
+      "types": "./dist/serve-static.d.ts",
+      "require": "./dist/serve-static.js",
+      "import": "./dist/serve-static.mjs"
+    },
+    "./vercel": {
+      "types": "./dist/vercel.d.ts",
+      "require": "./dist/vercel.js",
+      "import": "./dist/vercel.mjs"
+    },
+    "./utils/*": {
+      "types": "./dist/utils/*.d.ts",
+      "require": "./dist/utils/*.js",
+      "import": "./dist/utils/*.mjs"
+    },
+    "./conninfo": {
+      "types": "./dist/conninfo.d.ts",
+      "require": "./dist/conninfo.js",
+      "import": "./dist/conninfo.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "serve-static": [
+        "./dist/serve-static.d.ts"
+      ],
+      "vercel": [
+        "./dist/vercel.d.ts"
+      ],
+      "utils/*": [
+        "./dist/utils/*.d.ts"
+      ],
+      "conninfo": [
+        "./dist/conninfo.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "test": "node --expose-gc node_modules/jest/bin/jest.js",
+    "build": "tsup --external hono",
+    "watch": "tsup --watch",
+    "postbuild": "publint",
+    "prerelease": "bun run build && bun run test",
+    "release": "np",
+    "lint": "eslint src test",
+    "lint:fix": "eslint src test --fix",
+    "format": "prettier --check \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\"",
+    "format:fix": "prettier --write \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\""
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/honojs/node-server.git"
+  },
+  "homepage": "https://github.com/honojs/node-server",
+  "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.14.1"
+  },
+  "devDependencies": {
+    "@hono/eslint-config": "^1.0.1",
+    "@types/jest": "^29.5.3",
+    "@types/node": "^20.10.0",
+    "@types/supertest": "^2.0.12",
+    "@whatwg-node/fetch": "^0.9.14",
+    "eslint": "^9.10.0",
+    "hono": "^4.4.10",
+    "jest": "^29.6.1",
+    "np": "^7.7.0",
+    "prettier": "^3.2.4",
+    "publint": "^0.1.16",
+    "supertest": "^6.3.3",
+    "ts-jest": "^29.1.1",
+    "tsup": "^7.2.0",
+    "typescript": "^5.3.2"
+  },
+  "peerDependencies": {
+    "hono": "^4"
+  },
+  "packageManager": "bun@1.2.20"
+}

package/node_modules/@pome-sh/twin-github/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@pome-sh/twin-github",
+  "version": "0.1.0",
+  "description": "Deterministic GitHub-shaped twin for agent testing — REST + MCP, SQLite-backed state.",
+  "private": true,
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./server": {
+      "types": "./dist/src/server.d.ts",
+      "default": "./dist/src/server.js"
+    },
+    "./*": "./dist/src/*.js"
+  },
+  "bin": {
+    "twin-github": "./dist/src/server.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "FIDELITY.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsx src/server.ts",
+    "seed": "tsx scripts/seed.ts",
+    "smoke": "tsx scripts/smoke.ts",
+    "validate:mcp": "tsx scripts/validate-mcp.ts",
+    "agent:claude": "tsx examples/claude-github-agent.ts",
+    "review:harness": "tsx scripts/review-harness.ts",
+    "start": "node dist/src/server.js",
+    "prepack": "bun run build",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "capture:fixtures": "tsx scripts/capture-gh-fixtures.ts",
+    "fidelity:parity": "tsx scripts/fidelity-parity.ts"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.6",
+    "@pome-sh/shared-types": "workspace:*",
+    "better-sqlite3": "^12.5.0",
+    "hono": "^4.12.27",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@octokit/openapi-types": "^27.0.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.1.9",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.7"
+  },
+  "keywords": [
+    "github",
+    "twin",
+    "test-double",
+    "agent-testing",
+    "mcp",
+    "pome"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pome-sh/pome.git",
+    "directory": "packages/twin-github"
+  },
+  "homepage": "https://github.com/pome-sh/pome/tree/main/packages/twin-github",
+  "bugs": {
+    "url": "https://github.com/pome-sh/pome/issues"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=20"
+  }
+}

package/node_modules/@pome-sh/twin-slack/FIDELITY.md

@@ -0,0 +1,259 @@
+# Slack Twin Fidelity
+
+`@pome-sh/twin-slack` is a high-fidelity test double of the Slack Web API —
+not a universal clone. This page documents exactly which surfaces are
+faithful to real Slack today, at what tier, and how fidelity is verified.
+
+Last verified: 2026-05-28.
+
+## What "fidelity" means here
+
+Each MCP tool and REST route is classified into one of three tiers:
+
+- **`semantic`** — the stateful behavior is implemented locally and covered
+  by tests. Message threading, channel membership, reaction uniqueness, ts
+  monotonicity, and the rest behave the way agents expect when they call
+  real Slack.
+- **`shape`** — the response envelope matches real Slack but some
+  underlying behavior is simplified. Useful for agents that only inspect
+  fields, not safe for agents that rely on side effects.
+- **`unsupported`** — not implemented. The twin returns a loud 501 envelope
+  with `_twin.fidelity: "unsupported"` so an agent never silently succeeds
+  against a missing surface.
+
+The bar is: **agents written against real Slack run unchanged against the
+local twin for the surfaces below**, and trip a loud failure for anything
+outside them.
+
+For the build / runtime / cross-repo invariants the hosted snapshot build
+depends on (port `:3333`, `/healthz`, `SLACK_CLONE_HOST`, `npm install`-able
+package, `node dist/src/server.js`), see
+[Runtime contract (for snapshot consumers)](README.md#runtime-contract-for-snapshot-consumers)
+in the package README. Changing any of those is a breaking change for
+`pome-cloud` and goes via a cross-repo PR.
+
+## MCP Tools
+
+| Tool | Backing surface | Tier | Tests | Known deviations |
+| --- | --- | --- | --- | --- |
+| `slack_post_message` | SQLite messages | semantic | `mcp-contract.test.ts`, `domain-chat.test.ts`, `recorder-state-delta.test.ts` | Block-kit rendering is not validated; emoji shortcodes are preserved literally. |
+| `slack_reply_to_thread` | SQLite messages (thread_ts FK) | semantic | `mcp-contract.test.ts`, `domain.test.ts` | Routes via `chat.postMessage({thread_ts})`; `reply_broadcast` is recorded but not re-fanned out. |
+| `slack_add_reaction` | SQLite reactions | semantic | `mcp-contract.test.ts`, `domain.test.ts`, `concurrency.test.ts` | Reactions are unique per `(channel, ts, name, user)`; skin-tone modifier suffixes are preserved as-is. |
+| `slack_get_channel_history` | SQLite messages | semantic | `mcp-contract.test.ts`, `domain.test.ts`, `performance.test.ts` | `oldest`/`latest`/`inclusive` filters supported; per-message metadata follows real Slack envelope. |
+| `slack_get_thread_replies` | SQLite messages | semantic | `mcp-contract.test.ts`, `domain.test.ts`, `domain-chat.test.ts` | Parent decorated with `thread_ts === ts`, `subscribed: false`, `is_locked: false` per real Slack invariant. |
+| `slack_list_channels` | SQLite channels | semantic | `mcp-contract.test.ts`, `domain.test.ts`, `performance.test.ts` | `types` filter supports `public_channel,private_channel,mpim,im`; cursor pagination via base64url offsets. |
+| `slack_get_users` | SQLite users | semantic | `mcp-contract.test.ts`, `domain.test.ts` | Deleted users are included with `deleted: true`; profile pagination matches real Slack envelope. |
+| `slack_get_user_profile` | SQLite users.profile_json | semantic | `mcp-contract.test.ts`, `domain.test.ts` | Returns the full profile JSON; custom fields preserved verbatim through the round-trip. |
+
+The visible MCP tool count is pinned at 8 in `test/mcp-contract.test.ts`;
+descriptions, required fields, mutating set, and `additionalProperties:false`
+are all locked. Any drift breaks the contract test loudly.
+
+## REST routes
+
+| Endpoint | Tier | Tests | Notes |
+| --- | --- | --- | --- |
+| `auth.test` | semantic | `app.test.ts`, `auth.test.ts` | Returns `{ok, url, team, user, team_id, user_id, bot_id?}`. |
+| `chat.postMessage` | semantic | `app.test.ts`, `domain-chat.test.ts`, `recorder-state-delta.test.ts` | Form-encoded + JSON body; persists `username`, `icon_emoji`, `icon_url`; emits `bot_id`, `bot_profile`, `app_id` for bot authors. |
+| `chat.update` | semantic | `domain-chat.test.ts`, `app-routes.test.ts` | `edited_ts` allocated via the workspace-unique ts counter — no collisions. |
+| `chat.delete` | semantic | `app.test.ts`, `actor-session.test.ts`, `domain.test.ts` | Hard delete (matches real Slack); thread parent `reply_count` decrements transactionally. No admin override. |
+| `chat.scheduleMessage` / `chat.deleteScheduledMessage` | semantic | `domain.test.ts`, `app-routes.test.ts` | No fire path — scheduled messages persist until explicit delete. |
+| `conversations.list` | semantic | `app.test.ts`, `recorder-state-delta.test.ts` | Cursor pagination, `types` filter, `exclude_archived`. |
+| `conversations.info` | semantic | `app-routes.test.ts` | `include_num_members` supported. |
+| `conversations.create` | semantic | `app.test.ts`, `domain-conversations.test.ts` | Granular error codes: `invalid_name_required` / `_maxlength` / `_specials` / `_punctuation`. |
+| `conversations.history` | semantic | `app.test.ts`, `performance.test.ts` | Newest-first ordering; `pin_count` included. |
+| `conversations.replies` | semantic | `domain-chat.test.ts`, `domain.test.ts` | Parent decorated with `thread_ts === ts`, `subscribed:false`, `is_locked:false`. |
+| `conversations.invite` / `join` / `leave` / `kick` / `archive` / `members` | semantic | `app-routes.test.ts`, `domain.test.ts`, `domain-conversations.test.ts` | `cant_kick_self`, `cant_kick_from_general`, `cant_leave_general`, `cant_archive_general` matched. |
+| `conversations.open` | semantic | `domain-conversations.test.ts`, `concurrency.test.ts` | Deterministic DM channel id by sorted member-id signature with a partial UNIQUE index. |
+| `reactions.add` / `remove` / `get` | semantic | `app.test.ts`, `domain.test.ts`, `concurrency.test.ts` | `already_reacted` / `no_reaction` error codes. |
+| `users.list` / `users.info` / `users.lookupByEmail` / `users.profile.get` / `users.profile.set` | semantic | `domain.test.ts`, `app-routes.test.ts` | `users_not_found` error code on email miss. |
+| `pins.add` / `remove` / `list` | semantic | `domain.test.ts`, `app-routes.test.ts` | `already_pinned` / `no_pin` codes; SQL constraint-mapped on race. |
+| `search.messages` | semantic | `domain.test.ts`, `performance.test.ts` | Substring (LIKE-based) match; query syntax is intentionally smaller than real Slack search. |
+| `files.upload` / `info` / `list` / `delete` | shape | `domain.test.ts`, `app-routes.test.ts` | Metadata-only; no binary storage. URL fields point to deterministic `pome-twin-files.slack.com` hosts. |
+| `bookmarks.add` / `remove` / `list` | semantic | `domain.test.ts`, `app-routes.test.ts` | `link` type accepted; other bookmark types are unsupported per real Slack 2024 changelog. |
+| `team.info` | semantic | `app-routes.test.ts` | Returns workspace metadata; enterprise fields are NULL for non-Enterprise twins. |
+
+Routes not listed return **501 + `_twin.fidelity:"unsupported"`** so agents
+fail loudly rather than silently no-op.
+
+## Fidelity-watch coverage (status.pome.sh)
+
+The daily watchdog reports twin-slack at **19 of 45 semantic surfaces**, 26 rolling
+out. The number is built from source, never hand-typed
+(the Twin Fidelity Watch in pome-cloud); here is exactly what it counts.
+
+- **Denominator (45)** — the full semantic surface inventory: 8 MCP tools + 37
+  semantic REST methods (`files.upload` is shape-tier, excluded). MCP tools and
+  REST methods are counted as **distinct public contracts**: an agent calls
+  `slack_list_channels`, a REST client calls `conversations.list`. They share a
+  backend, but each is a surface we hold to fidelity on its own. Source:
+  the Twin Fidelity Watch's `sandboxes/slack/surfaces.ts` (`SEMANTIC_SURFACES`, in pome-cloud).
+- **Numerator (19)** — surfaces with their own external-verification evidence,
+  counted in distinct methods/tools (not capture instances):
+  - **16 REST read methods**, shape-diffed daily against real Slack (the committed
+    upstream golden). `conversations.info` and `conversations.history` are each
+    captured under two scenarios (public/private channel, empty/non-empty history),
+    so the table shows 18 read rows but 16 distinct methods.
+  - **3 mutating MCP tools** (`slack_post_message`, `slack_reply_to_thread`,
+    `slack_add_reaction`), write round-tripped against the seeded twin **oracle**
+    (L2). This is L2-vs-oracle, **not** L1-vs-real-Slack — the daily cron does no
+    mutating writes against the real workspace.
+- **Rolling out (26)** — 5 read MCP tools (their underlying REST reads are verified;
+  the MCP-envelope check rolls out next), 20 mutating REST methods (no write
+  round-trip yet — including the `chat.postMessage` / `reactions.add` that back the
+  3 verified MCP write tools, since the REST contract is verified separately), and
+  `files.info` (needs a minted file id; see the L1 read exception). A surface is
+  counted only once it has its own evidence — never credited by proxy.
+
+## Known divergences from real Slack
+
+Each bullet has exactly one structured entry in the Twin Fidelity Watch's
+`known-divergences/slack.yaml` (in pome-cloud)
+(the `SL-DIV-NNN` machine mirror, enforced 1:1 by the fidelity lint, D9). The
+read-subset / accepted-divergence bullets (9–15) were derived from the FDRS-473
+real-Slack L1 reconciliation: the twin capture diffed against the committed
+real-Slack golden, then triaged into upstream-only leaves the twin faithfully
+omits (read_subset) and genuine identity / controlled-sandbox differences the
+twin cannot reproduce (accepted_divergence). Twin-only OVER-returned fields were
+FIXED in the twin source, not documented away.
+
+_Behavioral / envelope choices:_
+
+1. **Auth errors return HTTP 401** instead of real Slack's 200 + `{ok:false,
+   error:"not_authed"}`. The choice aligns with RFC 6750 Bearer-Token
+   semantics and is what the `@slack/web-api` SDK expects on bad tokens;
+   401 is also what every MCP client expects. Application-level errors
+   (e.g. `channel_not_found`, `name_taken`) DO return HTTP 200 to match
+   real Slack and keep the SDK parseable.
+2. **Hard delete** for `chat.delete` (matches Slack) — thread replies of a
+   deleted parent are orphaned with their `thread_ts` pointing at a gone
+   row. Real Slack soft-deletes the parent with a tombstone placeholder.
+3. **No admin override** on `chat.update` / `chat.delete`. Real Slack also
+   does not provide an admin override at the API layer; this is documented
+   for clarity.
+4. **`ts` is workspace-globally-unique** (matches real Slack); two channels'
+   first messages produce distinct ts values.
+5. **No RTM / Events / Socket Mode** — only HTTP REST + MCP JSON-RPC.
+6. **No Slack Connect, Enterprise Grid, or admin scopes.**
+7. **`files.upload` is the legacy v1 endpoint.** Real Slack's 2024-04
+   deprecation of v1 in favor of `files.getUploadURLExternal` +
+   `files.completeUploadExternal` is not yet implemented.
+8. **`search.messages`** uses substring matching (LIKE), not Slack's
+   query-grammar (modifiers like `in:`, `from:`, `before:` are not parsed).
+
+_Read-subset field omissions (twin returns a documented subset):_
+
+9. **Team objects omit Slack enterprise/internal flags.** `team.info` omits
+   `is_verified`, `lob_sales_home_enabled`, and `is_sfdc_auto_slack` — the
+   verified-org badge and Slack-internal Salesforce/auto-provision flags a
+   non-Enterprise twin does not model. (`avatar_base_url` is `*_url` hypermedia,
+   INFO categorically.)
+10. **Channel objects omit Slack-Connect/viewer-state/rename metadata.**
+    `conversations.list` / `.info` channel objects omit the Slack-Connect leaves
+    (`is_ext_shared`, `shared_team_ids`, `pending_connected_team_ids`), the
+    per-viewer state (`is_member`, `is_open`, `last_read`), the server `updated`
+    mtime, the `properties` blob, and `previous_names` (the twin models no rename
+    history — it omits the key rather than emitting an empty array).
+11. **Message objects omit bot-identity/block/thread-fanout metadata.**
+    `conversations.history` / `.replies` / `reactions.get` message objects omit
+    `bot_id` / `app_id` / `bot_profile` (the seeded author is a user, not a bot
+    app), the rich-text `blocks`, the thread-fanout convenience leaves
+    (`thread_ts` on a parent, `reply_users`, `parent_user_id`, `is_locked`), and
+    the `permalink` / `team` decoration.
+12. **User-profile objects omit contact-card and derived-status leaves.** The
+    `users.*` profile omits the unseed-ed contact card (`first_name`, `last_name`,
+    `title`, `phone`, `skype`), the custom-`fields` blob, the derived status
+    leaves (`status_text_canonical`, `status_emoji_display_info`,
+    `status_clear_on_focus_end`), and `always_active`. (The per-endpoint
+    `email`/`team` shape was FIXED in the twin to match real Slack.)
+13. **Search match objects omit internal-search and shared-channel metadata.**
+    `search.messages` matches omit Slack's `db_message` / `score` internals, the
+    `blocks` / `no_reactions` leaves, and the per-match embedded `channel`'s full
+    shared-channel flag set (`is_channel`, `is_group`, `is_im`, `is_mpim`,
+    `is_shared`, `is_org_shared`, `is_ext_shared`, `is_archived`,
+    `pending_shared`, `is_pending_ext_shared`).
+
+_Accepted divergences (identity / controlled-sandbox):_
+
+14. **`auth.test` `bot_id` reflects the capturing bot token, not the seeded user.**
+    The golden was captured with a bot app token, so real Slack returns a `bot_id`
+    string; the twin's seeded auth user is a regular user, so it returns
+    `bot_id: null`. An inherent identity divergence — the bot id is a
+    workspace-minted id the twin cannot reproduce.
+15. **`conversations.members` #general count reflects the seed (3) vs the free workspace (bot+1).**
+    The seed models three users in #general; the real free workspace's #general has
+    only the bot plus the single creating human (a free workspace cannot be seeded
+    with extra human members via a bot token). Unavoidable controlled-sandbox vs
+    free-workspace membership difference, not a serializer bug.
+
+_Shape-anchoring divergences (compile-time anchor to `@slack/web-api`):_
+
+16. **Serializers are anchored to `@slack/web-api`, a source that lags real Slack on some fields.**
+    The shape anchor (`src/upstream-types.ts`, FDRS-477) is the SDK's published
+    response types, not real Slack's live wire format. The SDK trails Slack on some
+    leaves (un-typed fresh fields, removed-but-still-served legacy fields), so a
+    twin field the SDK does not type still surfaces as an emitted-not-in-upstream
+    divergence even when real Slack returns it. The anchor is a compile-time subset
+    guard, not a fidelity oracle — live capture (the FDRS-473 golden) outranks it.
+17. **`serializePin` is left to live capture — `@slack/web-api`'s pin type is too thin.**
+    `PinsListResponse.Item` models only `{comment, created, created_by, file, type}`:
+    it has NO `message` and NO `channel`. The twin emits a MESSAGE pin
+    (`type:"message"`, `channel`, `message`, `created`, `created_by`) whose two
+    distinguishing fields are absent upstream, so the type would anchor only
+    `created`/`created_by`/`type`. Anchoring it adds no real guard; `serializePin` is
+    deliberately UNANCHORED and verified against the live golden instead.
+18. **`serializeUserProfile` emits a twin-only `team` field.** `team` is not on the
+    `@slack/web-api` profile type; the twin carries it for cross-endpoint convenience.
+    Held out of the anchored `base` literal and spread back on the open Record.
+19. **Channel objects emit twin-only `parent_conversation` and `members`.**
+    `serializeChannel` carries `parent_conversation` (always `null` — the twin models
+    no thread-parent conversations) and a conditional `members` count, neither on the
+    anchored `SlackChannel`. Both are assigned on the Record after the anchor.
+20. **Messages emit a twin-only `permalink`.** `serializeMessage` decorates a fetched
+    message with a deterministic `permalink` the upstream `SlackMessage` does not
+    carry. Held out of the anchored literal and merged on the Record.
+21. **Scheduled messages emit a twin-only `thread_ts`.** `serializeScheduledMessage`
+    carries `thread_ts` for scheduled thread replies; it is absent from
+    `@slack/web-api`'s `ChatScheduledMessagesListResponse` item, so it is held out of
+    the anchored `base` and spread back.
+
+## Shape anchoring (compile-time, `@slack/web-api@7.16.0`)
+
+The serializers are pinned to Slack's official response types at compile time
+(`src/upstream-types.ts`, FDRS-477; mirrors twin-github FDRS-475/476). Each
+serializer's literal `satisfies DeepPartial<Slack…>`, so a wrong-named or
+mistyped field is a COMPILE error while omitting a field stays legal (the twin
+is a faithful subset). The anchor target is `@slack/web-api@7.16.0`.
+
+**Anchored (9 serializers).** `serializeWorkspace`, `serializeUserProfile`,
+`serializeUser`, `serializeChannel`, `serializeMessage`, `groupReactions`
+(array-element anchor), `serializeFile`, `serializeBookmark`, and
+`serializeScheduledMessage` all `satisfies DeepPartial<…>` against their
+`@slack/web-api` type. `serializeBookmark` is a perfect 1:1 (no held-out keys).
+Where the row type is wider than upstream (`safeJsonArray` returns `unknown[]`,
+nullable columns), the value is cast to the upstream leaf type; twin-only fields
+(bullets 18–21) are held off the anchored literal and assigned on the Record.
+
+**Left to live capture (1 serializer).** `serializePin` is unanchored: the SDK's
+`PinsListResponse.Item` is too thin to model a message pin (bullet 17), so it is
+verified against the FDRS-473 real-Slack golden instead of the type.
+
+**Inverse weighting (live capture > anchor on Slack).** The `@slack/web-api`
+types are a published SDK artifact that lags the live API, so they are a weaker
+oracle here than the committed real-Slack golden. The anchor is the cheap
+compile-time floor (catches typos and an upstream field-rename at build time);
+the golden is the source of truth for what real Slack actually returns. When the
+two disagree, the golden wins and the anchor's gap is recorded as a divergence
+above — never the reverse.
+
+## Verification commands
+
+```bash
+cd packages/twin-slack
+bun run typecheck                       # zero TS errors
+bun run test                            # all tests pass
+bunx vitest run --coverage              # ≥ 90% lines, ≥ 90% funcs
+bun run validate:mcp                    # JSON-RPC SDK round-trip
+TWIN_AUTH_SECRET=dev SLACK_DETERMINISTIC_TS=1 bun run smoke
+bun run verify:cloud-token              # cloud xoxb-pome-* token validates
+```

package/node_modules/@pome-sh/twin-slack/README.md

@@ -0,0 +1,213 @@
+# Pome Twin: Slack
+
+> One of three twins in this repository (GitHub, Stripe x402, Slack).
+
+`@pome-sh/twin-slack` is a local, stateful Slack twin for agent testing. It exposes Slack Web API–shaped REST routes plus an 8-tool MCP-style API backed by the same SQLite domain services. The 8 visible MCP tools mirror the canonical Slack agent toolset (post message, reply to thread, add reaction, get channel history, get thread replies, list channels, list users, get user profile).
+
+## Quickstart
+
+```bash
+bun install
+bun run seed
+export TWIN_AUTH_SECRET=$(openssl rand -hex 32)
+bun run dev
+
+# Docker (from monorepo root; host port 3335):
+# docker compose --profile twins up -d twin-slack
+# curl http://127.0.0.1:3335/healthz
+```
+
+Slack-shaped REST + MCP routes live under `/s/:sid/*` and require a
+bearer token whose `sid` claim matches the URL `:sid`. `/healthz` and
+`/admin/*` stay at the root (admin is localhost-only).
+
+```bash
+# Mint a token (32-char minimum secret recommended; use the SAME secret as the server)
+TOKEN=$(node -e "import('hono/jwt').then(m => m.sign({ sid: 'demo', team_id: 'tm_1', login: 'pome-agent', exp: Math.floor(Date.now()/1000)+3600 }, process.env.TWIN_AUTH_SECRET).then(t => console.log(t)))")
+
+# Public health probe — no auth
+curl http://127.0.0.1:3333/healthz
+
+# Session-scoped routes — auth required, sid in path must equal sid in claim
+curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:3333/s/demo/auth.test
+curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:3333/s/demo/mcp/tools
+
+# Slack SDKs default to form-encoded bodies; the twin accepts both form and JSON
+curl -X POST http://127.0.0.1:3333/s/demo/chat.postMessage \
+  -H "Authorization: Bearer $TOKEN" \
+  -H 'content-type: application/x-www-form-urlencoded' \
+  -d 'channel=C_GENERAL&text=hello'
+
+# Legacy MCP call
+curl -s -X POST http://127.0.0.1:3333/s/demo/mcp/call \
+  -H "Authorization: Bearer $TOKEN" \
+  -H 'content-type: application/json' \
+  -d '{"tool":"slack_list_channels","arguments":{"limit":10}}'
+```
+
+The default seed creates:
+
+- Workspace `T_POME` ("Pome Twin Workspace", domain `pome-twin`)
+- Users `pome-agent` (`U_PRIMARY`, admin), `alice` (`U_ALICE`), `bob` (`U_BOB`)
+- Channels `#general` (`C_GENERAL`, all three members, 2 seeded messages) and `#random` (`C_RANDOM`, no members)
+
+## APIs
+
+- REST base URL: `http://127.0.0.1:3333`
+- **Real MCP (JSON-RPC, Streamable HTTP, stateless):** `POST /s/:sid/mcp`
+  — speaks the protocol the `@modelcontextprotocol/sdk` `Client` +
+  `StreamableHTTPClientTransport` expect (`initialize`, `tools/list`,
+  `tools/call`, `ping`, `notifications/*`). 8 visible tools returned via
+  `tools/list` with camelCase `inputSchema`.
+- Legacy custom MCP routes:
+  - `GET  /s/:sid/mcp/tools` — returns `{ tools: [{ name, description, input_schema }, ...] }`
+  - `POST /s/:sid/mcp/call` — body `{ tool, arguments }`
+
+All session-scoped REST and MCP routes require a bearer token whose `sid`
+claim matches the path. Provider-shape `xoxb-pome-<sid>-<sig>` /
+`xoxp-pome-<sid>-<sig>` tokens are also accepted (cloud control-plane issues
+these via `provider_credentials.slack.token`).
+
+### Connecting from `@modelcontextprotocol/sdk` or the Anthropic Agent SDK
+
+```ts
+// Anthropic claude-agent-sdk mcpServers config
+mcpServers: {
+  slack: {
+    type: "http",
+    url: `${TWIN_BASE_URL}/s/${sid}/mcp`,
+    headers: { Authorization: `Bearer ${token}` }
+  }
+}
+```
+
+The endpoint is stateless: each POST is independent; no `Mcp-Session-Id`
+round-trip, no SSE. `GET` and `DELETE` on `/s/:sid/mcp` return 405. The
+bearer-auth contract is unchanged — the JWT `sid` claim (or
+`xoxb-pome-<sid>-<hmac>` provider-shape token) still has to match the
+path's `:sid`.
+
+### Visible MCP tools
+
+| Tool | Inputs | Description |
+|---|---|---|
+| `slack_post_message` | `channel_id, text` | Post a message |
+| `slack_reply_to_thread` | `channel_id, thread_ts, text` | Reply in a thread |
+| `slack_add_reaction` | `channel_id, timestamp, reaction` | Add a reaction emoji |
+| `slack_get_channel_history` | `channel_id` (opt `limit`) | Get channel history |
+| `slack_get_thread_replies` | `channel_id, thread_ts` | Get thread replies |
+| `slack_list_channels` | opt `limit`, `cursor` | List channels |
+| `slack_get_users` | opt `cursor`, `limit` | List workspace users |
+| `slack_get_user_profile` | `user_id` | Get user profile |
+
+### Use in a new project
+
+```bash
+bun add -D @pome-sh/twin-slack  # or npm i -D / pnpm add -D
+```
+
+In another terminal, boot the twin and seed it:
+
+```bash
+TWIN_AUTH_SECRET=$(openssl rand -hex 32) bunx --package=@pome-sh/twin-slack twin-slack &
+curl -X POST http://127.0.0.1:3333/admin/seed -H 'content-type: application/json' -d '{}'
+```
+
+In tests:
+
+```ts
+import { createSlackTwinApp, openSlackTwinDatabase, SlackDomain, defaultSeedState } from "@pome-sh/twin-slack";
+
+const db = openSlackTwinDatabase(":memory:");
+const domain = new SlackDomain(db);
+domain.seed(defaultSeedState());
+const app = createSlackTwinApp({ db, domain, runId: "my-test" });
+// pass `app.fetch` to fetch-shape clients, e.g. Hono's app.request
+```
+
+### Claude Agent example
+
+`examples/claude-slack-agent.ts` is a runnable end-to-end demo: it asks
+Claude to plan a Slack-flavored task, then drives each tool call via the
+`@modelcontextprotocol/sdk` JSON-RPC client.
+
+```bash
+TWIN_AUTH_SECRET=dev-only-insecure-secret SLACK_DETERMINISTIC_TS=1 bun run dev &
+ANTHROPIC_API_KEY=sk-... bun run agent:claude "Post hello to #general and react :wave:"
+```
+
+### Local commands
+
+```bash
+bun install          # install deps
+bun run seed         # seed the local DB
+bun run dev          # boot the twin on :3333
+bun run smoke        # 12-step end-to-end smoke test
+bun run validate:mcp # JSON-RPC SDK round-trip against /s/<sid>/mcp
+bun run typecheck    # tsc --noEmit
+bun run test         # full vitest run
+bun run test:coverage # coverage gate (lines 90%+, funcs 90%+)
+bun run agent:claude "<task>"   # Claude-driven smoke flow
+```
+
+### Tracing parity
+
+Every `tools/call` reaching `/s/:sid/mcp` produces one recorder event whose
+`request_body` is `{ tool, arguments }` and whose `response_body` is the raw
+domain return — byte-identical to what `POST /s/:sid/mcp/call` records. The
+only intentional difference is `path`. Run `bun run validate:mcp` to
+exercise the MCP wire protocol end-to-end and dump the round-trip.
+
+## Security model
+
+- **Session URL vs state:** `/s/:sid` binds the bearer token to a session id in the URL. A single process uses one SQLite database for all SIDs on that instance (same model as `twin-github`). Do not run unrelated tenants in one twin process.
+- **Provider tokens:** Cloud-issued tokens use `xoxb-pome-<base64url(sid)>_<sig>` (underscore delimiter, matching `twin-github`'s `ghp_pome_*` pattern). Provider tokens act as `login: pome-agent` unless the JWT carries an explicit `login` claim.
+- **Private channels:** Reads (`conversations.history`, `search.messages`, etc.) require channel membership for private / IM / MPIM channels, consistent with writes.
+- **Admin routes:** `/admin/reset` and `/admin/seed` are localhost-only and unauthenticated (intentional for snapshot bootstrap). Bind to `127.0.0.1` in untrusted networks.
+- **Introspection:** `GET /s/:sid/_pome/state` exports the full workspace snapshot to any valid session bearer (debugging only).
+- **Production:** Set `TWIN_AUTH_SECRET` when `NODE_ENV=production`; the dev fallback secret is rejected at startup.
+
+## Runtime contract (for snapshot consumers)
+
+`pome-cloud` builds a Vercel Sandbox snapshot from this package's source. The
+following constraints must hold for that build to succeed and for the resulting
+snapshot to boot. Changing any of these is a breaking change for hosted; coordinate
+via a cross-repo PR.
+
+### Build
+
+- Package is `npm install`-able from `package.json` alone (no `workspace:*`
+  protocols, no bun-only deps; no committed lockfile is required, the snapshot
+  build regenerates one on each rebuild). The shared-types `workspace:*` is
+  rewritten to `file:./vendor/shared-types` inside the sandbox build.
+- `npm run build` exits 0 and emits `dist/src/server.js`
+- Built output is loadable under Node 22 — the snapshot runs `runtime: "node22"`.
+
+### Runtime
+
+- Server entry: `node dist/src/server.js` (cwd = package root)
+- Listens on `:3333`
+- Honors `SLACK_CLONE_HOST=0.0.0.0` env (default `127.0.0.1` is unreachable
+  via Vercel Sandbox port forwarding)
+- `GET /healthz` returns 200 within ~3s of process start (the snapshot build
+  sleeps 3s after `node dist/src/server.js` before probing)
+- All admin routes are localhost-only (`/admin/*`)
+- Bearer auth at `Authorization: Bearer <jwt>` per `src/auth.ts`
+
+### Env
+
+- `PORT` — listen port (default `3333`).
+- `SLACK_CLONE_HOST` — bind host (default `127.0.0.1`; set `0.0.0.0` in sandbox).
+- `SLACK_CLONE_DB` — sqlite path (default `:memory:` for tests, `.slack_clone/slack.db` for dev).
+- `POME_SEED_JSON` — JSON seed. Accepts flat shape or `{slack:{seed:…}}` envelope.
+- `TWIN_AUTH_SECRET` — HMAC secret for JWT + provider tokens. Required in production.
+- `POME_RUN_ID` — recorder correlation id (default `spawn`).
+- `SLACK_DETERMINISTIC_TS` — set to `1` for deterministic message timestamps in tests.
+
+### Cross-repo coordination
+
+- Bumping any of the above = open a cross-repo PR (this repo + `pome-cloud`)
+- The cloud-side snapshot build script lives at
+  `pome-cloud/notes/build-twin-slack-template.ts`
+- The snapshot manifest at `pome-cloud/infra/twin-slack-snapshot.json`
+  records the OSS git sha each snapshot was built from

package/node_modules/@pome-sh/twin-slack/dist/examples/claude-slack-agent.d.ts

@@ -0,0 +1 @@
+export {};