kimaki 0.20.1 → 0.22.0

package/skills/egaki/SKILL.md

@@ -1,43 +1,45 @@
 ---
 name: egaki
+repo: remorses/egaki
 description: >
-  AI image and video generation CLI. Use this skill to install egaki, configure
-  auth, run help commands, and generate images or videos with provider keys or
-  an Egaki subscription.
+  AI image and video generation CLI and MDX-to-video framework built on Remotion.
+  Use this skill to install egaki, configure auth, generate images/videos, create
+  MDX video projects with animation primitives (Opacity, Scale, TranslateX, Blur),
+  easing presets (EASE, springFromDuration, dspring, cubicBezier), LayoutTransition,
+  captions, voice cloning, TTS, Server components, and media components. ALWAYS load
+  this skill when the user mentions egaki, runs egaki commands, edits egaki MDX video
+  files, or works in a project with an egaki vite plugin.
 ---
 
 # egaki
 
-Generate AI images and videos from the terminal.
-Use this for text-to-image, image editing, mask-based edits, text-to-video,
-image-to-video, and model discovery.
-
-## Install
+Every time you work with egaki, you MUST fetch the latest README:
 
 ```bash
-pnpm add -g egaki
+curl -s https://raw.githubusercontent.com/remorses/egaki/main/README.md # NEVER pipe to head/tail, read the full output
 ```
 
-## Always check help first
+The README is the single source of truth for all user-facing docs: CLI usage,
+MDX video syntax, animation primitives, easing presets, LayoutTransition,
+captions, voice cloning, media components, CSS rules, and project setup.
 
-Run the full help output before using commands:
+## Always check help first
 
 ```bash
-egaki --help
+egaki --help # NEVER pipe to head/tail, read the full output
 ```
 
-Do not truncate help output with `head`.
-
-For subcommand details: `egaki <command> --help` (e.g. `egaki image --help`, `egaki video --help`, `egaki login --help`)
+For subcommand details: `egaki <command> --help` (e.g. `egaki image --help`,
+`egaki video --help`, `egaki login --help`)
 
 ## Auth options
 
-You can authenticate in two ways:
+Two authentication modes:
 
-1. Egaki subscription key (recommended — all models, one key)
-2. Provider API keys (Google, OpenAI, Fal, Replicate) via `egaki login`
+1. **Egaki subscription key** (recommended, all models, one key)
+2. **Provider API keys** (Google, OpenAI, Fal, xAI, etc.) via `egaki login`
 
-If using Egaki subscription, set it up first with `egaki subscribe`, then store
+If using Egaki subscription, set it up with `egaki subscribe`, then store
 the key with `egaki login --provider egaki --key egaki_...`.
 
 ## Login behavior for remote agents
@@ -49,78 +51,22 @@ to the user so they can complete auth interactively.
 
 The `--model` / `-m` flag is **optional** on both `egaki image` and `egaki video`.
 
-- **Interactive (TTY):** omitting `--model` shows a picker with popular models
-- **Non-interactive (piped/scripted):** omitting `--model` uses a sensible default
+- **Interactive (TTY):** omitting `--model` shows a picker
+- **Non-interactive (piped/scripted):** uses a sensible default
 
 Agents should always pass `-m` explicitly to avoid the interactive picker.
 
 ### Preferred image models
 
-When the user does not specify a model, prefer these in order:
-
 1. **`gpt-image-1`** (or `gpt-image-2` / `chatgpt-image-latest` if available)
 2. **`grok-imagine-image`** (xAI Grok)
 3. **`nano-banana-pro-preview`**
 
-Always try the first available model. Fall back to the next if auth is missing
-for the preferred one.
-
 ### Preferred video models
 
-When the user does not specify a video model, prefer:
-
 1. **`grok-imagine-video-1.5`** (xAI Grok)
 
-## Example commands
-
-```bash
-# configure key interactively
-egaki login
-
-# show login status
-egaki login --show
-
-# subscribe to Egaki for all supported models
-egaki subscribe
-
-# check subscription usage
-egaki usage
-
-# generate an image (interactive model picker if TTY)
-egaki image "a watercolor fox reading a map" -o fox.png
-
-# select a model explicitly
-egaki image "isometric floating city, soft colors" -m imagen-4.0-generate-001 -o city.png
-
-# edit an existing image (local file or URL)
-egaki image "add a red scarf and make it winter" --input portrait.jpg -o portrait-winter.png
-egaki image "turn this into a manga panel" --input https://example.com/photo.jpg -o manga.png
-
-# inpainting with a mask
-egaki image "replace the sky with a dramatic sunset" --input scene.png --mask mask.png -o scene-sunset.png
-
-# generate a video — use a 5 minute timeout, video generation is slow
-egaki video "a paper boat drifting on a calm lake at sunrise" -o boat.mp4
-
-# generate a video with a specific model
-egaki video "timelapse of a stormy sea, cinematic" -m google/veo-3.1-fast-generate-001 --duration 6 -o storm.mp4
-
-# cheap video model
-egaki video "a cat walking on a rooftop at night" -m klingai/kling-v2.5-turbo-t2v --duration 5 -o cat.mp4
-
-# image-to-video (model must support i2v)
-egaki video "slowly animate the clouds" --input photo.jpg -m klingai/kling-v2.6-i2v -o animated.mp4
-
-# discover all models (image + video)
-egaki models
-
-# filter by type
-egaki models --type video
-egaki models --type image
-```
-
-## Video generation note for agents
+## Video generation note
 
-Video generation can be very slow — some models take 1–3 minutes per request.
-Always use a command timeout of **at least 5 minutes** when invoking `egaki video`
-from automation or agent workflows.
+Video generation can be very slow (1-3 minutes per request). Always use a
+command timeout of **at least 5 minutes** from automation or agent workflows.

package/skills/goke/SKILL.md

@@ -85,34 +85,39 @@ Supported agents: `cursor`, `claude`, `devin`, `replit`, `gemini`, `codex`, `aug
 
 ## Long-Running Interactive Commands
 
-Commands that start a browser/device login flow or any other long-running TTY-only interaction must fail fast in non-TTY shells. Do not start the flow and hope the agent notices the URL. The process must stay alive while the user approves the browser prompt, so agents need to launch it in a persistent terminal session like tuistory or tmux.
+Commands that start a browser/device login flow need to work for both interactive users and AI agents. goke's built-in **daemon** pattern (`ctx.daemon`) handles this: the command forks itself into a background process that waits for browser approval, while the foreground returns immediately so agents aren't blocked.
 
-Always guard these commands with `!process.stdout.isTTY` before making network requests, opening the browser, or starting spinners. Do not fail just because an agent is running the command if the command has a real TTY.
+Use `isAgent` to branch between agent mode (start daemon, return immediately) and interactive mode (block until login completes). Do not fail in non-TTY shells; use the daemon instead.
 
 ```ts
-import dedent from 'string-dedent'
-import { goke } from 'goke'
-
-cli.command('login', 'Authenticate with browser login').action((options, { console, process }) => {
-  if (!process.stdout.isTTY) {
-    console.error(dedent`
-      mycli login needs an interactive terminal and must stay alive while you approve the browser login.
-
-      Run it in a background terminal session like tuistory or tmux, then wait for the URL/code:
+import { goke, isAgent, openInBrowser } from 'goke'
 
-        bunx tuistory launch "mycli login" -s mycli-login
-        bunx tuistory -s mycli-login wait "/code:|https?:\\/\\//i" --timeout 15000
+cli
+  .command('login', 'Authenticate with browser login')
+  .action(async (options, ctx) => {
+    if (ctx.daemon.isDaemon) {
+      // ── DAEMON: run the long-running flow in background ──
+      const result = await startOAuthFlow({ /* ... */ })
+      if (result.success) saveAuth(result)
+      return // daemon exits, PID file is cleaned up
+    }
 
-      The login command exits by itself after successful browser approval.
-    `)
-    process.exit(1)
-  }
+    // ── CLIENT: decide foreground vs background ──
+    if (isAgent) {
+      // Agent mode: start daemon and return immediately
+      await ctx.daemon.start({ timeoutMs: 10 * 60 * 1000 })
+      ctx.console.log('Login running in background.')
+      ctx.console.log('After approving in browser, verify with: mycli me')
+      return
+    }
 
-  // Start device/browser login only after the guard.
-})
+    // Interactive mode: attach to daemon, see all its logs and errors in real time
+    await ctx.daemon.start({ attach: true, timeoutMs: 10 * 60 * 1000 })
+    ctx.console.log('Login successful!')
+  })
 ```
 
-Use `tuistory wait` for the handoff point that needs user interaction. It returns nearby lines around the match, so agents can show the URL/code without a separate `tuistory read` call. Do not add `tuistory close` to login instructions when the CLI exits by itself after success.
+Add a `me` command (exits 0 if logged in, 1 if not) so agents can poll for completion. Use `ctx.daemon.forCommand('login')` to check the login daemon status from other commands. See the **Background Daemons** section in the goke README for the full pattern, including `env` passthrough and PID file safety.
 
 ## Shell Completions
 
@@ -398,6 +403,8 @@ cli
 
 CLIs that talk to a remote server must support multiple server URLs so users can self-host, use a preview/staging environment, or point to localhost during development. Auth tokens and other per-server state live in a JSON config file keyed by API URL.
 
+**Never log config file paths** (like `~/.myapp/config.json` or `~/.myapp/auth.json`) in CLI output. Agents read CLI output and will try to `cat` or parse these files directly, bypassing the CLI's own commands. Log success/failure messages without revealing internal storage paths.
+
 ### Config file location
 
 Store config at `~/.cliname/config.json`. The directory is named after the CLI binary. Use `os.homedir()` to resolve `~`.

package/skills/holocron/SKILL.md

@@ -44,6 +44,7 @@ When the user asks about a specific workflow, fetch the matching page directly:
 - **Holocron deploy**: https://holocron.so/docs/deploy/holocron.md
 - **AI assistant docs**: https://holocron.so/docs/ai/assistant.md
 - **Bleed**: https://holocron.so/docs/customize/bleed.md
+- **Layout and page modes**: https://holocron.so/docs/customize/layout.md
 
 ```bash
 curl -fsSL https://holocron.so/docs/quickstart.md
@@ -55,7 +56,7 @@ curl -fsSL https://holocron.so/docs/organize/docs-json.md
 Use the CLI to create a new docs site with a working template:
 
 ```bash
-npx -y @holocron.so/cli create --name "My Docs" my-docs --skip-auth
+npx -y "@holocron.so/cli" create --name "My Docs" my-docs --skip-auth
 ```
 
 The `--skip-auth` flag skips cloud setup & AI chat setup (suitable for agents and local-only
@@ -357,6 +358,22 @@ Sidebar: `Home`
 - **Every `title` MUST be unique across the site.**
 - **`index.mdx` MUST use `sidebarTitle: Home`** (or `Overview`) and a descriptive `title`.
 
+## Page modes — hiding sidebars
+
+Set **`mode`** in frontmatter to hide sidebars. Use for landing pages, tool pages, or pages that should not show left nav or AI chat. See https://holocron.so/docs/customize/layout.md for details.
+
+- **`center`** — hides the left nav, centers content. Right aside still works.
+- **`custom`** — hides both sidebars and the editorial grid. Only navbar, tab bar, and footer remain. See `example/src/landing.mdx` for a full example.
+
+In both modes the content can feel too wide. Use **`maxWidth`** to constrain it:
+
+```yaml
+---
+mode: "custom"
+maxWidth: 700
+---
+```
+
 ## Custom entry (mounting docs inside a Spiceflow app)
 
 When the site mounts Holocron inside an existing **Spiceflow** app (the `entry`
@@ -402,6 +419,23 @@ the **`knownPaths`** field in `docs.json` to tell Holocron these paths are valid
 Wildcards only work as a trailing `/*` suffix. Glob patterns like `/api/*/users`
 are not supported.
 
+## Vertical spacing inside wrappers
+
+When wrapping MDX content in a `<div>` or custom component, add
+`flex flex-col gap-(--prose-gap)` so children get correct vertical spacing.
+Without it, elements collapse together. Add `no-bleed` too if the wrapper
+contains images or code blocks that shouldn't escape its bounds.
+
+```mdx
+<div className='no-bleed flex flex-col gap-(--prose-gap)'>
+
+First paragraph.
+
+Second paragraph with correct spacing above.
+
+</div>
+```
+
 ## MDX container components
 
 Always use multi-line form for container components like `Callout`, `Note`,
@@ -505,7 +539,7 @@ section above.
 Run `--help` to see all available commands. Never truncate the output.
 
 ```bash
-npx -y @holocron.so/cli --help
+npx -y "@holocron.so/cli" --help
 ```
 
 Key commands: `login`, `logout`, `whoami`, `deploy`, `projects list`,
@@ -514,19 +548,26 @@ Key commands: `login`, `logout`, `whoami`, `deploy`, `projects list`,
 Before logging in, always check if the user is already authenticated:
 
 ```bash
-npx -y @holocron.so/cli whoami
+npx -y "@holocron.so/cli" whoami
 ```
 
 If `whoami` succeeds and shows user, orgs, and projects, skip login. Only run
-`npx -y @holocron.so/cli login` if `whoami` fails.
+`npx -y "@holocron.so/cli" login` if `whoami` fails.
 
 ## Deploy
 
+When the user asks to "deploy the site", they may mean deploying with their own
+script and platform (Cloudflare Workers, a Node server, CI pipeline), not
+`holocron deploy`. Check `package.json` scripts first: if there is a `deploy`,
+`deployment`, or similar script (e.g. wrangler deploy), use that instead of the
+Holocron CLI. Only use `holocron deploy` when the project has no own deploy
+script or the user explicitly asks for holocron.so hosting.
+
 `holocron deploy` builds the docs site and uploads it to holocron.so hosting.
 It is the fastest way to publish without managing your own server.
 
 ```bash
-npx -y @holocron.so/cli deploy
+npx -y "@holocron.so/cli" deploy
 ```
 
 The command runs the build, uploads only changed files, finalizes the deployment,
@@ -606,7 +647,7 @@ Use ASCII diagrams frequently in MDX pages. Always use the **`diagram`** languag
 - Never exceed 94 characters per line.
 - Prefer a **varied, organic layout**. Mix plain text labels, boxes for major components, and directional arrows.
 - All connections must use **directional arrows**. Never use plain lines without an arrowhead.
-- Verify alignment by running `npx -y @holocron.so/cli diagrams fix <file>` (see dedicated section below).
+- Verify alignment by running `npx -y "@holocron.so/cli" diagrams fix <file>` (see dedicated section below).
 
 ````mdx
 ```diagram
@@ -632,7 +673,7 @@ docs.jsonc ───►│  Vite Plugin  │──────► Build Output
 LLMs cannot count characters reliably. Every time you create or edit a diagram in an MDX page, you **must** run the alignment fixer before committing. This is not optional.
 
 ```bash
-npx -y @holocron.so/cli diagrams fix path/to/file.mdx
+npx -y "@holocron.so/cli" diagrams fix path/to/file.mdx
 ```
 
 The command:
@@ -664,6 +705,29 @@ Accordion apply `no-bleed` automatically to keep descendants inside their frame.
 
 See https://holocron.so/docs/customize/bleed.md for the full reference.
 
+## Custom CSS — prefer CSS variables over class selectors
+
+When customizing the look of a Holocron site, **always use CSS variable overrides** in `:root` instead of targeting internal class names, DOM structure, or aria labels. Holocron exposes a set of documented CSS variables for colors, typography, spacing, code blocks, blockquotes, and sidebar navigation. These are stable across Holocron updates; internal markup is not.
+
+```css
+/* style.css */
+:root {
+  --weight-heading: 700;
+  --code-block-background: var(--muted);
+  --code-block-border: 1px solid var(--border-subtle);
+  --sidebar-link-radius: var(--radius-sm);
+  --blockquote-border-color: var(--border-subtle);
+}
+```
+
+Fetch the full list of available tokens:
+
+```bash
+curl -fsSL https://holocron.so/docs/customize/theme.md
+```
+
+If a user wants to customize something that has no CSS variable, **do not hack it with fragile selectors**. Instead, open an issue on the Holocron repo (https://github.com/remorses/holocron/issues) requesting a new CSS variable for that use case. Holocron actively adds new variables based on user needs. Internal selectors like `.slot-sidebar-left nav > div:first-child > a` or `figure[class~='group/code'] button[aria-label='Copy code']` will break on any refactor and should never be used.
+
 ## Agent rules
 
 - **Always place MDX pages inside the Holocron `pagesDir`.** Before creating or
@@ -677,7 +741,7 @@ See https://holocron.so/docs/customize/bleed.md for the full reference.
 - All ASCII diagrams in MDX pages must use the `diagram` language hint on the
   code fence (` ```diagram `). This renders them with proper styling on the
   website instead of plain monospace.
-- After creating or editing any diagram, run `npx -y @holocron.so/cli diagrams fix <file>`
+- After creating or editing any diagram, run `npx -y "@holocron.so/cli" diagrams fix <file>`
   to auto-fix alignment. LLMs cannot count characters reliably.
 - Never pipe curl or `--help` output through `head`, `tail`, or any truncation
   command. Always read the full output.

package/skills/new-skill/SKILL.md

@@ -62,6 +62,93 @@ Claude Code, Cursor, Windsurf, and others. Skills teach agents the
 workflows, patterns, and tools specific to this project.
 ```
 
+## Making a skill installable from a URL
+
+Use this when the project does **not have a public GitHub repo** (private repos, closed-source SaaS products) or when you want the install command to use your own domain:
+
+```bash
+npx skills add https://example.com
+```
+
+The `skills` CLI treats any non-GitHub/GitLab HTTP(S) URL as a **well-known discovery endpoint** (RFC 8615). It fetches `/.well-known/agent-skills/index.json` and expects the v0.2.0 discovery schema:
+
+```json
+{
+  "$schema": "https://schemas.agentskills.io/discovery/0.2.0/schema.json",
+  "skills": [
+    {
+      "name": "my-skill",
+      "type": "skill-md",
+      "description": "One-line description shown in the CLI skill picker.",
+      "url": "./my-skill/SKILL.md",
+      "digest": "sha256:<hex sha256 of the exact artifact bytes>"
+    }
+  ]
+}
+```
+
+Rules:
+
+- **The digest must match the served bytes exactly.** The CLI downloads the artifact from `url` and verifies its sha256 before installing. Never hardcode the digest; compute it from the same string you serve.
+- **`url` is resolved relative to index.json**, so `./my-skill/SKILL.md` works and survives domain changes. Absolute URLs also work.
+- **`name` must be kebab-case** (`^[a-z0-9-]+$`, no leading/trailing/double dashes) and match the SKILL.md frontmatter name.
+- `type: "skill-md"` serves a single markdown file. Use `type: "archive"` (zip or tar.gz with a root SKILL.md) only when the skill ships companion files.
+- Keep the canonical SKILL.md in the repo (`skills/<name>/SKILL.md`) and serve those exact bytes, so the published skill can never drift from git.
+
+Example with **spiceflow** on Cloudflare Workers: import the SKILL.md with vite `?raw` and compute the digest once per isolate with WebCrypto.
+
+```ts
+import { Spiceflow } from 'spiceflow'
+import skillMd from '../../skills/my-skill/SKILL.md?raw'
+
+let digestPromise: Promise<string> | undefined
+function getSkillDigest(): Promise<string> {
+  digestPromise ??= (async () => {
+    const bytes = new TextEncoder().encode(skillMd)
+    const hash = await crypto.subtle.digest('SHA-256', bytes)
+    const hex = Array.from(new Uint8Array(hash), (b) => b.toString(16).padStart(2, '0')).join('')
+    return `sha256:${hex}`
+  })()
+  return digestPromise
+}
+
+export const skillDiscoveryApp = new Spiceflow()
+  .route({
+    method: 'GET',
+    path: '/.well-known/agent-skills/index.json',
+    handler: async () =>
+      Response.json({
+        $schema: 'https://schemas.agentskills.io/discovery/0.2.0/schema.json',
+        skills: [
+          {
+            name: 'my-skill',
+            type: 'skill-md',
+            description: 'One-line description shown in the CLI skill picker.',
+            url: './my-skill/SKILL.md',
+            digest: await getSkillDigest(),
+          },
+        ],
+      }),
+  })
+  .route({
+    method: 'GET',
+    path: '/.well-known/agent-skills/my-skill/SKILL.md',
+    handler: () =>
+      new Response(skillMd, {
+        headers: { 'content-type': 'text/markdown; charset=utf-8' },
+      }),
+  })
+```
+
+Validate end-to-end against a local dev server before deploying:
+
+```bash
+npx skills add http://localhost:3000 --list
+npx skills add http://localhost:3000 -y --copy
+```
+
+If the digest is wrong the CLI silently skips the skill, so an empty `--list` result usually means a digest mismatch.
+
 ## Frontmatter
 
 Every SKILL.md starts with YAML frontmatter containing three required fields:

package/skills/playwriter/SKILL.md

@@ -3,9 +3,9 @@ name: playwriter
 description: Control the user own Chrome browser via Playwriter extension with Playwright code snippets in a stateful local js sandbox. Use this over other Playwright MCPs to automate the browser — it connects to the user's existing Chrome instead of launching a new one. Use this cli for navigating JS-heavy websites (Instagram, Twitter, cookie/login walls, lazy-loaded UIs) instead of webfetch/curl. ALWAYS load this skill before using any playwriter commands
 ---
 
-## REQUIRED: Read Full Documentation First
+## Read Full Documentation (once per session)
 
-**Before using playwriter, you MUST run this command:**
+**Before the first playwriter command in a session, run:**
 
 ```bash
 playwriter skill # IMPORTANT! do not use | head here. read in full!
@@ -19,9 +19,9 @@ This outputs the complete documentation including:
 - Best practices for slow pages and SPAs
 - Context variables, utility functions, and more
 
-**Do NOT skip this step.** The quick examples below will fail without understanding timeouts, selector rules, and common pitfalls from the full docs.
+**Do NOT skip this step.** The examples below will fail without understanding timeouts, selector rules, and pitfalls from the full docs. You only need to do this once per session; subsequent playwriter commands in the same session do not require re-reading.
 
-**Read the ENTIRE output.** Do NOT pipe through `head`, `tail`, or any truncation command. The skill output must be read in its entirety — critical rules about timeouts, selectors, and common pitfalls are spread throughout the document, not just at the top.
+**Read the ENTIRE output.** Do NOT pipe through `head`, `tail`, or any truncation command. Critical rules are spread throughout the document, not just at the top.
 
 ## Minimal Example (after reading full docs)
 

package/skills/spiceflow/SKILL.md

@@ -11,6 +11,8 @@ Every time you work with spiceflow, you MUST fetch the **entire** README from th
 curl -s https://raw.githubusercontent.com/remorses/spiceflow/main/README.md
 ```
 
+If you are about to design any navigation, cookie, redirect, or refresh behavior and you have not fetched the README in this session, stop and fetch it first.
+
 **Do NOT truncate, summarize, or skip sections.** Never pipe to `head`, `tail`, `sed`, or any command that cuts the output short. Never stop reading early because it "looks long enough." The README contains sections on routing, RSC, server actions, layouts, error handling, forms, federation, deployment, and more. Missing any of them means missing framework behavior you will get wrong.
 
 After reading the full README, check if it references any docs/ files relevant to your task. If it does, fetch those too in full:

package/src/agent-model.e2e.test.ts

@@ -710,14 +710,17 @@ describe('agent model resolution', () => {
       await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID))
       await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID))
 
+      const existingThreadIds = new Set(
+        (await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => thread.id),
+      )
       await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
         content: 'Reply with exactly: btw-source-msg',
       })
 
       const sourceThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
         timeout: 4_000,
-        predicate: (t) => {
-          return t.name === 'Reply with exactly: btw-source-msg'
+        predicate: (thread) => {
+          return !existingThreadIds.has(thread.id)
         },
       })
 
@@ -742,14 +745,17 @@ describe('agent model resolution', () => {
         modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
       })
 
+      const existingForkThreadIds = new Set(
+        (await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => thread.id),
+      )
       await discord.thread(sourceThread.id).user(TEST_USER_ID).sendMessage({
         content: 'Reply with exactly: btw-model-check. btw',
       })
 
       const forkedThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
         timeout: 4_000,
-        predicate: (t) => {
-          return t.name === 'btw: Reply with exactly: btw-model-check'
+        predicate: (thread) => {
+          return !existingForkThreadIds.has(thread.id)
         },
       })