Merge branch 'main' into posthog-code/channel-rename-delete-task-sync

Author: adamleithp

.claude/skills/merging-prs/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: merging-prs
+description: Merge a PR into main through the Trunk merge queue and babysit it until it lands. Enqueue with a "/trunk merge" comment, then poll the "Trunk Merge Queue" check run and the PR state until it is MERGED or FAILED, reporting the Trunk bot's failure reason if the PR is kicked out. Use when asked to merge a PR, "merge when ready", "land it", "ship it", or to babysit/watch a PR through the queue. Never use `gh pr merge` in this repo -- the queue is the only path into main.
+allowed-tools: Bash(gh pr view:*), Bash(gh pr checks:*), Bash(gh pr comment:*), Bash(gh pr ready:*), Bash(gh api:*), Bash(sleep:*)
+---
+
+# Merge a PR through the Trunk merge queue
+
+Merges into `main` go **exclusively** through the [Trunk](https://trunk.io) merge
+queue. `gh pr merge` and the GitHub merge button are blocked by branch ruleset.
+To merge, you enqueue the PR with a comment, then watch it until Trunk lands it.
+
+When a developer says "merge this PR", "merge it when it's ready", "land it",
+"ship it", or "babysit this PR", do the full loop below — enqueue **and** watch
+to completion, reporting the outcome. See also [docs/merge-queue.md](../../../docs/merge-queue.md).
+
+`<n>` below is the PR number. Resolve the repo slug once if you need it:
+`REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)`.
+
+## 1. Preflight
+
+```bash
+gh pr view <n> --json state,isDraft,mergeable,reviewDecision,statusCheckRollup
+```
+
+- **Not open** (already merged/closed) → report and stop.
+- **Draft** → it can't be merged. Ask the developer to confirm, then
+  `gh pr ready <n>` before continuing. Don't un-draft silently.
+- **Failing required checks** (`statusCheckRollup`) → the queue will just reject
+  it. Report which checks are red and stop; fix them first. **Pending** checks
+  are fine — the queue waits for them.
+- **Merge conflicts** (`mergeable == "CONFLICTING"`) → report and stop; rebase first.
+
+## 2. Enqueue
+
+```bash
+gh pr comment <n> --body "/trunk merge"
+```
+
+Within ~2 minutes, confirm Trunk picked it up — a check run whose name starts
+with `Trunk Merge Queue` should appear on the head commit:
+
+```bash
+SHA=$(gh pr view <n> --json headRefOid -q .headRefOid)
+gh api repos/$REPO/commits/$SHA/check-runs \
+  --jq '.check_runs[] | select(.name | startswith("Trunk Merge Queue")) | {name, status, conclusion, details_url}'
+```
+
+If nothing appears after a couple of minutes, the developer may lack write
+access or GitHub-comment commands may be disabled — report that and suggest the
+`trunk-merge-queue-submit` label as a fallback.
+
+## 3. Poll until it lands
+
+Loop about every 60 seconds, up to ~45–60 minutes total. Each iteration:
+
+```bash
+gh pr view <n> --json state,mergedAt          # MERGED  -> success, stop
+SHA=$(gh pr view <n> --json headRefOid -q .headRefOid)
+gh api repos/$REPO/commits/$SHA/check-runs \
+  --jq '.check_runs[] | select(.name | startswith("Trunk Merge Queue")) | {status, conclusion, details_url}'
+sleep 60
+```
+
+- `state == "MERGED"` → done. Report success with the merge commit.
+- Check run `status` moves `queued` → `in_progress` → `completed`. Report each
+  transition so the developer can follow along.
+- Watch the **check run + PR state**, not `gh pr checks --watch`: the queue runs
+  CI on Trunk's own draft/`trunk-merge/**` branch, so this PR's own checks don't
+  reflect the queue's testing.
+- Stop at the timeout with a status summary rather than looping forever.
+
+## 4. Handle failure
+
+If the check run completes with `conclusion == "failure"` (or the PR drops out
+of the queue), Trunk kicks the PR and its bot comments with the failing
+workflow. Read the newest comments and report the reason:
+
+```bash
+gh pr view <n> --comments | tail -n 40
+```
+
+- If the failure is clearly caused by this PR **and** the fix is obvious, fix it,
+  push, wait for the PR's own checks to go green, and re-enqueue **once** with
+  `/trunk merge`.
+- Otherwise stop and report the failure and the workflow link. Don't repeatedly
+  re-enqueue a red PR.
+
+## 5. Cancel
+
+If the developer asks to stop the merge:
+
+```bash
+gh pr comment <n> --body "/trunk cancel"
+```
+
+Confirm the check run reports cancelled.
+
+## Hard rules
+
+- **Never** run `gh pr merge` — it's blocked and it's not how this repo merges.
+- **Never** force-push a branch while it is in the queue — it removes the PR
+  from the queue.
+- Re-enqueue a failed PR **at most once** automatically; beyond that, hand back
+  to the developer.

.claude/skills/quill-code/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: quill-code
+description: Edit the @posthog/quill design system locally and consume the change in this repo (posthog-code) before it is published to npm. Use when changing quill components/primitives/tokens, when a quill change must be tested inside the Code app, or when the user mentions quill, the design system, the .local-quill tarball, or the @posthog/quill pnpm override.
+---
+
+# quill-code
+
+`@posthog/quill` is **not** in this repo. It is a published catalog dependency whose
+source lives in the main PostHog monorepo at `../posthog/packages/quill`. To test an
+unpublished quill change inside this repo (posthog-code), you build quill, pack it to a
+tarball, and point a pnpm `overrides` entry at that tarball. This is a **temporary
+local-dev** state — revert before merging (see below).
+
+## Quill layout (where to edit)
+
+`../posthog/packages/quill` is the **workspace** (`@posthog/quill-workspace`). It
+contains sub-packages, each a layer of the design system:
+
+- `packages/primitives/src` — base components (Card, Badge, Button, Progress, …)
+- `packages/components/src` — composed components (DataTable, DateTimePicker, Metric)
+- `packages/blocks/src` — **product-level blocks** (e.g. `ExperimentCard`). Add the
+  file here and export it from `packages/blocks/src/index.ts`.
+- `packages/quill/src` — the **aggregate** that re-exports all layers as `@posthog/quill`.
+
+A new export in any sub-package flows to `@posthog/quill` automatically on build.
+
+## The loop (every quill change)
+
+1. Edit/add the component in the right sub-package (above) and export it from that
+   package's `src/index.ts`.
+2. Re-sync into this repo:
+
+   ```bash
+   .claude/skills/quill-code/scripts/sync-quill.sh
+   ```
+
+   This builds the **whole quill workspace** (recursive `pnpm build` at the workspace
+   root — it rebuilds the sub-packages BEFORE the aggregate bundles them), packs it
+   into `.local-quill/` as a content-hashed `posthog-quill-local-<hash>.tgz`, rewrites
+   the override line in `pnpm-workspace.yaml`, deletes stale tarballs, and runs
+   `pnpm install`.
+
+   > Building only the aggregate (`packages/quill/packages/quill`) re-bundles the
+   > sub-packages' **stale** `dist/`, so edits to primitives/components/blocks are
+   > silently dropped. Always build at the workspace root — the script does this.
+3. Verify in the Code app (`pnpm dev`, or the `test-electron-app` skill). Repeat from 1.
+
+After every quill edit you **must** re-run the sync — the app consumes the tarball, not
+the quill source, so unsynced edits are invisible here.
+
+If quill lives elsewhere, set `QUILL_DIR=/abs/path/to/posthog/packages/quill/packages/quill`.
+
+## Why a tarball, not `link:`
+
+`link:` symlinks into the mono's `node_modules` and drags in its **React 18** types,
+colliding with this repo's **React 19** (dual-React → broken typecheck +
+invalid-hook-call at runtime). The tarball is copied into this repo's store and deduped
+against React 19. The filename is **content-hashed** because pnpm pins a tarball by
+integrity, so a stable filename gets cached stale across re-syncs.
+
+## The override (what the script rewrites)
+
+In `pnpm-workspace.yaml`, under `overrides:`:
+
+```yaml
+'@posthog/quill': file:./.local-quill/posthog-quill-local-<hash>.tgz
+```
+
+There is also a permanent pin you should leave alone:
+
+```yaml
+'@posthog/quill>@base-ui/react': ^1.3.0   # quill ships a broken catalog: dep; do not remove
+```
+
+## Reverting (before merge)
+
+The override is local-dev only. Once the quill change is published to npm:
+
+1. Bump the catalog version in `pnpm-workspace.yaml` (`'@posthog/quill': 0.3.0-beta.x`)
+   to the published version.
+2. Restore the override line to point back at the catalog, or remove the `file:` override.
+3. `pnpm install`.
+
+Do not commit a `file:./.local-quill/...` override or the `.local-quill/` tarballs.

.claude/skills/quill-code/scripts/sync-quill.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+# Build local @posthog/quill, pack it to a content-hashed tarball, point the
+# pnpm override at it, and reinstall. See SKILL.md for the why.
+set -euo pipefail
+
+# code repo root = dir containing pnpm-workspace.yaml, walking up from this script
+CODE_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && while [ ! -f pnpm-workspace.yaml ] && [ "$PWD" != / ]; do cd ..; done && pwd)"
+[ -f "$CODE_ROOT/pnpm-workspace.yaml" ] || { echo "could not find pnpm-workspace.yaml above $0" >&2; exit 1; }
+
+QUILL_DIR="${QUILL_DIR:-$CODE_ROOT/../posthog/packages/quill/packages/quill}"
+[ -d "$QUILL_DIR" ] || { echo "quill source not found: $QUILL_DIR (set QUILL_DIR=...)" >&2; exit 1; }
+
+# The quill workspace root (@posthog/quill-workspace) is two levels up from the
+# aggregate package. We MUST build there: its `pnpm build` runs the recursive
+# `pnpm -r --filter '@posthog/quill-*' --filter '@posthog/quill' build`, which
+# rebuilds the sub-packages (primitives, components, blocks, ...) BEFORE the
+# aggregate bundles them. Building inside QUILL_DIR alone only re-bundles the
+# sub-packages' STALE dist, so edits to blocks/primitives/etc. are silently lost.
+QUILL_WS="${QUILL_WS:-$(cd "$QUILL_DIR/../.." && pwd)}"
+
+DEST="$CODE_ROOT/.local-quill"
+WS="$CODE_ROOT/pnpm-workspace.yaml"
+
+echo "==> building quill workspace in $QUILL_WS"
+( cd "$QUILL_WS" && pnpm build )
+
+echo "==> packing tarball -> $DEST"
+mkdir -p "$DEST"
+( cd "$QUILL_DIR" && npm pack --pack-destination "$DEST" >/dev/null )
+
+RAW="$(ls -t "$DEST"/posthog-quill-*.tgz | grep -v -- '-local-' | head -1)"
+[ -n "$RAW" ] || { echo "npm pack produced no posthog-quill-*.tgz" >&2; exit 1; }
+
+HASH="$(md5 -q "$RAW" | cut -c1-8)"
+HASHED="posthog-quill-local-$HASH.tgz"
+cp "$RAW" "$DEST/$HASHED"
+rm -f "$RAW"
+# drop stale local tarballs so the pnpm store can't resolve an old integrity
+find "$DEST" -name 'posthog-quill-local-*.tgz' ! -name "$HASHED" -delete
+
+echo "==> pointing override at .local-quill/$HASHED"
+# single override line: '@posthog/quill': file:./.local-quill/...
+sed -i '' -E "s#('@posthog/quill': file:\./\.local-quill/)[^']*#\1$HASHED#" "$WS"
+grep -q "$HASHED" "$WS" || { echo "failed to rewrite override line in $WS" >&2; exit 1; }
+
+echo "==> pnpm install"
+( cd "$CODE_ROOT" && pnpm install )
+
+echo "==> done. @posthog/quill now resolves to .local-quill/$HASHED"

.github/workflows/code-release.yml

@@ -196,6 +196,16 @@ jobs:
             echo "OK: $bin"
           done
 
+          # The native codex CLI must ship as a sibling of codex-acp, or the
+          # app-server harness silently falls back to codex-acp in production.
+          for f in codex rg; do
+            if [[ ! -f "$RESOURCES/app.asar.unpacked/.vite/build/codex-acp/$f" ]]; then
+              echo "FAIL: codex-acp/$f missing in bundled binaries"
+              exit 1
+            fi
+            echo "OK: codex-acp/$f"
+          done
+
       - name: Install Playwright
         run: pnpm --filter code exec playwright install