chore: release v1.1.0

chore: release v1.0.1
Refactor code structure for improved readability and maintainability
2026-07-12 22:09:48 +08:00 · 2026-01-18 20:11:49 -06:00 · 2026-01-18 19:15:34 -06:00 · 2026-01-18 18:18:54 -06:00 · 2026-01-18 18:00:58 -06:00 · 2026-01-18 17:58:12 -06:00
95 changed files with 8441 additions and 2794 deletions
@@ -6,16 +6,15 @@
  },
  "metadata": {
    "description": "Skills shared by Baoyu for improving daily work efficiency",
-    "version": "0.7.0"
+    "version": "1.1.0"
  },
  "plugins": [
    {
      "name": "content-skills",
-      "description": "Skills shared by Baoyu for improving daily work efficiency",
+      "description": "Content generation and publishing skills",
      "source": "./",
      "strict": false,
      "skills": [
-        "./skills/baoyu-gemini-web",
        "./skills/baoyu-xhs-images",
        "./skills/baoyu-post-to-x",
        "./skills/baoyu-post-to-wechat",
@@ -24,6 +23,25 @@
        "./skills/baoyu-slide-deck",
        "./skills/baoyu-comic"
      ]
+    },
+    {
+      "name": "ai-generation-skills",
+      "description": "AI-powered generation backends",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/baoyu-danger-gemini-web"
+      ]
+    },
+    {
+      "name": "utility-skills",
+      "description": "Utility tools for content processing",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/baoyu-danger-x-to-markdown",
+        "./skills/baoyu-compress-image"
+      ]
    }
  ]
 }
@@ -58,7 +58,24 @@ Default behavior:
 - If changes include `feat:` or new skills → Minor bump
 - Otherwise → Patch bump

-### Step 3: Update Changelogs
+### Step 3: Check and Update README
+
+Before updating changelogs, check if README files need updates based on changes:
+
+**When to update README**:
+- New skills added → Add to skill list
+- Skills removed → Remove from skill list
+- Skill renamed → Update references
+- New features affecting usage → Update usage section
+- Breaking changes → Update migration notes
+
+**Files to sync**:
+- `README.md` (English)
+- `README.zh.md` (Chinese)
+
+If changes include new skills or significant feature changes, update both README files to reflect the new capabilities. Keep both files in sync with the same structure and information.
+
+### Step 4: Update Changelogs

 Files to update:
 - `CHANGELOG.md` (English)
@@ -86,7 +103,7 @@ Only include sections that have changes. Omit empty sections.

 For Chinese changelog, translate the content maintaining the same structure.

-### Step 4: Update marketplace.json
+### Step 5: Update marketplace.json

 Update `.claude-plugin/marketplace.json`:
 ```json
@@ -97,14 +114,16 @@ Update `.claude-plugin/marketplace.json`:
 }
 ```

-### Step 5: Commit Changes
+### Step 6: Commit Changes

 ```bash
-git add CHANGELOG.md CHANGELOG.zh.md .claude-plugin/marketplace.json
+git add README.md README.zh.md CHANGELOG.md CHANGELOG.zh.md .claude-plugin/marketplace.json
 git commit -m "chore: release v{NEW_VERSION}"
 ```

-### Step 6: Create Version Tag
+**Note**: Do NOT add Co-Authored-By line. This is a release commit, not a code contribution.
+
+### Step 7: Create Version Tag

 ```bash
 git tag v{NEW_VERSION}
@@ -150,7 +169,12 @@ Changelog preview (EN):
 ### Fixes
 - `baoyu-bar`: fixed timeout issue

+README updates needed: Yes/No
+(If yes, show proposed changes)
+
 Files to modify:
+- README.md (if updates needed)
+- README.zh.md (if updates needed)
 - CHANGELOG.md
 - CHANGELOG.zh.md
 - .claude-plugin/marketplace.json
@@ -140,3 +140,7 @@ vite.config.ts.timestamp-*
 tests-data/

 .DS_Store
+
+# Skill extensions (user customization)
+.baoyu-skills/
+x-to-markdown/
@@ -2,6 +2,75 @@

 English | [中文](./CHANGELOG.zh.md)

+## 1.1.0 - 2026-01-18
+
+### Features
+- `baoyu-compress-image`: new utility skill for cross-platform image compression. Converts to WebP by default with PNG-to-PNG support. Uses system tools (sips, cwebp, ImageMagick) with Sharp fallback.
+
+### Refactor
+- Marketplace structure: reorganizes plugins into three categories—`content-skills`, `ai-generation-skills`, and `utility-skills`—for better organization.
+
+### Documentation
+- `CLAUDE.md`, `README.md`, `README.zh.md`: updates skill architecture documentation to reflect the new three-category structure.
+
+## 1.0.1 - 2026-01-18
+
+### Refactor
+- Code structure improvements for better readability and maintainability.
+- `baoyu-slide-deck`: unified style reference file formats.
+
+### Other
+- Screenshots: converted from PNG to WebP format for smaller file sizes; added screenshots for new styles.
+
+## 1.0.0 - 2026-01-18
+
+### Features
+- `baoyu-danger-x-to-markdown`: new skill to convert X/Twitter posts and threads to Markdown format.
+
+### Breaking Changes
+- `baoyu-gemini-web` renamed to `baoyu-danger-gemini-web` to indicate potential risks of using reverse-engineered APIs.
+
+## 0.11.0 - 2026-01-18
+
+### Features
+- `baoyu-danger-gemini-web`: adds disclaimer consent check flow—requires user acceptance before first use, with persistent consent storage per platform.
+
+## 0.10.0 - 2026-01-18
+
+### Features
+- `baoyu-slide-deck`: expands style library from 10 to 15 styles with 8 new additions—`dark-atmospheric`, `editorial-infographic`, `fantasy-animation`, `intuition-machine`, `pixel-art`, `scientific`, `vintage`, `watercolor`.
+
+### Breaking Changes
+- `baoyu-slide-deck`: removes 3 styles (`playful`, `storytelling`, `warm`); changes default style from `notion` to `blueprint`.
+
+## 0.9.0 - 2026-01-17
+
+### Features
+- Extension support: all skills now support customization via `EXTEND.md` files. Check `.baoyu-skills/<skill-name>/EXTEND.md` (project) or `~/.baoyu-skills/<skill-name>/EXTEND.md` (user) for custom styles and configurations.
+
+### Other
+- `.gitignore`: adds `.baoyu-skills/` directory for user extension files.
+
+## 0.8.2 - 2026-01-17
+
+### Refactor
+- `baoyu-danger-gemini-web`: reorganizes script architecture—moves modular files into `gemini-webapi/` subdirectory and updates SKILL.md with `${SKILL_DIR}` path references.
+
+## 0.8.1 - 2026-01-17
+
+### Refactor
+- `baoyu-danger-gemini-web`: refactors script architecture—consolidates 10 separate files into a structured `gemini-webapi/` module (TypeScript port of gemini_webapi Python library).
+
+## 0.8.0 - 2026-01-17
+
+### Features
+- `baoyu-xhs-images`: adds content analysis framework (`analysis-framework.md`, `outline-template.md`) for structured content breakdown and outline generation.
+
+### Documentation
+- `CLAUDE.md`: adds Output Path Convention (directory structure, backup rules) and Image Naming Convention (format, slug rules) to standardize image generation outputs.
+- Multiple skills: updates file management conventions to use unified directory structure (`[source-name-no-ext]/<skill-suffix>/`).
+  - `baoyu-article-illustrator`, `baoyu-comic`, `baoyu-cover-image`, `baoyu-slide-deck`, `baoyu-xhs-images`
+
 ## 0.7.0 - 2026-01-17

 ### Features
@@ -20,7 +89,7 @@ English | [中文](./CHANGELOG.zh.md)

 - `baoyu-slide-deck`: adds `scripts/merge-to-pdf.ts` to export generated slides into a single PDF; docs updated with pptx/pdf outputs.
 - `baoyu-comic`: adds `scripts/merge-to-pdf.ts` to merge cover/pages into a PDF; docs clarify character reference handling (image vs text).
- Docs conventions: adds a “Script Directory” template to `CLAUDE.md`; aligns `baoyu-gemini-web` / `baoyu-slide-deck` / `baoyu-comic` docs to use `${SKILL_DIR}` in commands so agents can run scripts from any install location.
+- Docs conventions: adds a “Script Directory” template to `CLAUDE.md`; aligns `baoyu-danger-gemini-web` / `baoyu-slide-deck` / `baoyu-comic` docs to use `${SKILL_DIR}` in commands so agents can run scripts from any install location.

 ## 0.6.0 - 2026-01-17

@@ -35,8 +104,8 @@ English | [中文](./CHANGELOG.zh.md)

 ## 0.5.2 - 2026-01-16

- `baoyu-gemini-web`: adds `--sessionId` (local persisted sessions, plus `--list-sessions`) for multi-turn conversations and consistent multi-image generation.
- `baoyu-gemini-web`: adds `--reference/--ref` for reference images (vision input), plus stronger timeout handling and cookie refresh recovery.
+- `baoyu-danger-gemini-web`: adds `--sessionId` (local persisted sessions, plus `--list-sessions`) for multi-turn conversations and consistent multi-image generation.
+- `baoyu-danger-gemini-web`: adds `--reference/--ref` for reference images (vision input), plus stronger timeout handling and cookie refresh recovery.
 - Docs: `baoyu-xhs-images` / `baoyu-slide-deck` / `baoyu-comic` document session usage (reuse one `sessionId` per set) to improve visual consistency.

 ## 0.5.1 - 2026-01-16
@@ -52,7 +121,7 @@ English | [中文](./CHANGELOG.zh.md)

 ## 0.4.2 - 2026-01-15

- `baoyu-gemini-web`: updates description to clarify it as the image-generation backend for other skills (e.g. `cover-image`, `xhs-images`, `article-illustrator`).
+- `baoyu-danger-gemini-web`: updates description to clarify it as the image-generation backend for other skills (e.g. `cover-image`, `xhs-images`, `article-illustrator`).

 ## 0.4.1 - 2026-01-15

@@ -2,6 +2,75 @@

 [English](./CHANGELOG.md) | 中文

+## 1.1.0 - 2026-01-18
+
+### 新功能
+- `baoyu-compress-image`：新增跨平台图片压缩技能。默认转换为 WebP 格式，支持 PNG 转 PNG。自动选择系统工具（sips、cwebp、ImageMagick），Sharp 作为兜底方案。
+
+### 重构
+- Marketplace 结构重组：将插件分为三大类——`content-skills`（内容技能）、`ai-generation-skills`（AI 生成技能）和 `utility-skills`（工具技能），便于管理和发现。
+
+### 文档
+- `CLAUDE.md`、`README.md`、`README.zh.md`：更新技能架构文档，反映新的三类分组结构。
+
+## 1.0.1 - 2026-01-18
+
+### 重构
+- 代码结构优化，提升可读性和可维护性。
+- `baoyu-slide-deck`：统一风格参考文件格式。
+
+### 其他
+- 截图：从 PNG 转换为 WebP 格式，减小文件体积；新增新风格的截图。
+
+## 1.0.0 - 2026-01-18
+
+### 新功能
+- `baoyu-danger-x-to-markdown`：新增技能，将 X/Twitter 帖子和线程转换为 Markdown 格式。
+
+### 破坏性变更
+- `baoyu-gemini-web` 重命名为 `baoyu-danger-gemini-web`，以提示使用逆向工程 API 的潜在风险。
+
+## 0.11.0 - 2026-01-18
+
+### 新功能
+- `baoyu-danger-gemini-web`：新增 Disclaimer 同意检查流程——首次使用前需用户确认接受，同意状态按平台持久化存储。
+
+## 0.10.0 - 2026-01-18
+
+### 新功能
+- `baoyu-slide-deck`：风格库从 10 个扩展至 15 个，新增 8 种风格——`dark-atmospheric`（暗黑氛围）、`editorial-infographic`（杂志信息图）、`fantasy-animation`（奇幻动画）、`intuition-machine`（技术简报）、`pixel-art`（像素艺术）、`scientific`（科学图解）、`vintage`（复古文献）、`watercolor`（水彩手绘）。
+
+### 破坏性变更
+- `baoyu-slide-deck`：移除 3 种风格（`playful`、`storytelling`、`warm`）；默认风格从 `notion` 改为 `blueprint`。
+
+## 0.9.0 - 2026-01-17
+
+### 新功能
+- 扩展支持：所有技能现支持通过 `EXTEND.md` 文件自定义。检查 `.baoyu-skills/<skill-name>/EXTEND.md`（项目级）或 `~/.baoyu-skills/<skill-name>/EXTEND.md`（用户级）配置自定义样式与设置。
+
+### 其他
+- `.gitignore`：添加 `.baoyu-skills/` 目录忽略，存放用户扩展文件。
+
+## 0.8.2 - 2026-01-17
+
+### 重构
+- `baoyu-danger-gemini-web`：重组脚本架构——将模块文件移至 `gemini-webapi/` 子目录，并更新 SKILL.md 使用 `${SKILL_DIR}` 路径引用。
+
+## 0.8.1 - 2026-01-17
+
+### 重构
+- `baoyu-danger-gemini-web`：重构脚本架构——将 10 个分散的脚本文件整合为结构化的 `gemini-webapi/` 模块（gemini_webapi Python 库的 TypeScript 移植版）。
+
+## 0.8.0 - 2026-01-17
+
+### 新功能
+- `baoyu-xhs-images`：新增内容分析框架（`analysis-framework.md`、`outline-template.md`），提供结构化内容拆解与大纲生成方案。
+
+### 文档
+- `CLAUDE.md`：新增 Output Path Convention（目录结构、备份规则）和 Image Naming Convention（文件命名格式、slug 规则），统一图片生成输出规范。
+- 多个技能：更新文件管理规范，采用统一目录结构（`[source-name-no-ext]/<skill-suffix>/`）。
+  - `baoyu-article-illustrator`、`baoyu-comic`、`baoyu-cover-image`、`baoyu-slide-deck`、`baoyu-xhs-images`
+
 ## 0.7.0 - 2026-01-17

 ### 新功能
@@ -20,7 +89,7 @@

 - `baoyu-slide-deck`：新增 `scripts/merge-to-pdf.ts`，可将生成的 slide 图片一键合并为 PDF；文档补充导出步骤与产物命名（pptx/pdf）。
 - `baoyu-comic`：新增 `scripts/merge-to-pdf.ts`，将封面/分页图片合并为 PDF；补充角色参考（图片/文本）处理说明。
- 文档规范：在 `CLAUDE.md` 中补充“Script Directory”模板；`baoyu-gemini-web` / `baoyu-slide-deck` / `baoyu-comic` 文档统一用 `${SKILL_DIR}` 引用脚本路径，方便 agent 在任意安装目录运行。
+- 文档规范：在 `CLAUDE.md` 中补充“Script Directory”模板；`baoyu-danger-gemini-web` / `baoyu-slide-deck` / `baoyu-comic` 文档统一用 `${SKILL_DIR}` 引用脚本路径，方便 agent 在任意安装目录运行。

 ## 0.6.0 - 2026-01-17

@@ -35,8 +104,8 @@

 ## 0.5.2 - 2026-01-16

- `baoyu-gemini-web`：新增 `--sessionId`（本地持久化会话，支持 `--list-sessions`），用于多轮对话/多图生成保持上下文一致。
- `baoyu-gemini-web`：新增 `--reference/--ref` 传入参考图片（vision 输入），并增强超时与 cookie 失效自动恢复逻辑。
+- `baoyu-danger-gemini-web`：新增 `--sessionId`（本地持久化会话，支持 `--list-sessions`），用于多轮对话/多图生成保持上下文一致。
+- `baoyu-danger-gemini-web`：新增 `--reference/--ref` 传入参考图片（vision 输入），并增强超时与 cookie 失效自动恢复逻辑。
 - `baoyu-xhs-images` / `baoyu-slide-deck` / `baoyu-comic`：文档补充 session 约定（整套图使用同一 `sessionId`，增强风格一致性）。

 ## 0.5.1 - 2026-01-16
@@ -52,7 +121,7 @@

 ## 0.4.2 - 2026-01-15

- `baoyu-gemini-web`：描述信息更新，明确其作为 `cover-image` / `xhs-images` / `article-illustrator` 等技能的图片生成后端。
+- `baoyu-danger-gemini-web`：描述信息更新，明确其作为 `cover-image` / `xhs-images` / `article-illustrator` 等技能的图片生成后端。

 ## 0.4.1 - 2026-01-15

@@ -8,17 +8,34 @@ Claude Code marketplace plugin providing AI-powered content generation skills. S

 ## Architecture

+Skills are organized into three plugin categories in `marketplace.json`:
+
 ```
 skills/
-├── baoyu-gemini-web/          # Core: Gemini API wrapper (text + image gen)
-├── baoyu-xhs-images/          # Xiaohongshu infographic series (1-10 images)
-├── baoyu-cover-image/         # Article cover images (2.35:1 aspect)
-├── baoyu-slide-deck/          # Presentation slides with outlines
-├── baoyu-article-illustrator/ # Smart illustration placement
-├── baoyu-post-to-x/           # X/Twitter posting automation
-└── baoyu-post-to-wechat/      # WeChat Official Account posting
+├── [content-skills]           # Content generation and publishing
+│   ├── baoyu-xhs-images/          # Xiaohongshu infographic series (1-10 images)
+│   ├── baoyu-cover-image/         # Article cover images (2.35:1 aspect)
+│   ├── baoyu-slide-deck/          # Presentation slides with outlines
+│   ├── baoyu-article-illustrator/ # Smart illustration placement
+│   ├── baoyu-comic/               # Knowledge comics (Logicomix/Ohmsha style)
+│   ├── baoyu-post-to-x/           # X/Twitter posting automation
+│   └── baoyu-post-to-wechat/      # WeChat Official Account posting
+│
+├── [ai-generation-skills]     # AI-powered generation backends
+│   └── baoyu-danger-gemini-web/   # Gemini API wrapper (text + image gen)
+│
+└── [utility-skills]           # Utility tools for content processing
+    ├── baoyu-danger-x-to-markdown/ # X/Twitter content to markdown
+    └── baoyu-compress-image/      # Image compression
 ```

+**Plugin Categories**:
+| Category | Description |
+|----------|-------------|
+| `content-skills` | Skills that generate or publish content (images, slides, comics, posts) |
+| `ai-generation-skills` | Backend skills providing AI generation capabilities |
+| `utility-skills` | Helper tools for content processing (conversion, compression) |
+
 Each skill contains:
 - `SKILL.md` - YAML front matter (name, description) + documentation
 - `scripts/` - TypeScript implementations
@@ -35,24 +52,24 @@ npx -y bun skills/<skill>/scripts/main.ts [options]
 Examples:
 ```bash
 # Text generation
-npx -y bun skills/baoyu-gemini-web/scripts/main.ts "Hello"
+npx -y bun skills/baoyu-danger-gemini-web/scripts/main.ts "Hello"

 # Image generation
-npx -y bun skills/baoyu-gemini-web/scripts/main.ts --prompt "A cat" --image cat.png
+npx -y bun skills/baoyu-danger-gemini-web/scripts/main.ts --prompt "A cat" --image cat.png

 # From prompt files
-npx -y bun skills/baoyu-gemini-web/scripts/main.ts --promptfiles system.md content.md --image out.png
+npx -y bun skills/baoyu-danger-gemini-web/scripts/main.ts --promptfiles system.md content.md --image out.png
 ```

 ## Key Dependencies

 - **Bun**: TypeScript runtime (via `npx -y bun`)
- **Chrome**: Required for `baoyu-gemini-web` auth and `baoyu-post-to-x` automation
+- **Chrome**: Required for `baoyu-danger-gemini-web` auth and `baoyu-post-to-x` automation
 - **No npm packages**: Self-contained TypeScript, no external dependencies

 ## Authentication

-`baoyu-gemini-web` uses browser cookies for Google auth:
+`baoyu-danger-gemini-web` uses browser cookies for Google auth:
 - First run opens Chrome for login
 - Cookies cached in data directory
 - Force refresh: `--login` flag
@@ -70,9 +87,28 @@ npx -y bun skills/baoyu-gemini-web/scripts/main.ts --promptfiles system.md conte
   - SKILL.md `name` field: `baoyu-<name>`
 2. Add TypeScript in `skills/baoyu-<name>/scripts/`
 3. Add prompt templates in `skills/baoyu-<name>/prompts/` if needed
-4. Register in `marketplace.json` plugins[0].skills array as `./skills/baoyu-<name>`
+4. **Choose the appropriate category** and register in `marketplace.json`:
+   - `content-skills`: For content generation/publishing (images, slides, posts)
+   - `ai-generation-skills`: For AI backend capabilities
+   - `utility-skills`: For helper tools (conversion, compression)
+   - If none fit, create a new category with descriptive name
 5. **Add Script Directory section** to SKILL.md (see template below)

+### Choosing a Category
+
+| If your skill... | Use category |
+|------------------|--------------|
+| Generates visual content (images, slides, comics) | `content-skills` |
+| Publishes to platforms (X, WeChat, etc.) | `content-skills` |
+| Provides AI generation backend | `ai-generation-skills` |
+| Converts or processes content | `utility-skills` |
+| Compresses or optimizes files | `utility-skills` |
+
+**Creating a new category**: If the skill doesn't fit existing categories, add a new plugin object to `marketplace.json` with:
+- `name`: Descriptive kebab-case name (e.g., `analytics-skills`)
+- `description`: Brief description of the category
+- `skills`: Array with the skill path
+
 ### Script Directory Template

 Every SKILL.md with scripts MUST include this section after Usage:
@@ -102,3 +138,107 @@ When referencing scripts in workflow sections, use `${SKILL_DIR}/scripts/<name>.
 - Async/await patterns
 - Short variable names
 - Type-safe interfaces
+
+## Image Generation Guidelines
+
+Skills that require image generation MUST delegate to available image generation skills rather than implementing their own.
+
+### Image Generation Skill Selection
+
+1. Check available image generation skills in `skills/` directory
+2. Read each skill's SKILL.md to understand parameters and capabilities
+3. If multiple image generation skills available, ask user to choose preferred skill
+
+### Generation Flow Template
+
+Use this template when implementing image generation in skills:
+
+```markdown
+### Step N: Generate Images
+
+**Skill Selection**:
+1. Check available image generation skills (e.g., `baoyu-danger-gemini-web`)
+2. Read selected skill's SKILL.md for parameter reference
+3. If multiple skills available, ask user to choose
+
+**Generation Flow**:
+1. Call selected image generation skill with:
+   - Prompt file path (or inline prompt)
+   - Output image path
+   - Any skill-specific parameters (refer to skill's SKILL.md)
+2. Generate images sequentially (one at a time)
+3. After each image, output progress: "Generated X/N"
+4. On failure, auto-retry once before reporting error
+```
+
+### Output Path Convention
+
+Generated images from the same skill and source file MUST be grouped together:
+
+**With source file** (e.g., `/path/to/project/content/my-article.md`):
+```
+/path/to/project/content/my-article/<skill-suffix>/
+```
+- Remove file extension from source filename
+- Use skill name suffix (e.g., `xhs-images`, `cover-image`, `slide-deck`)
+- Example: source `/tests-data/anthropic-economic-index.md` + skill `baoyu-xhs-images` → `/tests-data/anthropic-economic-index/xhs-images/`
+
+**Without source file**:
+```
+./<skill-suffix>/<source-slug>/
+```
+- Place under current project directory
+- Use descriptive slug for the content
+
+**Directory Backup**:
+- If output directory already exists, rename existing directory with timestamp
+- Format: `<dirname>-backup-YYYYMMDD-HHMMSS`
+- Example: `xhs-images` → `xhs-images-backup-20260117-143052`
+
+### Image Naming Convention
+
+Image filenames MUST include meaningful slugs for readability:
+
+**Format**: `NN-{type}-[slug].png`
+- `NN`: Two-digit sequence number (01, 02, ...)
+- `{type}`: Image type (cover, content, page, slide, illustration, etc.)
+- `[slug]`: Descriptive kebab-case slug derived from content
+
+**Examples**:
+```
+01-cover-ai-future.png
+02-content-key-benefits.png
+03-page-enigma-machine.png
+04-slide-architecture-overview.png
+```
+
+**Slug Rules**:
+- Derived from image purpose or content (kebab-case)
+- Must be unique within the output directory
+- 2-5 words, concise but descriptive
+- When content changes significantly, update slug accordingly
+
+### Best Practices
+
+- Always read the image generation skill's SKILL.md before calling
+- Pass parameters exactly as documented in the skill
+- Handle failures gracefully with retry logic
+- Provide clear progress feedback to user
+
+## Extension Support
+
+Every SKILL.md MUST include an Extension Support section at the end:
+
+```markdown
+## Extension Support
+
+Custom styles and configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/<skill-name>/EXTEND.md` (project)
+2. `~/.baoyu-skills/<skill-name>/EXTEND.md` (user)
+
+If found, load before Step 1. Extension content overrides defaults.
+```
+
+Replace `<skill-name>` with the actual skill name (e.g., `baoyu-cover-image`).
@@ -61,25 +61,13 @@ You can also **Enable auto-update** to get the latest versions automatically.

 ## Available Skills

-### baoyu-gemini-web
+Skills are organized into three categories:

-Interacts with Gemini Web to generate text and images.
+### Content Skills

-**Text Generation:**
+Content generation and publishing skills.

-```bash
-/baoyu-gemini-web "Hello, Gemini"
-/baoyu-gemini-web --prompt "Explain quantum computing"
-```
-
-**Image Generation:**
-
-```bash
-/baoyu-gemini-web --prompt "A cute cat" --image cat.png
-/baoyu-gemini-web --promptfiles system.md content.md --image out.png
-```
-
-### baoyu-xhs-images
+#### baoyu-xhs-images

 Xiaohongshu (RedNote) infographic series generator. Breaks down content into 1-10 cartoon-style infographics with **Style × Layout** two-dimensional system.

@@ -112,7 +100,7 @@ Xiaohongshu (RedNote) infographic series generator. Breaks down content into 1-1
 | `comparison` | 2 sides | Before/after, pros/cons |
 | `flow` | 3-6 steps | Processes, timelines |

-### baoyu-cover-image
+#### baoyu-cover-image

 Generate hand-drawn style cover images for articles with multiple style options.

@@ -130,7 +118,7 @@ Generate hand-drawn style cover images for articles with multiple style options.

 Available styles: `elegant` (default), `tech`, `warm`, `bold`, `minimal`, `playful`, `nature`, `retro`

-### baoyu-slide-deck
+#### baoyu-slide-deck

 Generate professional slide deck images from content. Creates comprehensive outlines with style instructions, then generates individual slide images.

@@ -153,20 +141,40 @@ Generate professional slide deck images from content. Creates comprehensive outl

 | Style | Description | Best For |
 |-------|-------------|----------|
-| `notion` (default) | SaaS dashboard aesthetic with clean data focus, card-based layouts | Product demos, SaaS, productivity tools, B2B |
-| `sketch-notes` | Hand-drawn feel with soft brush strokes, warm off-white background | Educational, tutorials, knowledge sharing |
-| `blueprint` | Technical schematics with grid texture, engineering precision | Architecture, system design, data analysis |
-| `bold-editorial` | High-impact magazine style, bold typography, dark backgrounds | Product launches, marketing, keynotes |
-| `vector-illustration` | Flat vector with black outlines, retro soft colors, toy model aesthetic | Creative proposals, children's content, explainers |
-| `minimal` | Ultra-clean with maximum whitespace, single accent color, zen-like | Executive briefings, keynotes, premium brands |
-| `storytelling` | Cinematic full-bleed visuals, emotional photography | Case studies, narratives, customer journeys |
-| `warm` | Soft gradients, rounded shapes, wellness palette | Lifestyle, wellness, personal development |
-| `corporate` | Navy/gold palette, structured layouts, professional iconography | Investor decks, client proposals, quarterly reports |
-| `playful` | Vibrant coral/teal/yellow, rounded shapes, dynamic layouts | Workshops, training, creative pitches |
+| `blueprint` (default) | Technical schematics, grid texture, engineering precision | Architecture, system design |
+| `notion` | SaaS dashboard aesthetic, card-based layouts, clean data focus | Product demos, SaaS, B2B |
+| `bold-editorial` | High-impact magazine style, bold typography, dark backgrounds | Product launches, keynotes |
+| `corporate` | Navy/gold palette, structured layouts, professional icons | Investor decks, proposals |
+| `dark-atmospheric` | Cinematic dark mode, glowing accents, atmospheric depth | Entertainment, gaming, creative |
+| `editorial-infographic` | Magazine-style explainers, flat illustrations | Tech explainers, research |
+| `fantasy-animation` | Whimsical Ghibli/Disney style, hand-drawn animation | Educational, storytelling |
+| `intuition-machine` | Technical briefing, bilingual labels, aged paper texture | Technical docs, bilingual |
+| `minimal` | Ultra-clean, maximum whitespace, single accent color | Executive briefings, premium |
+| `pixel-art` | Retro 8-bit aesthetic, chunky pixels, nostalgic gaming | Gaming, developer talks |
+| `scientific` | Academic diagrams, biological pathways, precise labeling | Biology, chemistry, medical |
+| `sketch-notes` | Hand-drawn feel, soft brush strokes, warm background | Educational, tutorials |
+| `vector-illustration` | Flat vector, black outlines, retro soft colors | Creative proposals, explainers |
+| `vintage` | Aged-paper aesthetic, historical document styling | Historical, heritage, biography |
+| `watercolor` | Soft hand-painted textures, natural warmth | Lifestyle, wellness, travel |
+
+**Style Previews**:
+
+| | | |
+|:---:|:---:|:---:|
+| ![blueprint](./screenshots/slide-deck-styles/blueprint.webp) | ![bold-editorial](./screenshots/slide-deck-styles/bold-editorial.webp) | ![corporate](./screenshots/slide-deck-styles/corporate.webp) |
+| blueprint | bold-editorial | corporate |
+| ![dark-atmospheric](./screenshots/slide-deck-styles/dark-atmospheric.webp) | ![editorial-infographic](./screenshots/slide-deck-styles/editorial-infographic.webp) | ![fantasy-animation](./screenshots/slide-deck-styles/fantasy-animation.webp) |
+| dark-atmospheric | editorial-infographic | fantasy-animation |
+| ![intuition-machine](./screenshots/slide-deck-styles/intuition-machine.webp) | ![minimal](./screenshots/slide-deck-styles/minimal.webp) | ![notion](./screenshots/slide-deck-styles/notion.webp) |
+| intuition-machine | minimal | notion |
+| ![pixel-art](./screenshots/slide-deck-styles/pixel-art.webp) | ![scientific](./screenshots/slide-deck-styles/scientific.webp) | ![sketch-notes](./screenshots/slide-deck-styles/sketch-notes.webp) |
+| pixel-art | scientific | sketch-notes |
+| ![vector-illustration](./screenshots/slide-deck-styles/vector-illustration.webp) | ![vintage](./screenshots/slide-deck-styles/vintage.webp) | ![watercolor](./screenshots/slide-deck-styles/watercolor.webp) |
+| vector-illustration | vintage | watercolor |

 After generation, slides are automatically merged into a `.pptx` file for easy sharing.

-### baoyu-comic
+#### baoyu-comic

 Knowledge comic creator supporting multiple styles (Logicomix/Ligne Claire, Ohmsha manga guide). Creates original educational comics with detailed panel layouts and sequential image generation.

@@ -178,14 +186,28 @@ Knowledge comic creator supporting multiple styles (Logicomix/Ligne Claire, Ohms
 /baoyu-comic posts/turing-story/source.md --style dramatic
 /baoyu-comic posts/turing-story/source.md --style ohmsha

-# Specify layout
+# Custom style (natural language)
+/baoyu-comic posts/turing-story/source.md --style "watercolor with soft edges"
+
+# Specify layout and aspect ratio
 /baoyu-comic posts/turing-story/source.md --layout cinematic
-/baoyu-comic posts/turing-story/source.md --layout webtoon
+/baoyu-comic posts/turing-story/source.md --aspect 16:9
+
+# Specify language
+/baoyu-comic posts/turing-story/source.md --lang zh

 # Direct content input
 /baoyu-comic "The story of Alan Turing and the birth of computer science"
 ```

+**Options**:
+| Option | Values |
+|--------|--------|
+| `--style` | `classic` (default), `dramatic`, `warm`, `tech`, `sepia`, `vibrant`, `ohmsha`, `realistic`, or custom description |
+| `--layout` | `standard` (default), `cinematic`, `dense`, `splash`, `mixed`, `webtoon` |
+| `--aspect` | `3:4` (default, portrait), `4:3` (landscape), `16:9` (widescreen) |
+| `--lang` | `auto` (default), `zh`, `en`, `ja`, etc. |
+
 **Styles** (visual aesthetics):

 | Style | Description | Best For |
@@ -209,7 +231,30 @@ Knowledge comic creator supporting multiple styles (Logicomix/Ligne Claire, Ohms
 | `mixed` | 3-7 varies | Complex narratives, emotional arcs |
 | `webtoon` | 3-5 vertical | Ohmsha tutorials, mobile reading |

-### baoyu-post-to-wechat
+#### baoyu-article-illustrator
+
+Smart article illustration skill. Analyzes article content and generates illustrations at positions requiring visual aids.
+
+```bash
+/baoyu-article-illustrator path/to/article.md
+```
+
+#### baoyu-post-to-x
+
+Post content and articles to X (Twitter). Supports regular posts with images and X Articles (long-form Markdown). Uses real Chrome with CDP to bypass anti-automation.
+
+```bash
+# Post with text
+/baoyu-post-to-x "Hello from Claude Code!"
+
+# Post with images
+/baoyu-post-to-x "Check this out" --image photo.png
+
+# Post X Article
+/baoyu-post-to-x --article path/to/article.md
+```
+
+#### baoyu-post-to-wechat

 Post content to WeChat Official Account (微信公众号). Two modes available:

@@ -231,9 +276,94 @@ Post content to WeChat Official Account (微信公众号). Two modes available:

 Prerequisites: Google Chrome installed. First run requires QR code login (session preserved).

+### AI Generation Skills
+
+AI-powered generation backends.
+
+#### baoyu-danger-gemini-web
+
+Interacts with Gemini Web to generate text and images.
+
+**Text Generation:**
+
+```bash
+/baoyu-danger-gemini-web "Hello, Gemini"
+/baoyu-danger-gemini-web --prompt "Explain quantum computing"
+```
+
+**Image Generation:**
+
+```bash
+/baoyu-danger-gemini-web --prompt "A cute cat" --image cat.png
+/baoyu-danger-gemini-web --promptfiles system.md content.md --image out.png
+```
+
+### Utility Skills
+
+Utility tools for content processing.
+
+#### baoyu-danger-x-to-markdown
+
+Converts X (Twitter) content to markdown format. Supports tweet threads and X Articles.
+
+```bash
+# Convert tweet to markdown
+/baoyu-danger-x-to-markdown https://x.com/username/status/123456
+
+# Save to specific file
+/baoyu-danger-x-to-markdown https://x.com/username/status/123456 -o output.md
+
+# JSON output
+/baoyu-danger-x-to-markdown https://x.com/username/status/123456 --json
+```
+
+**Supported URLs:**
+- `https://x.com/<user>/status/<id>`
+- `https://twitter.com/<user>/status/<id>`
+- `https://x.com/i/article/<id>`
+
+**Authentication:** Uses environment variables (`X_AUTH_TOKEN`, `X_CT0`) or Chrome login for cookie-based auth.
+
+#### baoyu-compress-image
+
+Compress images to reduce file size while maintaining quality.
+
+```bash
+/baoyu-compress-image path/to/image.png
+/baoyu-compress-image path/to/images/ --quality 80
+```
+
+## Customization
+
+All skills support customization via `EXTEND.md` files. Create an extension file to override default styles, add custom configurations, or define your own presets.
+
+**Extension paths** (checked in priority order):
+1. `.baoyu-skills/<skill-name>/EXTEND.md` - Project-level (for team/project-specific settings)
+2. `~/.baoyu-skills/<skill-name>/EXTEND.md` - User-level (for personal preferences)
+
+**Example**: To customize `baoyu-cover-image` with your brand colors:
+
+```bash
+mkdir -p .baoyu-skills/baoyu-cover-image
+```
+
+Then create `.baoyu-skills/baoyu-cover-image/EXTEND.md`:
+
+```markdown
+## Custom Styles
+
+### brand
+- Primary color: #1a73e8
+- Secondary color: #34a853
+- Font style: Modern sans-serif
+- Always include company logo watermark
+```
+
+The extension content will be loaded before skill execution and override defaults.
+
 ## Disclaimer

-### baoyu-gemini-web
+### baoyu-danger-gemini-web

 This skill uses the Gemini Web API (reverse-engineered).

@@ -243,6 +373,17 @@ This skill uses the Gemini Web API (reverse-engineered).
 - Cookies are cached for subsequent runs
 - No guarantees on API stability or availability

+### baoyu-danger-x-to-markdown
+
+This skill uses a reverse-engineered X (Twitter) API.
+
+**Warning:** This is NOT an official API. Use at your own risk.
+
+- May break without notice if X changes their API
+- Account restrictions possible if API usage detected
+- First use requires consent acknowledgment
+- Authentication via environment variables or Chrome login
+
 ## License

 MIT
@@ -61,25 +61,13 @@ npx add-skill jimliu/baoyu-skills

 ## 可用技能

-### baoyu-gemini-web
+技能分为三大类：

-与 Gemini Web 交互，生成文本和图片。
+### 内容技能 (Content Skills)

-**文本生成：**
+内容生成和发布技能。

-```bash
-/baoyu-gemini-web "你好，Gemini"
-/baoyu-gemini-web --prompt "解释量子计算"
-```
-
-**图片生成：**
-
-```bash
-/baoyu-gemini-web --prompt "一只可爱的猫" --image cat.png
-/baoyu-gemini-web --promptfiles system.md content.md --image out.png
-```
-
-### baoyu-xhs-images
+#### baoyu-xhs-images

 小红书信息图系列生成器。将内容拆解为 1-10 张卡通风格信息图，支持 **风格 × 布局** 二维系统。

@@ -112,7 +100,7 @@ npx add-skill jimliu/baoyu-skills
 | `comparison` | 双栏 | 对比、优劣 |
 | `flow` | 3-6 步 | 流程、时间线 |

-### baoyu-cover-image
+#### baoyu-cover-image

 为文章生成手绘风格封面图，支持多种风格选项。

@@ -130,7 +118,7 @@ npx add-skill jimliu/baoyu-skills

 可用风格：`elegant`（默认）、`tech`、`warm`、`bold`、`minimal`、`playful`、`nature`、`retro`

-### baoyu-slide-deck
+#### baoyu-slide-deck

 从内容生成专业的幻灯片图片。先创建包含样式说明的完整大纲，然后逐页生成幻灯片图片。

@@ -153,20 +141,40 @@ npx add-skill jimliu/baoyu-skills

 | 风格 | 描述 | 适用场景 |
 |------|------|----------|
-| `notion`（默认） | SaaS 仪表盘美学，卡片式布局，数据展示清晰 | 产品演示、SaaS、生产力工具、B2B |
+| `blueprint`（默认） | 技术蓝图风格，网格纹理，工程精度 | 架构设计、系统设计 |
+| `notion` | SaaS 仪表盘美学，卡片式布局，数据清晰 | 产品演示、SaaS、B2B |
+| `bold-editorial` | 杂志社论风格，粗体排版，深色背景 | 产品发布、主题演讲 |
+| `corporate` | 海军蓝/金色配色，结构化布局，专业图标 | 投资者演示、客户提案 |
+| `dark-atmospheric` | 电影级暗色调，发光效果，氛围感 | 娱乐、游戏、创意 |
+| `editorial-infographic` | 杂志风格信息图，扁平插画 | 科技解说、研究报告 |
+| `fantasy-animation` | 吉卜力/迪士尼风格，手绘动画 | 教育、故事讲述 |
+| `intuition-machine` | 技术简报，双语标签，做旧纸张纹理 | 技术文档、双语内容 |
+| `minimal` | 极简风格，大量留白，单一强调色 | 高管简报、高端品牌 |
+| `pixel-art` | 复古 8-bit 像素风，怀旧游戏感 | 游戏、开发者分享 |
+| `scientific` | 学术图表，生物通路，精确标注 | 生物、化学、医学 |
 | `sketch-notes` | 手绘风格，柔和笔触，暖白色背景 | 教育、教程、知识分享 |
-| `blueprint` | 技术蓝图风格，网格纹理，工程精度 | 架构设计、系统设计、数据分析 |
-| `bold-editorial` | 杂志社论风格，粗体排版，深色背景，高冲击力 | 产品发布、营销、主题演讲 |
-| `vector-illustration` | 扁平矢量风格，黑色轮廓线，复古柔和配色，玩具模型感 | 创意提案、儿童内容、说明性内容 |
-| `minimal` | 极简风格，大量留白，单一强调色，禅意美学 | 高管简报、主题演讲、高端品牌 |
-| `storytelling` | 电影风格，全幅视觉，情感化摄影 | 案例研究、叙事、客户旅程 |
-| `warm` | 柔和渐变，圆润形状，健康生活配色 | 生活方式、健康养生、个人成长 |
-| `corporate` | 海军蓝/金色配色，结构化布局，专业图标 | 投资者演示、客户提案、季度报告 |
-| `playful` | 活力珊瑚/青色/黄色，圆润形状，动感布局 | 工作坊、培训、创意提案 |
+| `vector-illustration` | 扁平矢量风格，黑色轮廓线，复古柔和配色 | 创意提案、说明性内容 |
+| `vintage` | 做旧纸张美学，历史文档风格 | 历史、传记、人文 |
+| `watercolor` | 柔和手绘水彩纹理，自然温暖 | 生活方式、健康、旅行 |
+
+**风格预览**：
+
+| | | |
+|:---:|:---:|:---:|
+| ![blueprint](./screenshots/slide-deck-styles/blueprint.webp) | ![bold-editorial](./screenshots/slide-deck-styles/bold-editorial.webp) | ![corporate](./screenshots/slide-deck-styles/corporate.webp) |
+| blueprint | bold-editorial | corporate |
+| ![dark-atmospheric](./screenshots/slide-deck-styles/dark-atmospheric.webp) | ![editorial-infographic](./screenshots/slide-deck-styles/editorial-infographic.webp) | ![fantasy-animation](./screenshots/slide-deck-styles/fantasy-animation.webp) |
+| dark-atmospheric | editorial-infographic | fantasy-animation |
+| ![intuition-machine](./screenshots/slide-deck-styles/intuition-machine.webp) | ![minimal](./screenshots/slide-deck-styles/minimal.webp) | ![notion](./screenshots/slide-deck-styles/notion.webp) |
+| intuition-machine | minimal | notion |
+| ![pixel-art](./screenshots/slide-deck-styles/pixel-art.webp) | ![scientific](./screenshots/slide-deck-styles/scientific.webp) | ![sketch-notes](./screenshots/slide-deck-styles/sketch-notes.webp) |
+| pixel-art | scientific | sketch-notes |
+| ![vector-illustration](./screenshots/slide-deck-styles/vector-illustration.webp) | ![vintage](./screenshots/slide-deck-styles/vintage.webp) | ![watercolor](./screenshots/slide-deck-styles/watercolor.webp) |
+| vector-illustration | vintage | watercolor |

 生成完成后，所有幻灯片会自动合并为 `.pptx` 文件，方便分享。

-### baoyu-comic
+#### baoyu-comic

 知识漫画创作器，支持多种风格（Logicomix/清线风格、欧姆社漫画教程风格）。创作带有详细分镜布局的原创教育漫画，逐页生成图片。

@@ -178,14 +186,28 @@ npx add-skill jimliu/baoyu-skills
 /baoyu-comic posts/turing-story/source.md --style dramatic
 /baoyu-comic posts/turing-story/source.md --style ohmsha

-# 指定布局
+# 自定义风格（自然语言描述）
+/baoyu-comic posts/turing-story/source.md --style "水彩风格，边缘柔和"
+
+# 指定布局和比例
 /baoyu-comic posts/turing-story/source.md --layout cinematic
-/baoyu-comic posts/turing-story/source.md --layout webtoon
+/baoyu-comic posts/turing-story/source.md --aspect 16:9
+
+# 指定语言
+/baoyu-comic posts/turing-story/source.md --lang zh

 # 直接输入内容
 /baoyu-comic "图灵的故事与计算机科学的诞生"
 ```

+**选项**：
+| 选项 | 取值 |
+|------|------|
+| `--style` | `classic`（默认）、`dramatic`、`warm`、`tech`、`sepia`、`vibrant`、`ohmsha`、`realistic`，或自然语言描述 |
+| `--layout` | `standard`（默认）、`cinematic`、`dense`、`splash`、`mixed`、`webtoon` |
+| `--aspect` | `3:4`（默认，竖版）、`4:3`（横版）、`16:9`（宽屏） |
+| `--lang` | `auto`（默认）、`zh`、`en`、`ja` 等 |
+
 **风格**（视觉美学）：

 | 风格 | 描述 | 适用场景 |
@@ -209,7 +231,30 @@ npx add-skill jimliu/baoyu-skills
 | `mixed` | 3-7 不等 | 复杂叙事、情感弧线 |
 | `webtoon` | 3-5 竖向 | 欧姆社教程、手机阅读 |

-### baoyu-post-to-wechat
+#### baoyu-article-illustrator
+
+智能文章插图技能。分析文章内容，在需要视觉辅助的位置生成插图。
+
+```bash
+/baoyu-article-illustrator path/to/article.md
+```
+
+#### baoyu-post-to-x
+
+发布内容和文章到 X (Twitter)。支持带图片的普通帖子和 X 文章（长篇 Markdown）。使用真实 Chrome + CDP 绕过反自动化检测。
+
+```bash
+# 发布文字
+/baoyu-post-to-x "Hello from Claude Code!"
+
+# 发布带图片
+/baoyu-post-to-x "看看这个" --image photo.png
+
+# 发布 X 文章
+/baoyu-post-to-x --article path/to/article.md
+```
+
+#### baoyu-post-to-wechat

 发布内容到微信公众号，支持两种模式：

@@ -231,9 +276,94 @@ npx add-skill jimliu/baoyu-skills

 前置要求：已安装 Google Chrome，首次运行需扫码登录（登录状态会保存）

+### AI 生成技能 (AI Generation Skills)
+
+AI 驱动的生成后端。
+
+#### baoyu-danger-gemini-web
+
+与 Gemini Web 交互，生成文本和图片。
+
+**文本生成：**
+
+```bash
+/baoyu-danger-gemini-web "你好，Gemini"
+/baoyu-danger-gemini-web --prompt "解释量子计算"
+```
+
+**图片生成：**
+
+```bash
+/baoyu-danger-gemini-web --prompt "一只可爱的猫" --image cat.png
+/baoyu-danger-gemini-web --promptfiles system.md content.md --image out.png
+```
+
+### 工具技能 (Utility Skills)
+
+内容处理工具。
+
+#### baoyu-danger-x-to-markdown
+
+将 X (Twitter) 内容转换为 markdown 格式。支持推文串和 X 文章。
+
+```bash
+# 将推文转换为 markdown
+/baoyu-danger-x-to-markdown https://x.com/username/status/123456
+
+# 保存到指定文件
+/baoyu-danger-x-to-markdown https://x.com/username/status/123456 -o output.md
+
+# JSON 输出
+/baoyu-danger-x-to-markdown https://x.com/username/status/123456 --json
+```
+
+**支持的 URL：**
+- `https://x.com/<user>/status/<id>`
+- `https://twitter.com/<user>/status/<id>`
+- `https://x.com/i/article/<id>`
+
+**身份验证：** 使用环境变量（`X_AUTH_TOKEN`、`X_CT0`）或 Chrome 登录进行 cookie 认证。
+
+#### baoyu-compress-image
+
+压缩图片以减小文件大小，同时保持质量。
+
+```bash
+/baoyu-compress-image path/to/image.png
+/baoyu-compress-image path/to/images/ --quality 80
+```
+
+## 自定义扩展
+
+所有技能支持通过 `EXTEND.md` 文件自定义。创建扩展文件可覆盖默认样式、添加自定义配置或定义个人预设。
+
+**扩展路径**（按优先级检查）：
+1. `.baoyu-skills/<skill-name>/EXTEND.md` - 项目级（团队/项目特定设置）
+2. `~/.baoyu-skills/<skill-name>/EXTEND.md` - 用户级（个人偏好设置）
+
+**示例**：为 `baoyu-cover-image` 自定义品牌配色：
+
+```bash
+mkdir -p .baoyu-skills/baoyu-cover-image
+```
+
+然后创建 `.baoyu-skills/baoyu-cover-image/EXTEND.md`：
+
+```markdown
+## 自定义风格
+
+### brand
+- 主色：#1a73e8
+- 辅色：#34a853
+- 字体风格：现代无衬线
+- 始终包含公司 logo 水印
+```
+
+扩展内容会在技能执行前加载，并覆盖默认设置。
+
 ## 免责声明

-### baoyu-gemini-web
+### baoyu-danger-gemini-web

 此技能使用 Gemini Web API（逆向工程）。

@@ -243,6 +373,17 @@ npx add-skill jimliu/baoyu-skills
 - Cookies 会被缓存供后续使用
 - 不保证 API 的稳定性或可用性

+### baoyu-danger-x-to-markdown
+
+此技能使用逆向工程的 X (Twitter) API。
+
+**警告：** 这不是官方 API。使用风险自负。
+
+- 如果 X 更改其 API，可能会无预警失效
+- 如检测到 API 使用，账号可能受限
+- 首次使用需确认免责声明
+- 通过环境变量或 Chrome 登录进行身份验证
+
 ## 许可证

 MIT
@@ -102,22 +102,44 @@ When no `--style` is specified, analyze content to select the best style:

 ## File Management

-Save illustrations to `imgs/` subdirectory in the same folder as the article:
+### With Article Path
+
+Save illustrations to `[source-name-no-ext]/illustrations/` subdirectory in the same folder as the article:

 ```
 path/to/
 ├── article.md
-└── imgs/
+└── article/
+    └── illustrations/
+        ├── outline.md
+        ├── prompts/
+        │   ├── illustration-concept-a.md
+        │   ├── illustration-concept-b.md
+        │   └── ...
+        ├── illustration-concept-a.png
+        ├── illustration-concept-b.png
+        └── ...
+```
+
+Example: `/posts/ai-future.md` → `/posts/ai-future/illustrations/`
+
+### Without Article Path (Pasted Content)
+
+Save to `./illustrations/[topic-slug]/`:
+
+```
+illustrations/
+└── ai-future/
+    ├── source.md
    ├── outline.md
    ├── prompts/
-    │   ├── illustration-concept-a.md
-    │   ├── illustration-concept-b.md
-    │   └── ...
-    ├── illustration-concept-a.png
-    ├── illustration-concept-b.png
-    └── ...
+    └── *.png
 ```

+### Directory Backup
+
+If target directory exists, rename existing to `<dirname>-backup-YYYYMMDD-HHMMSS`
+
 ## Workflow

 ### Step 1: Analyze Content & Select Style
@@ -266,7 +288,7 @@ Style notes: [specific style characteristics]
 Insert generated images at corresponding positions:

 ```markdown
-![illustration description](imgs/illustration-[slug].png)
+![illustration description]([article-name]/illustrations/illustration-[slug].png)
 ```

 **Insertion Rules**:
@@ -427,3 +449,13 @@ Typography: Clean hand-drawn lettering, simple sans-serif labels
 - Sensitive figures should use cartoon alternatives
 - Prompts written in user's confirmed language preference
 - Illustration text (labels, captions) should match article language
+
+## Extension Support
+
+Custom styles and configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-article-illustrator/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-article-illustrator/EXTEND.md` (user)
+
+If found, load before Step 1. Extension content overrides defaults.
@@ -84,8 +84,12 @@ Style × Layout × Aspect can be freely combined. Custom styles can be described
 ```

 **Target directory**:
- With source path: `[source-dir]/comic/`
- Without source: `comic-outputs/YYYY-MM-DD/[topic-slug]/`
+- With source path: `[source-dir]/[source-name-no-ext]/comic/`
+  - Example: `/posts/turing-story.md` → `/posts/turing-story/comic/`
+- Without source: `./comic/[topic-slug]/`
+
+**Directory backup**:
+- If target directory exists, rename existing to `<dirname>-backup-YYYYMMDD-HHMMSS`

 ## Workflow

@@ -384,3 +388,13 @@ Detailed templates and guidelines in `references/` directory:
 - `ohmsha-guide.md` - Ohmsha manga style specifics
 - `styles/` - Detailed style definitions
 - `layouts/` - Detailed layout definitions
+
+## Extension Support
+
+Custom styles and configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-comic/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-comic/EXTEND.md` (user)
+
+If found, load before Step 1. Extension content overrides defaults.
@@ -0,0 +1,188 @@
+---
+name: baoyu-compress-image
+description: Cross-platform image compression skill. Converts images to WebP by default with PNG-to-PNG support. Uses system tools (sips, cwebp, ImageMagick) with Sharp fallback.
+---
+
+# Image Compressor
+
+Cross-platform image compression with WebP default output, PNG-to-PNG support, preferring system tools with Sharp fallback.
+
+## Script Directory
+
+**Important**: All scripts are located in the `scripts/` subdirectory of this skill.
+
+**Agent Execution Instructions**:
+1. Determine this SKILL.md file's directory path as `SKILL_DIR`
+2. Script path = `${SKILL_DIR}/scripts/<script-name>.ts`
+3. Replace all `${SKILL_DIR}` in this document with the actual path
+
+**Script Reference**:
+| Script | Purpose |
+|--------|---------|
+| `scripts/main.ts` | CLI entry point for image compression |
+
+## Quick Start
+
+```bash
+# Compress to WebP (default)
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png
+
+# Keep original format (PNG → PNG)
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png --format png
+
+# Custom quality
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png -q 75
+
+# Process directory
+npx -y bun ${SKILL_DIR}/scripts/main.ts ./images/ -r
+```
+
+## Commands
+
+### Single File Compression
+
+```bash
+# Basic (converts to WebP, replaces original)
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png
+
+# Custom output path
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png -o compressed.webp
+
+# Keep original file
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png --keep
+
+# Custom quality (0-100, default: 80)
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png -q 75
+
+# Keep original format
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png -f png
+```
+
+### Directory Processing
+
+```bash
+# Process all images in directory
+npx -y bun ${SKILL_DIR}/scripts/main.ts ./images/
+
+# Recursive processing
+npx -y bun ${SKILL_DIR}/scripts/main.ts ./images/ -r
+
+# With custom quality
+npx -y bun ${SKILL_DIR}/scripts/main.ts ./images/ -r -q 75
+```
+
+### Output Formats
+
+```bash
+# Plain text (default)
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png
+
+# JSON output
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png --json
+```
+
+## Options
+
+| Option | Short | Description | Default |
+|--------|-------|-------------|---------|
+| `<input>` | | Input file or directory | Required |
+| `--output <path>` | `-o` | Output path | Same path, new extension |
+| `--format <fmt>` | `-f` | webp, png, jpeg | webp |
+| `--quality <n>` | `-q` | Quality 0-100 | 80 |
+| `--keep` | `-k` | Keep original file | false |
+| `--recursive` | `-r` | Process directories recursively | false |
+| `--json` | | JSON output | false |
+| `--help` | `-h` | Show help | |
+
+## Compressor Selection
+
+Priority order (auto-detected):
+
+1. **sips** (macOS built-in, WebP support since macOS 11)
+2. **cwebp** (Google's official WebP tool)
+3. **ImageMagick** (`convert` command)
+4. **Sharp** (npm package, auto-installed by Bun)
+
+The skill automatically selects the best available compressor.
+
+## Output Format
+
+### Text Mode (default)
+
+```
+image.png → image.webp (245KB → 89KB, 64% reduction)
+```
+
+### JSON Mode
+
+```json
+{
+  "input": "image.png",
+  "output": "image.webp",
+  "inputSize": 250880,
+  "outputSize": 91136,
+  "ratio": 0.36,
+  "compressor": "sips"
+}
+```
+
+### Directory JSON Mode
+
+```json
+{
+  "files": [...],
+  "summary": {
+    "totalFiles": 10,
+    "totalInputSize": 2508800,
+    "totalOutputSize": 911360,
+    "ratio": 0.36,
+    "compressor": "sips"
+  }
+}
+```
+
+## Examples
+
+### Compress single image
+
+```bash
+npx -y bun ${SKILL_DIR}/scripts/main.ts photo.png
+# photo.png → photo.webp (1.2MB → 340KB, 72% reduction)
+```
+
+### Compress with custom quality
+
+```bash
+npx -y bun ${SKILL_DIR}/scripts/main.ts photo.png -q 60
+# photo.png → photo.webp (1.2MB → 280KB, 77% reduction)
+```
+
+### Keep original format
+
+```bash
+npx -y bun ${SKILL_DIR}/scripts/main.ts screenshot.png -f png --keep
+# screenshot.png → screenshot-compressed.png (500KB → 380KB, 24% reduction)
+```
+
+### Process entire directory
+
+```bash
+npx -y bun ${SKILL_DIR}/scripts/main.ts ./screenshots/ -r
+# Processed 15 files: 12.5MB → 4.2MB (66% reduction)
+```
+
+### Get JSON for scripting
+
+```bash
+npx -y bun ${SKILL_DIR}/scripts/main.ts image.png --json | jq '.ratio'
+```
+
+## Extension Support
+
+Custom configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-compress-image/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-compress-image/EXTEND.md` (user)
+
+If found, load before workflow. Extension content overrides defaults.
@@ -0,0 +1,315 @@
+#!/usr/bin/env bun
+import { existsSync, statSync, readdirSync, unlinkSync, renameSync } from "fs";
+import { basename, dirname, extname, join, resolve } from "path";
+import { spawn } from "child_process";
+
+type Compressor = "sips" | "cwebp" | "imagemagick" | "sharp";
+type Format = "webp" | "png" | "jpeg";
+
+interface Options {
+  input: string;
+  output?: string;
+  format: Format;
+  quality: number;
+  keep: boolean;
+  recursive: boolean;
+  json: boolean;
+}
+
+interface Result {
+  input: string;
+  output: string;
+  inputSize: number;
+  outputSize: number;
+  ratio: number;
+  compressor: Compressor;
+}
+
+const SUPPORTED_EXTS = [".png", ".jpg", ".jpeg", ".webp", ".gif", ".tiff"];
+
+async function commandExists(cmd: string): Promise<boolean> {
+  try {
+    const proc = spawn("which", [cmd], { stdio: "pipe" });
+    return new Promise((res) => {
+      proc.on("close", (code) => res(code === 0));
+      proc.on("error", () => res(false));
+    });
+  } catch {
+    return false;
+  }
+}
+
+async function detectCompressor(format: Format): Promise<Compressor> {
+  if (format === "webp") {
+    if (await commandExists("cwebp")) return "cwebp";
+    if (await commandExists("convert")) return "imagemagick";
+    return "sharp";
+  }
+  if (process.platform === "darwin") return "sips";
+  if (await commandExists("convert")) return "imagemagick";
+  return "sharp";
+}
+
+function runCmd(cmd: string, args: string[]): Promise<{ code: number; stderr: string }> {
+  return new Promise((res) => {
+    const proc = spawn(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    proc.stderr?.on("data", (d) => (stderr += d.toString()));
+    proc.on("close", (code) => res({ code: code ?? 1, stderr }));
+    proc.on("error", (e) => res({ code: 1, stderr: e.message }));
+  });
+}
+
+async function compressWithSips(input: string, output: string, format: Format, quality: number): Promise<void> {
+  const fmt = format === "jpeg" ? "jpeg" : format;
+  const args = ["-s", "format", fmt, "-s", "formatOptions", String(quality), input, "--out", output];
+  const { code, stderr } = await runCmd("sips", args);
+  if (code !== 0) throw new Error(`sips failed: ${stderr}`);
+}
+
+async function compressWithCwebp(input: string, output: string, quality: number): Promise<void> {
+  const args = ["-q", String(quality), input, "-o", output];
+  const { code, stderr } = await runCmd("cwebp", args);
+  if (code !== 0) throw new Error(`cwebp failed: ${stderr}`);
+}
+
+async function compressWithImagemagick(input: string, output: string, quality: number): Promise<void> {
+  const args = [input, "-quality", String(quality), output];
+  const { code, stderr } = await runCmd("convert", args);
+  if (code !== 0) throw new Error(`convert failed: ${stderr}`);
+}
+
+async function compressWithSharp(input: string, output: string, format: Format, quality: number): Promise<void> {
+  const sharp = (await import("sharp")).default;
+  let pipeline = sharp(input);
+  if (format === "webp") pipeline = pipeline.webp({ quality });
+  else if (format === "png") pipeline = pipeline.png({ quality });
+  else if (format === "jpeg") pipeline = pipeline.jpeg({ quality });
+  await pipeline.toFile(output);
+}
+
+async function compress(
+  compressor: Compressor,
+  input: string,
+  output: string,
+  format: Format,
+  quality: number
+): Promise<void> {
+  switch (compressor) {
+    case "sips":
+      await compressWithSips(input, output, format, quality);
+      break;
+    case "cwebp":
+      if (format !== "webp") {
+        await compressWithSharp(input, output, format, quality);
+      } else {
+        await compressWithCwebp(input, output, quality);
+      }
+      break;
+    case "imagemagick":
+      await compressWithImagemagick(input, output, quality);
+      break;
+    case "sharp":
+      await compressWithSharp(input, output, format, quality);
+      break;
+  }
+}
+
+function getOutputPath(input: string, format: Format, keep: boolean, customOutput?: string): string {
+  if (customOutput) return resolve(customOutput);
+  const dir = dirname(input);
+  const base = basename(input, extname(input));
+  const ext = format === "jpeg" ? ".jpg" : `.${format}`;
+  if (keep && extname(input).toLowerCase() === ext) {
+    return join(dir, `${base}-compressed${ext}`);
+  }
+  return join(dir, `${base}${ext}`);
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+async function processFile(
+  compressor: Compressor,
+  input: string,
+  opts: Options
+): Promise<Result> {
+  const absInput = resolve(input);
+  const inputSize = statSync(absInput).size;
+  const output = getOutputPath(absInput, opts.format, opts.keep, opts.output);
+  const tempOutput = output + ".tmp";
+
+  await compress(compressor, absInput, tempOutput, opts.format, opts.quality);
+
+  const outputSize = statSync(tempOutput).size;
+
+  if (!opts.keep && absInput !== output) {
+    unlinkSync(absInput);
+  }
+  renameSync(tempOutput, output);
+
+  return {
+    input: absInput,
+    output,
+    inputSize,
+    outputSize,
+    ratio: outputSize / inputSize,
+    compressor,
+  };
+}
+
+function collectFiles(dir: string, recursive: boolean): string[] {
+  const files: string[] = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory() && recursive) {
+      files.push(...collectFiles(full, recursive));
+    } else if (entry.isFile() && SUPPORTED_EXTS.includes(extname(entry.name).toLowerCase())) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+
+function printHelp() {
+  console.log(`Usage: bun main.ts <input> [options]
+
+Options:
+  -o, --output <path>   Output path
+  -f, --format <fmt>    Output format: webp, png, jpeg (default: webp)
+  -q, --quality <n>     Quality 0-100 (default: 80)
+  -k, --keep            Keep original file
+  -r, --recursive       Process directories recursively
+      --json            JSON output
+  -h, --help            Show help`);
+}
+
+function parseArgs(args: string[]): Options | null {
+  const opts: Options = {
+    input: "",
+    format: "webp",
+    quality: 80,
+    keep: false,
+    recursive: false,
+    json: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    } else if (arg === "-o" || arg === "--output") {
+      opts.output = args[++i];
+    } else if (arg === "-f" || arg === "--format") {
+      const fmt = args[++i]?.toLowerCase();
+      if (fmt === "webp" || fmt === "png" || fmt === "jpeg" || fmt === "jpg") {
+        opts.format = fmt === "jpg" ? "jpeg" : (fmt as Format);
+      } else {
+        console.error(`Invalid format: ${fmt}`);
+        return null;
+      }
+    } else if (arg === "-q" || arg === "--quality") {
+      const q = parseInt(args[++i], 10);
+      if (isNaN(q) || q < 0 || q > 100) {
+        console.error(`Invalid quality: ${args[i]}`);
+        return null;
+      }
+      opts.quality = q;
+    } else if (arg === "-k" || arg === "--keep") {
+      opts.keep = true;
+    } else if (arg === "-r" || arg === "--recursive") {
+      opts.recursive = true;
+    } else if (arg === "--json") {
+      opts.json = true;
+    } else if (!arg.startsWith("-") && !opts.input) {
+      opts.input = arg;
+    }
+  }
+
+  if (!opts.input) {
+    console.error("Error: Input file or directory required");
+    printHelp();
+    return null;
+  }
+
+  return opts;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const opts = parseArgs(args);
+  if (!opts) process.exit(1);
+
+  const input = resolve(opts.input);
+  if (!existsSync(input)) {
+    console.error(`Error: ${input} not found`);
+    process.exit(1);
+  }
+
+  const compressor = await detectCompressor(opts.format);
+  const isDir = statSync(input).isDirectory();
+
+  if (isDir) {
+    const files = collectFiles(input, opts.recursive);
+    if (files.length === 0) {
+      console.error("No supported images found");
+      process.exit(1);
+    }
+
+    const results: Result[] = [];
+    for (const file of files) {
+      try {
+        const r = await processFile(compressor, file, { ...opts, output: undefined });
+        results.push(r);
+        if (!opts.json) {
+          const reduction = Math.round((1 - r.ratio) * 100);
+          console.log(`${r.input} → ${r.output} (${formatSize(r.inputSize)} → ${formatSize(r.outputSize)}, ${reduction}% reduction)`);
+        }
+      } catch (e) {
+        if (!opts.json) console.error(`Error processing ${file}: ${(e as Error).message}`);
+      }
+    }
+
+    if (opts.json) {
+      const totalInput = results.reduce((s, r) => s + r.inputSize, 0);
+      const totalOutput = results.reduce((s, r) => s + r.outputSize, 0);
+      console.log(
+        JSON.stringify({
+          files: results,
+          summary: {
+            totalFiles: results.length,
+            totalInputSize: totalInput,
+            totalOutputSize: totalOutput,
+            ratio: totalInput > 0 ? totalOutput / totalInput : 0,
+            compressor,
+          },
+        }, null, 2)
+      );
+    } else {
+      const totalInput = results.reduce((s, r) => s + r.inputSize, 0);
+      const totalOutput = results.reduce((s, r) => s + r.outputSize, 0);
+      const reduction = Math.round((1 - totalOutput / totalInput) * 100);
+      console.log(`\nProcessed ${results.length} files: ${formatSize(totalInput)} → ${formatSize(totalOutput)} (${reduction}% reduction)`);
+    }
+  } else {
+    try {
+      const r = await processFile(compressor, input, opts);
+      if (opts.json) {
+        console.log(JSON.stringify(r, null, 2));
+      } else {
+        const reduction = Math.round((1 - r.ratio) * 100);
+        console.log(`${r.input} → ${r.output} (${formatSize(r.inputSize)} → ${formatSize(r.outputSize)}, ${reduction}% reduction)`);
+      }
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`);
+      process.exit(1);
+    }
+  }
+}
+
+main();
@@ -76,30 +76,36 @@ When no `--style` is specified, the system analyzes content to select the best s

 ### With Article Path

-Save to `imgs/` subdirectory in the same folder as the article:
+Save to `[source-name-no-ext]/cover-image/` subdirectory in the same folder as the article:

 ```
 path/to/
 ├── article.md
-└── imgs/
+└── article/
+    └── cover-image/
+        ├── prompts/
+        │   └── cover.md
+        └── cover.png
+```
+
+Example: `/posts/ai-future.md` → `/posts/ai-future/cover-image/`
+
+### Without Article Path (Pasted Content)
+
+Save to `./cover-image/[topic-slug]/`:
+
+```
+cover-image/
+└── ai-future/
+    ├── source.md           # Saved pasted content
    ├── prompts/
    │   └── cover.md
    └── cover.png
 ```

-### Without Article Path (Pasted Content)
+### Directory Backup

-Save to `cover-outputs/YYYY-MM-DD/[topic-slug]/`:
-
-```
-cover-outputs/
-└── 2026-01-17/
-    └── ai-future/
-        ├── source.md           # Saved pasted content
-        ├── prompts/
-        │   └── cover.md
-        └── cover.png
-```
+If target directory exists, rename existing to `<dirname>-backup-YYYYMMDD-HHMMSS`

 ## Workflow

@@ -246,3 +252,13 @@ Preview the image to verify it matches your expectations.
 - Image generation typically takes 10-30 seconds
 - Title text uses user's confirmed language preference
 - Aspect ratio: 2.35:1 for cinematic/dramatic, 16:9 for widescreen, 1:1 for social media
+
+## Extension Support
+
+Custom styles and configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-cover-image/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-cover-image/EXTEND.md` (user)
+
+If found, load before Step 1. Extension content overrides defaults.
@@ -0,0 +1,267 @@
+---
+name: baoyu-danger-gemini-web
+description: Image generation skill using Gemini Web. Generates images from text prompts via Google Gemini. Also supports text generation. Use as the image generation backend for other skills like cover-image, xhs-images, article-illustrator.
+---
+
+# Gemini Web Client
+
+Supports:
+- Text generation
+- Image generation (download + save)
+- Reference images for vision input (attach local images)
+- Multi-turn conversations via persisted `--sessionId`
+
+## Script Directory
+
+**Important**: All scripts are located in the `scripts/` subdirectory of this skill.
+
+**Agent Execution Instructions**:
+1. Determine this SKILL.md file's directory path as `SKILL_DIR`
+2. Script path = `${SKILL_DIR}/scripts/<script-name>.ts`
+3. Replace all `${SKILL_DIR}` in this document with the actual path
+
+**Script Reference**:
+| Script | Purpose |
+|--------|---------|
+| `scripts/main.ts` | CLI entry point for text/image generation |
+| `scripts/gemini-webapi/*` | TypeScript port of `gemini_webapi` (GeminiClient, types, utils) |
+
+## ⚠️ Disclaimer (REQUIRED)
+
+**Before using this skill**, the consent check MUST be performed.
+
+### Consent Check Flow
+
+**Step 1**: Check consent file
+
+```bash
+# macOS
+cat ~/Library/Application\ Support/baoyu-skills/gemini-web/consent.json 2>/dev/null
+
+# Linux
+cat ~/.local/share/baoyu-skills/gemini-web/consent.json 2>/dev/null
+
+# Windows (PowerShell)
+Get-Content "$env:APPDATA\baoyu-skills\gemini-web\consent.json" 2>$null
+```
+
+**Step 2**: If consent exists and `accepted: true` with matching `disclaimerVersion: "1.0"`:
+
+Print warning and proceed:
+```
+⚠️  Warning: Using reverse-engineered Gemini Web API (not official). Accepted on: <acceptedAt date>
+```
+
+**Step 3**: If consent file doesn't exist or `disclaimerVersion` mismatch:
+
+Display disclaimer and ask user:
+
+```
+⚠️  DISCLAIMER
+
+This tool uses a reverse-engineered Gemini Web API, NOT an official Google API.
+
+Risks:
+- May break without notice if Google changes their API
+- No official support or guarantees
+- Use at your own risk
+
+Do you accept these terms and wish to continue?
+```
+
+Use `AskUserQuestion` tool with options:
+- **Yes, I accept** - Continue and save consent
+- **No, I decline** - Exit immediately
+
+**Step 4**: On acceptance, create consent file:
+
+```bash
+# macOS
+mkdir -p ~/Library/Application\ Support/baoyu-skills/gemini-web
+cat > ~/Library/Application\ Support/baoyu-skills/gemini-web/consent.json << 'EOF'
+{
+  "version": 1,
+  "accepted": true,
+  "acceptedAt": "<ISO timestamp>",
+  "disclaimerVersion": "1.0"
+}
+EOF
+
+# Linux
+mkdir -p ~/.local/share/baoyu-skills/gemini-web
+cat > ~/.local/share/baoyu-skills/gemini-web/consent.json << 'EOF'
+{
+  "version": 1,
+  "accepted": true,
+  "acceptedAt": "<ISO timestamp>",
+  "disclaimerVersion": "1.0"
+}
+EOF
+```
+
+**Step 5**: On decline, output message and stop:
+```
+User declined the disclaimer. Exiting.
+```
+
+---
+
+## Quick start
+
+```bash
+npx -y bun ${SKILL_DIR}/scripts/main.ts "Hello, Gemini"
+npx -y bun ${SKILL_DIR}/scripts/main.ts --prompt "Explain quantum computing"
+npx -y bun ${SKILL_DIR}/scripts/main.ts --prompt "A cute cat" --image cat.png
+npx -y bun ${SKILL_DIR}/scripts/main.ts --promptfiles system.md content.md --image out.png
+
+# Multi-turn conversation (agent generates unique sessionId)
+npx -y bun ${SKILL_DIR}/scripts/main.ts "Remember this: 42" --sessionId my-unique-id-123
+npx -y bun ${SKILL_DIR}/scripts/main.ts "What number?" --sessionId my-unique-id-123
+```
+
+## Commands
+
+### Text generation
+
+```bash
+# Simple prompt (positional)
+npx -y bun ${SKILL_DIR}/scripts/main.ts "Your prompt here"
+
+# Explicit prompt flag
+npx -y bun ${SKILL_DIR}/scripts/main.ts --prompt "Your prompt here"
+npx -y bun ${SKILL_DIR}/scripts/main.ts -p "Your prompt here"
+
+# With model selection
+npx -y bun ${SKILL_DIR}/scripts/main.ts -p "Hello" -m gemini-2.5-pro
+
+# Pipe from stdin
+echo "Summarize this" | npx -y bun ${SKILL_DIR}/scripts/main.ts
+```
+
+### Image generation
+
+```bash
+# Generate image with default path (./generated.png)
+npx -y bun ${SKILL_DIR}/scripts/main.ts --prompt "A sunset over mountains" --image
+
+# Generate image with custom path
+npx -y bun ${SKILL_DIR}/scripts/main.ts --prompt "A cute robot" --image robot.png
+
+# Shorthand
+npx -y bun ${SKILL_DIR}/scripts/main.ts "A dragon" --image=dragon.png
+```
+
+### Vision input (reference images)
+
+```bash
+# Text + image -> text
+npx -y bun ${SKILL_DIR}/scripts/main.ts --prompt "Describe this image" --reference a.png
+
+# Text + image -> image
+npx -y bun ${SKILL_DIR}/scripts/main.ts --prompt "Generate a variation" --reference a.png --image out.png
+```
+
+### Output formats
+
+```bash
+# Plain text (default)
+npx -y bun ${SKILL_DIR}/scripts/main.ts "Hello"
+
+# JSON output
+npx -y bun ${SKILL_DIR}/scripts/main.ts "Hello" --json
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `--prompt <text>`, `-p` | Prompt text |
+| `--promptfiles <files...>` | Read prompt from files (concatenated in order) |
+| `--model <id>`, `-m` | Model: gemini-3-pro (default), gemini-2.5-pro, gemini-2.5-flash |
+| `--image [path]` | Generate image, save to path (default: generated.png) |
+| `--reference <files...>`, `--ref <files...>` | Reference images for vision input |
+| `--sessionId <id>` | Session ID for multi-turn conversation (agent generates unique ID) |
+| `--list-sessions` | List saved sessions (max 100, sorted by update time) |
+| `--json` | Output as JSON |
+| `--login` | Refresh cookies only, then exit |
+| `--cookie-path <path>` | Custom cookie file path |
+| `--profile-dir <path>` | Chrome profile directory |
+| `--help`, `-h` | Show help |
+
+CLI note: `scripts/main.ts` supports text generation, image generation, reference images (`--reference/--ref`), and multi-turn conversations via `--sessionId`.
+
+## Models
+
+- `gemini-3-pro` - Default, latest model
+- `gemini-2.5-pro` - Previous generation pro
+- `gemini-2.5-flash` - Fast, lightweight
+
+## Authentication
+
+First run opens Chrome to authenticate with Google. Cookies are cached for subsequent runs.
+
+```bash
+# Force cookie refresh
+npx -y bun ${SKILL_DIR}/scripts/main.ts --login
+```
+
+## Environment variables
+
+| Variable | Description |
+|----------|-------------|
+| `GEMINI_WEB_DATA_DIR` | Data directory |
+| `GEMINI_WEB_COOKIE_PATH` | Cookie file path |
+| `GEMINI_WEB_CHROME_PROFILE_DIR` | Chrome profile directory |
+| `GEMINI_WEB_CHROME_PATH` | Chrome executable path |
+
+## Examples
+
+### Generate text response
+```bash
+npx -y bun ${SKILL_DIR}/scripts/main.ts "What is the capital of France?"
+```
+
+### Generate image
+```bash
+npx -y bun ${SKILL_DIR}/scripts/main.ts "A photorealistic image of a golden retriever puppy" --image puppy.png
+```
+
+### Get JSON output for parsing
+```bash
+npx -y bun ${SKILL_DIR}/scripts/main.ts "Hello" --json | jq '.text'
+```
+
+### Generate image from prompt files
+```bash
+# Concatenate system.md + content.md as prompt
+npx -y bun ${SKILL_DIR}/scripts/main.ts --promptfiles system.md content.md --image output.png
+```
+
+### Multi-turn conversation
+```bash
+# Start a session with unique ID (agent generates this)
+npx -y bun ${SKILL_DIR}/scripts/main.ts "You are a helpful math tutor." --sessionId task-abc123
+
+# Continue the conversation (remembers context)
+npx -y bun ${SKILL_DIR}/scripts/main.ts "What is 2+2?" --sessionId task-abc123
+npx -y bun ${SKILL_DIR}/scripts/main.ts "Now multiply that by 10" --sessionId task-abc123
+
+# List recent sessions (max 100, sorted by update time)
+npx -y bun ${SKILL_DIR}/scripts/main.ts --list-sessions
+```
+
+Session files are stored in `~/Library/Application Support/baoyu-skills/gemini-web/sessions/<id>.json` and contain:
+- `id`: Session ID
+- `metadata`: Gemini chat metadata for continuation
+- `messages`: Array of `{role, content, timestamp, error?}`
+- `createdAt`, `updatedAt`: Timestamps
+
+## Extension Support
+
+Custom configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-danger-gemini-web/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-danger-gemini-web/EXTEND.md` (user)
+
+If found, load before workflow. Extension content overrides defaults.
@@ -0,0 +1,627 @@
+import { Endpoint, ErrorCode, Headers, Model } from './constants.js';
+import { GemMixin } from './components/gem-mixin.js';
+import {
+  APIError,
+  AuthError,
+  GeminiError,
+  ImageGenerationError,
+  ModelInvalid,
+  TemporarilyBlocked,
+  TimeoutError,
+  UsageLimitExceeded,
+} from './exceptions.js';
+import { Candidate, Gem, GeneratedImage, ModelOutput, RPCData, WebImage } from './types/index.js';
+import {
+  extract_json_from_response,
+  get_access_token,
+  get_nested_value,
+  logger,
+  parse_file_name,
+  rotate_1psidts,
+  rotate_tasks,
+  fetch_with_timeout,
+  sleep,
+  upload_file,
+  write_cookie_file,
+  resolveGeminiWebCookiePath,
+} from './utils/index.js';
+
+type InitOptions = {
+  timeout?: number;
+  auto_close?: boolean;
+  close_delay?: number;
+  auto_refresh?: boolean;
+  refresh_interval?: number;
+  verbose?: boolean;
+};
+
+type RequestKwargs = RequestInit & { timeout_ms?: number };
+
+function normalize_headers(h?: HeadersInit): Record<string, string> {
+  if (!h) return {};
+  if (Array.isArray(h)) return Object.fromEntries(h.map(([k, v]) => [k, v]));
+  if (h instanceof Headers) {
+    const out: Record<string, string> = {};
+    h.forEach((v, k) => {
+      out[k] = v;
+    });
+    return out;
+  }
+  return { ...(h as Record<string, string>) };
+}
+
+function collect_strings(root: unknown, accept: (s: string) => boolean, limit: number = 20): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  const stack: unknown[] = [root];
+
+  while (stack.length > 0 && out.length < limit) {
+    const v = stack.pop();
+    if (typeof v === 'string') {
+      if (accept(v) && !seen.has(v)) {
+        seen.add(v);
+        out.push(v);
+      }
+      continue;
+    }
+
+    if (Array.isArray(v)) {
+      for (let i = 0; i < v.length; i++) stack.push(v[i]);
+      continue;
+    }
+
+    if (v && typeof v === 'object') {
+      for (const val of Object.values(v as Record<string, unknown>)) stack.push(val);
+    }
+  }
+
+  return out;
+}
+
+export class GeminiClient extends GemMixin {
+  public cookies: Record<string, string> = {};
+  public proxy: string | null = null;
+  public _running: boolean = false;
+  public access_token: string | null = null;
+  public timeout: number = 300;
+  public auto_close: boolean = false;
+  public close_delay: number = 300;
+  public auto_refresh: boolean = true;
+  public refresh_interval: number = 540;
+  public kwargs: RequestInit;
+
+  private close_timer: ReturnType<typeof setTimeout> | null = null;
+  private refresh_abort: AbortController | null = null;
+
+  constructor(
+    secure_1psid: string | null = null,
+    secure_1psidts: string | null = null,
+    proxy: string | null = null,
+    kwargs: RequestInit = {},
+  ) {
+    super();
+    this.proxy = proxy;
+    this.kwargs = kwargs;
+
+    if (secure_1psid) {
+      this.cookies['__Secure-1PSID'] = secure_1psid;
+      if (secure_1psidts) this.cookies['__Secure-1PSIDTS'] = secure_1psidts;
+    }
+  }
+
+  async init(
+    timeoutOrOpts: number | InitOptions = 300,
+    auto_close: boolean = false,
+    close_delay: number = 300,
+    auto_refresh: boolean = true,
+    refresh_interval: number = 540,
+    verbose: boolean = true,
+  ): Promise<void> {
+    const opts: InitOptions =
+      typeof timeoutOrOpts === 'object'
+        ? timeoutOrOpts
+        : { timeout: timeoutOrOpts, auto_close, close_delay, auto_refresh, refresh_interval, verbose };
+
+    const timeout = opts.timeout ?? 300;
+    const ac = opts.auto_close ?? false;
+    const cd = opts.close_delay ?? 300;
+    const ar = opts.auto_refresh ?? true;
+    const ri = opts.refresh_interval ?? 540;
+    const vb = opts.verbose ?? true;
+
+    try {
+      const [token, valid] = await get_access_token(this.cookies, this.proxy, vb);
+      this.access_token = token;
+      this.cookies = valid;
+      this._running = true;
+
+      this.timeout = timeout;
+      this.auto_close = ac;
+      this.close_delay = cd;
+      if (this.auto_close) await this.reset_close_task();
+
+      this.auto_refresh = ar;
+      this.refresh_interval = ri;
+
+      const sid = this.cookies['__Secure-1PSID'];
+      if (sid) {
+        const existing = rotate_tasks.get(sid);
+        if (existing && existing instanceof AbortController) existing.abort();
+        rotate_tasks.delete(sid);
+      }
+
+      if (this.auto_refresh && sid) {
+        const ctl = new AbortController();
+        this.refresh_abort?.abort();
+        this.refresh_abort = ctl;
+        rotate_tasks.set(sid, ctl);
+        void this.start_auto_refresh(ctl.signal);
+      }
+
+      await write_cookie_file(this.cookies, resolveGeminiWebCookiePath(), 'client').catch(() => {});
+
+      if (vb) logger.success('Gemini client initialized successfully.');
+    } catch (e) {
+      await this.close();
+      throw e;
+    }
+  }
+
+  async close(delay: number = 0): Promise<void> {
+    if (delay > 0) await sleep(delay * 1000);
+    this._running = false;
+
+    if (this.close_timer) {
+      clearTimeout(this.close_timer);
+      this.close_timer = null;
+    }
+
+    this.refresh_abort?.abort();
+    this.refresh_abort = null;
+
+    const sid = this.cookies['__Secure-1PSID'];
+    const t = sid ? rotate_tasks.get(sid) : null;
+    if (t && t instanceof AbortController) t.abort();
+    if (sid) rotate_tasks.delete(sid);
+  }
+
+  async reset_close_task(): Promise<void> {
+    if (this.close_timer) {
+      clearTimeout(this.close_timer);
+      this.close_timer = null;
+    }
+
+    this.close_timer = setTimeout(() => {
+      void this.close(0);
+    }, this.close_delay * 1000);
+    this.close_timer.unref?.();
+  }
+
+  async start_auto_refresh(signal: AbortSignal): Promise<void> {
+    while (!signal.aborted) {
+      let newTs: string | null = null;
+      try {
+        newTs = await rotate_1psidts(this.cookies, this.proxy);
+      } catch (e) {
+        if (e instanceof AuthError) {
+          logger.warning('AuthError: Failed to refresh cookies. Auto refresh task canceled.');
+          return;
+        }
+        logger.warning(`Unexpected error while refreshing cookies: ${e instanceof Error ? e.message : String(e)}`);
+      }
+
+      if (newTs) {
+        this.cookies['__Secure-1PSIDTS'] = newTs;
+        await write_cookie_file(this.cookies, resolveGeminiWebCookiePath(), 'refresh').catch(() => {});
+        logger.debug('Cookies refreshed. New __Secure-1PSIDTS applied.');
+      }
+
+      await sleep(this.refresh_interval * 1000, signal);
+    }
+  }
+
+  protected async _run<T>(fn: () => Promise<T>, retry: number): Promise<T> {
+    try {
+      if (!this._running) {
+        await this.init({
+          timeout: this.timeout,
+          auto_close: this.auto_close,
+          close_delay: this.close_delay,
+          auto_refresh: this.auto_refresh,
+          refresh_interval: this.refresh_interval,
+          verbose: false,
+        });
+
+        if (!this._running) {
+          throw new APIError('Client initialization failed.');
+        }
+      }
+
+      return await fn();
+    } catch (e) {
+      let r = retry;
+      if (e instanceof ImageGenerationError) r = Math.min(1, r);
+      if (e instanceof APIError && r > 0) {
+        await sleep(1000);
+        return await this._run(fn, r - 1);
+      }
+      throw e;
+    }
+  }
+
+  async generate_content(
+    prompt: string,
+    files: string[] | null = null,
+    model: Model | string | Record<string, unknown> = Model.UNSPECIFIED,
+    gem: Gem | string | null = null,
+    chat: ChatSession | null = null,
+    kwargs: RequestKwargs = {},
+  ): Promise<ModelOutput> {
+    return await this._run(async () => {
+      if (!prompt) throw new Error('Prompt cannot be empty.');
+
+      let mdl: Model;
+      if (typeof model === 'string') mdl = Model.from_name(model);
+      else if (model instanceof Model) mdl = model;
+      else if (model && typeof model === 'object') mdl = Model.from_dict(model);
+      else throw new TypeError(`'model' must be a Model instance, string, or dictionary; got ${typeof model}`);
+
+      const gem_id = gem instanceof Gem ? gem.id : gem;
+
+      if (this.auto_close) await this.reset_close_task();
+
+      if (!this.access_token) throw new APIError('Missing access token.');
+
+      const f = files?.length ? files : null;
+      const uploaded =
+        f &&
+        (await Promise.all(
+          f.map(async (p) => [[await upload_file(p, this.proxy)], parse_file_name(p)] as [string[], string]),
+        ));
+
+      const first = uploaded ? [prompt, 0, null, uploaded] : [prompt];
+      const inner: unknown[] = [first, null, chat ? chat.metadata : null];
+
+      if (gem_id) {
+        for (let i = 0; i < 16; i++) inner.push(null);
+        inner.push(gem_id);
+      }
+
+      const f_req = JSON.stringify([null, JSON.stringify(inner)]);
+      const body = new URLSearchParams({ at: this.access_token, 'f.req': f_req }).toString();
+
+      const h0 = { ...Headers.GEMINI, ...mdl.model_header, Cookie: Object.entries(this.cookies).map(([k, v]) => `${k}=${v}`).join('; ') };
+      const h1 = { ...h0, ...normalize_headers(kwargs.headers) };
+
+      let res: Response;
+      try {
+        const timeout_ms = typeof kwargs.timeout_ms === 'number' ? kwargs.timeout_ms : this.timeout * 1000;
+        const { timeout_ms: _t, ...rest } = kwargs;
+        res = await fetch_with_timeout(Endpoint.GENERATE, {
+          method: 'POST',
+          headers: h1,
+          body,
+          redirect: 'follow',
+          ...this.kwargs,
+          ...rest,
+          timeout_ms,
+        });
+      } catch (e) {
+        throw new TimeoutError(
+          `Generate content request timed out, please try again. If the problem persists, consider setting a higher 'timeout' value when initializing GeminiClient. (${e instanceof Error ? e.message : String(e)})`,
+        );
+      }
+
+      if (res.status !== 200) {
+        await this.close();
+        throw new APIError(`Failed to generate contents. Request failed with status code ${res.status}`);
+      }
+
+      const txt = await res.text();
+      const response_json = extract_json_from_response(txt);
+
+      let body_json: unknown[] | null = null;
+      let body_index = 0;
+
+      try {
+        if (!Array.isArray(response_json)) throw new Error('Invalid JSON');
+        for (let part_index = 0; part_index < response_json.length; part_index++) {
+          const part = response_json[part_index];
+          if (!Array.isArray(part)) continue;
+          const part_body = get_nested_value<string | null>(part, [2], null);
+          if (!part_body) continue;
+          try {
+            const part_json = JSON.parse(part_body) as unknown[];
+            if (get_nested_value(part_json, [4], null)) {
+              body_index = part_index;
+              body_json = part_json;
+              break;
+            }
+          } catch {}
+        }
+        if (!body_json) throw new Error('No body');
+      } catch {
+        await this.close();
+        try {
+          const code = get_nested_value<number>(response_json, [0, 5, 2, 0, 1, 0], -1);
+          if (code === ErrorCode.USAGE_LIMIT_EXCEEDED) {
+            throw new UsageLimitExceeded(
+              `Failed to generate contents. Usage limit of ${mdl.model_name} model has exceeded. Please try switching to another model.`,
+            );
+          }
+          if (code === ErrorCode.MODEL_INCONSISTENT) {
+            throw new ModelInvalid(
+              'Failed to generate contents. The specified model is inconsistent with the chat history. Please make sure to pass the same `model` parameter when starting a chat session with previous metadata.',
+            );
+          }
+          if (code === ErrorCode.MODEL_HEADER_INVALID) {
+            throw new ModelInvalid(
+              'Failed to generate contents. The specified model is not available. Please update gemini_webapi to the latest version. If the error persists and is caused by the package, please report it on GitHub.',
+            );
+          }
+          if (code === ErrorCode.IP_TEMPORARILY_BLOCKED) {
+            throw new TemporarilyBlocked(
+              'Failed to generate contents. Your IP address is temporarily blocked by Google. Please try using a proxy or waiting for a while.',
+            );
+          }
+        } catch (e) {
+          if (e instanceof GeminiError) throw e;
+        }
+
+        logger.debug(`Invalid response: ${txt.slice(0, 500)}`);
+        throw new APIError('Failed to generate contents. Invalid response data received. Client will try to re-initialize on next request.');
+      }
+
+      try {
+        const candidate_list = get_nested_value<unknown[]>(body_json, [4], []);
+        const out: Candidate[] = [];
+
+        for (let candidate_index = 0; candidate_index < candidate_list.length; candidate_index++) {
+          const candidate = candidate_list[candidate_index];
+          if (!Array.isArray(candidate)) continue;
+
+          const rcid = get_nested_value<string | null>(candidate, [0], null);
+          if (!rcid) continue;
+
+          let text = String(get_nested_value(candidate, [1, 0], ''));
+          if (/^http:\/\/googleusercontent\.com\/card_content\/\d+/.test(text)) {
+            text = String(get_nested_value(candidate, [22, 0], text));
+          }
+
+          const thoughts = get_nested_value<string | null>(candidate, [37, 0, 0], null);
+
+          const web_images: WebImage[] = [];
+          for (const w of get_nested_value<unknown[]>(candidate, [12, 1], [])) {
+            if (!Array.isArray(w)) continue;
+            const url = get_nested_value<string | null>(w, [0, 0, 0], null);
+            if (!url) continue;
+            web_images.push(new WebImage(url, String(get_nested_value(w, [7, 0], '')), String(get_nested_value(w, [0, 4], '')), this.proxy));
+          }
+
+          const generated_images: GeneratedImage[] = [];
+          const wants_generated =
+            get_nested_value(candidate, [12, 7, 0], null) != null ||
+            /http:\/\/googleusercontent\.com\/image_generation_content\/\d+/.test(text);
+
+          if (wants_generated) {
+            let img_body: unknown[] | null = null;
+            for (let part_index = body_index; part_index < (response_json as unknown[]).length; part_index++) {
+              const part = (response_json as unknown[])[part_index];
+              if (!Array.isArray(part)) continue;
+              const part_body = get_nested_value<string | null>(part, [2], null);
+              if (!part_body) continue;
+              try {
+                const part_json = JSON.parse(part_body) as unknown[];
+                const cand = get_nested_value<unknown>(part_json, [4, candidate_index], null);
+                if (!cand) continue;
+
+                const urls = collect_strings(cand, (s) => s.startsWith('https://lh3.googleusercontent.com/gg-dl/'), 1);
+                if (urls.length > 0) {
+                  img_body = part_json;
+                  break;
+                }
+              } catch {}
+            }
+
+            if (!img_body) {
+              throw new ImageGenerationError(
+                'Failed to parse generated images. Please update gemini_webapi to the latest version. If the error persists and is caused by the package, please report it on GitHub.',
+              );
+            }
+
+            const img_candidate = get_nested_value<unknown[]>(img_body, [4, candidate_index], []);
+            const finished = get_nested_value<string | null>(img_candidate, [1, 0], null);
+            if (finished) {
+              text = finished.replace(/http:\/\/googleusercontent\.com\/image_generation_content\/\d+/g, '').trimEnd();
+            }
+
+            const gen = get_nested_value<unknown[]>(img_candidate, [12, 7, 0], []);
+            for (let img_index = 0; img_index < gen.length; img_index++) {
+              const g = gen[img_index];
+              if (!Array.isArray(g)) continue;
+              const url = get_nested_value<string | null>(g, [0, 3, 3], null);
+              if (!url) continue;
+              const img_num = get_nested_value<number | null>(g, [3, 6], null);
+              const title = img_num ? `[Generated Image ${img_num}]` : '[Generated Image]';
+              const alt_list = get_nested_value<unknown[]>(g, [3, 5], []);
+              const alt =
+                (typeof alt_list[img_index] === 'string' ? (alt_list[img_index] as string) : null) ??
+                (typeof alt_list[0] === 'string' ? (alt_list[0] as string) : '') ??
+                '';
+              generated_images.push(new GeneratedImage(url, title, alt, this.proxy, this.cookies));
+            }
+
+            if (generated_images.length === 0) {
+              const urls = collect_strings(img_candidate, (s) => s.startsWith('https://lh3.googleusercontent.com/gg-dl/'), 4);
+              for (const url of urls) {
+                generated_images.push(new GeneratedImage(url, '[Generated Image]', '', this.proxy, this.cookies));
+              }
+            }
+          }
+
+          out.push(new Candidate({ rcid, text, thoughts, web_images, generated_images }));
+        }
+
+        if (out.length === 0) {
+          throw new GeminiError('Failed to generate contents. No output data found in response.');
+        }
+
+        const metadata = get_nested_value<string[]>(body_json, [1], []);
+        const output = new ModelOutput({ metadata, candidates: out });
+
+        if (chat instanceof ChatSession) chat.last_output = output;
+        return output;
+      } catch (e) {
+        if (e instanceof GeminiError || e instanceof APIError) throw e;
+        throw new APIError('Failed to parse response body. Data structure is invalid.');
+      }
+    }, 2);
+  }
+
+  async generateContent(
+    prompt: string,
+    files?: string[] | null,
+    model?: Model | string | Record<string, unknown>,
+    gem?: Gem | string | null,
+    chat?: ChatSession | null,
+    kwargs?: RequestKwargs,
+  ): Promise<ModelOutput> {
+    return await this.generate_content(prompt, files ?? null, model ?? Model.UNSPECIFIED, gem ?? null, chat ?? null, kwargs ?? {});
+  }
+
+  start_chat(opts?: ConstructorParameters<typeof ChatSession>[1]): ChatSession {
+    return new ChatSession(this, opts);
+  }
+
+  startChat(opts?: ConstructorParameters<typeof ChatSession>[1]): ChatSession {
+    return this.start_chat(opts);
+  }
+
+  protected async _batch_execute(payloads: RPCData[], opts: RequestInit = {}): Promise<Response> {
+    if (!this.access_token) throw new APIError('Missing access token.');
+
+    const f_req = JSON.stringify([payloads.map((p) => p.serialize())]);
+    const body = new URLSearchParams({ at: this.access_token, 'f.req': f_req }).toString();
+
+    const h0 = { ...Headers.GEMINI, Cookie: Object.entries(this.cookies).map(([k, v]) => `${k}=${v}`).join('; ') };
+    const h1 = { ...h0, ...normalize_headers(opts.headers) };
+
+    const res = await fetch_with_timeout(Endpoint.BATCH_EXEC, {
+      method: 'POST',
+      headers: h1,
+      body,
+      redirect: 'follow',
+      ...this.kwargs,
+      ...opts,
+      timeout_ms: this.timeout * 1000,
+    });
+
+    if (res.status !== 200) {
+      await this.close();
+      throw new APIError(`Batch execution failed with status code ${res.status}`);
+    }
+
+    return res;
+  }
+}
+
+export class ChatSession {
+  private __metadata: Array<string | null> = [null, null, null];
+  public geminiclient: GeminiClient;
+  private _last_output: ModelOutput | null = null;
+  public model: Model | string | Record<string, unknown>;
+  public gem: Gem | string | null;
+
+  constructor(
+    geminiclient: GeminiClient,
+    opts: {
+      metadata?: Array<string | null>;
+      cid?: string | null;
+      rid?: string | null;
+      rcid?: string | null;
+      model?: Model | string | Record<string, unknown>;
+      gem?: Gem | string | null;
+    } = {},
+  ) {
+    this.geminiclient = geminiclient;
+    this.model = opts.model ?? Model.UNSPECIFIED;
+    this.gem = opts.gem ?? null;
+
+    if (opts.metadata) this.metadata = opts.metadata;
+    if (opts.cid) this.cid = opts.cid;
+    if (opts.rid) this.rid = opts.rid;
+    if (opts.rcid) this.rcid = opts.rcid;
+  }
+
+  toString(): string {
+    return `ChatSession(cid='${this.cid}', rid='${this.rid}', rcid='${this.rcid}')`;
+  }
+
+  get last_output(): ModelOutput | null {
+    return this._last_output;
+  }
+
+  set last_output(v: ModelOutput | null) {
+    this._last_output = v;
+    if (v) {
+      this.metadata = (v.metadata ?? []) as Array<string | null>;
+      this.rcid = v.rcid;
+    }
+  }
+
+  async send_message(prompt: string, files: string[] | null = null, kwargs: RequestKwargs = {}): Promise<ModelOutput> {
+    return await this.geminiclient.generate_content(prompt, files, this.model, this.gem, this, kwargs);
+  }
+
+  async sendMessage(prompt: string, files?: string[] | null, kwargs?: RequestKwargs): Promise<ModelOutput> {
+    return await this.send_message(prompt, files ?? null, kwargs ?? {});
+  }
+
+  choose_candidate(index: number): ModelOutput {
+    if (!this.last_output) throw new Error('No previous output data found in this chat session.');
+    if (index >= this.last_output.candidates.length) {
+      throw new Error(`Index ${index} exceeds the number of candidates in last model output.`);
+    }
+    this.last_output.chosen = index;
+    this.rcid = this.last_output.rcid;
+    return this.last_output;
+  }
+
+  chooseCandidate(index: number): ModelOutput {
+    return this.choose_candidate(index);
+  }
+
+  get metadata(): Array<string | null> {
+    return this.__metadata;
+  }
+
+  set metadata(v: Array<string | null>) {
+    if (v.length > 3) throw new Error('metadata cannot exceed 3 elements');
+    this.__metadata = [null, null, null];
+    for (let i = 0; i < v.length; i++) this.__metadata[i] = v[i] ?? null;
+  }
+
+  get cid(): string | null {
+    return this.__metadata[0];
+  }
+
+  set cid(v: string | null) {
+    this.__metadata[0] = v;
+  }
+
+  get rid(): string | null {
+    return this.__metadata[1];
+  }
+
+  set rid(v: string | null) {
+    this.__metadata[1] = v;
+  }
+
+  get rcid(): string | null {
+    return this.__metadata[2];
+  }
+
+  set rcid(v: string | null) {
+    this.__metadata[2] = v;
+  }
+}
@@ -0,0 +1,179 @@
+import { GRPC } from '../constants.js';
+import { APIError } from '../exceptions.js';
+import { Gem, GemJar, RPCData } from '../types/index.js';
+import { logger } from '../utils/logger.js';
+import { extract_json_from_response, get_nested_value } from '../utils/parsing.js';
+
+export abstract class GemMixin {
+  protected _gems: GemJar | null = null;
+
+  protected abstract _run<T>(fn: () => Promise<T>, retry: number): Promise<T>;
+  protected abstract _batch_execute(payloads: RPCData[], opts?: RequestInit): Promise<Response>;
+  protected abstract close(delay?: number): Promise<void>;
+
+  get gems(): GemJar {
+    if (this._gems == null) {
+      throw new Error(
+        'Gems not fetched yet. Call `GeminiClient.fetch_gems()` method to fetch gems from gemini.google.com.',
+      );
+    }
+    return this._gems;
+  }
+
+  async fetch_gems(include_hidden: boolean = false, opts?: RequestInit): Promise<GemJar> {
+    return await this._run(async () => {
+      const res = await this._batch_execute(
+        [
+          new RPCData(GRPC.LIST_GEMS, include_hidden ? '[4]' : '[3]', 'system'),
+          new RPCData(GRPC.LIST_GEMS, '[2]', 'custom'),
+        ],
+        opts,
+      );
+
+      let response_json: unknown;
+      try {
+        response_json = extract_json_from_response(await res.text());
+        if (!Array.isArray(response_json)) throw new Error('Invalid response');
+      } catch {
+        await this.close();
+        throw new APIError('Failed to fetch gems. Invalid response data received. Client will try to re-initialize on next request.');
+      }
+
+      let predefined: unknown[] = [];
+      let custom: unknown[] = [];
+
+      try {
+        for (const part of response_json as unknown[]) {
+          if (!Array.isArray(part)) continue;
+          const ident = part[part.length - 1];
+          const body = get_nested_value<string | null>(part, [2], null);
+          if (!body) continue;
+
+          if (ident === 'system') {
+            const parsed = JSON.parse(body) as unknown[];
+            predefined = (Array.isArray(parsed) ? (parsed[2] as unknown[]) : []) ?? [];
+          } else if (ident === 'custom') {
+            const parsed = JSON.parse(body) as unknown[] | null;
+            if (parsed) custom = (parsed[2] as unknown[]) ?? [];
+          }
+        }
+
+        if (predefined.length === 0 && custom.length === 0) throw new Error('No gems');
+      } catch {
+        await this.close();
+        logger.debug('Invalid response while parsing gems');
+        throw new APIError('Failed to fetch gems. Invalid response data received. Client will try to re-initialize on next request.');
+      }
+
+      const entries: [string, Gem][] = [];
+
+      for (const gem of predefined) {
+        if (!Array.isArray(gem)) continue;
+        const id = String(get_nested_value(gem, [0], ''));
+        if (!id) continue;
+        entries.push([
+          id,
+          new Gem(
+            id,
+            String(get_nested_value(gem, [1, 0], '')),
+            get_nested_value<string | null>(gem, [1, 1], null),
+            get_nested_value<string | null>(gem, [2, 0], null),
+            true,
+          ),
+        ]);
+      }
+
+      for (const gem of custom) {
+        if (!Array.isArray(gem)) continue;
+        const id = String(get_nested_value(gem, [0], ''));
+        if (!id) continue;
+        entries.push([
+          id,
+          new Gem(
+            id,
+            String(get_nested_value(gem, [1, 0], '')),
+            get_nested_value<string | null>(gem, [1, 1], null),
+            get_nested_value<string | null>(gem, [2, 0], null),
+            false,
+          ),
+        ]);
+      }
+
+      this._gems = new GemJar(entries);
+      return this._gems;
+    }, 2);
+  }
+
+  async create_gem(name: string, prompt: string, description: string = ''): Promise<Gem> {
+    return await this._run(async () => {
+      const payload = JSON.stringify([
+        [
+          name,
+          description,
+          prompt,
+          null,
+          null,
+          null,
+          null,
+          null,
+          0,
+          null,
+          1,
+          null,
+          null,
+          null,
+          [],
+        ],
+      ]);
+
+      const res = await this._batch_execute([new RPCData(GRPC.CREATE_GEM, payload)]);
+      try {
+        const response_json = extract_json_from_response(await res.text()) as unknown[];
+        const gem_id = JSON.parse(String((response_json[0] as unknown[])[2]))[0] as string;
+        return new Gem(gem_id, name, description, prompt, false);
+      } catch {
+        await this.close();
+        throw new APIError('Failed to create gem. Invalid response data received. Client will try to re-initialize on next request.');
+      }
+    }, 2);
+  }
+
+  async update_gem(gem: Gem | string, name: string, prompt: string, description: string = ''): Promise<Gem> {
+    return await this._run(async () => {
+      const gem_id = typeof gem === 'string' ? gem : gem.id;
+      const payload = JSON.stringify([
+        gem_id,
+        [
+          name,
+          description,
+          prompt,
+          null,
+          null,
+          null,
+          null,
+          null,
+          0,
+          null,
+          1,
+          null,
+          null,
+          null,
+          [],
+          0,
+        ],
+      ]);
+
+      await this._batch_execute([new RPCData(GRPC.UPDATE_GEM, payload)]);
+      return new Gem(gem_id, name, description, prompt, false);
+    }, 2);
+  }
+
+  async delete_gem(gem: Gem | string, opts?: RequestInit): Promise<void> {
+    return await this._run(async () => {
+      const gem_id = typeof gem === 'string' ? gem : gem.id;
+      const payload = JSON.stringify([gem_id]);
+      await this._batch_execute([new RPCData(GRPC.DELETE_GEM, payload)], opts);
+    }, 2);
+  }
+}
+
@@ -0,0 +1,2 @@
+export { GemMixin } from './gem-mixin.js';
+
@@ -0,0 +1,107 @@
+export const Endpoint = {
+  GOOGLE: 'https://www.google.com',
+  INIT: 'https://gemini.google.com/app',
+  GENERATE:
+    'https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate',
+  ROTATE_COOKIES: 'https://accounts.google.com/RotateCookies',
+  UPLOAD: 'https://content-push.googleapis.com/upload',
+  BATCH_EXEC: 'https://gemini.google.com/_/BardChatUi/data/batchexecute',
+} as const;
+
+export const GRPC = {
+  LIST_CHATS: 'MaZiqc',
+  READ_CHAT: 'hNvQHb',
+  LIST_GEMS: 'CNgdBe',
+  CREATE_GEM: 'oMH3Zd',
+  UPDATE_GEM: 'kHv0Vd',
+  DELETE_GEM: 'UXcSJb',
+} as const;
+
+export const Headers = {
+  GEMINI: {
+    'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
+    Host: 'gemini.google.com',
+    Origin: 'https://gemini.google.com',
+    Referer: 'https://gemini.google.com/',
+    'User-Agent':
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'X-Same-Domain': '1',
+  },
+  ROTATE_COOKIES: {
+    'Content-Type': 'application/json',
+  },
+  UPLOAD: {
+    'Push-ID': 'feeds/mcudyrk2a4khkz',
+  },
+} as const;
+
+export const ErrorCode = {
+  TEMPORARY_ERROR_1013: 1013,
+  USAGE_LIMIT_EXCEEDED: 1037,
+  MODEL_INCONSISTENT: 1050,
+  MODEL_HEADER_INVALID: 1052,
+  IP_TEMPORARILY_BLOCKED: 1060,
+} as const;
+
+export class Model {
+  static readonly UNSPECIFIED = new Model('unspecified', {}, false);
+  static readonly G_3_0_PRO = new Model(
+    'gemini-3.0-pro',
+    { 'x-goog-ext-525001261-jspb': '[1,null,null,null,"9d8ca3786ebdfbea",null,null,0,[4]]' },
+    false,
+  );
+  static readonly G_2_5_PRO = new Model(
+    'gemini-2.5-pro',
+    { 'x-goog-ext-525001261-jspb': '[1,null,null,null,"4af6c7f5da75d65d",null,null,0,[4]]' },
+    false,
+  );
+  static readonly G_2_5_FLASH = new Model(
+    'gemini-2.5-flash',
+    { 'x-goog-ext-525001261-jspb': '[1,null,null,null,"9ec249fc9ad08861",null,null,0,[4]]' },
+    false,
+  );
+
+  constructor(
+    public readonly model_name: string,
+    public readonly model_header: Record<string, string>,
+    public readonly advanced_only: boolean,
+  ) {}
+
+  static from_name(name: string): Model {
+    for (const model of [Model.UNSPECIFIED, Model.G_3_0_PRO, Model.G_2_5_PRO, Model.G_2_5_FLASH]) {
+      if (model.model_name === name) return model;
+    }
+
+    throw new Error(
+      `Unknown model name: ${name}. Available models: ${[Model.UNSPECIFIED, Model.G_3_0_PRO, Model.G_2_5_PRO, Model.G_2_5_FLASH]
+        .map((m) => m.model_name)
+        .join(', ')}`,
+    );
+  }
+
+  static from_dict(model_dict: { model_name?: unknown; model_header?: unknown }): Model {
+    if (!model_dict || typeof model_dict !== 'object') {
+      throw new Error("When passing a custom model as a dictionary, 'model_name' and 'model_header' keys must be provided.");
+    }
+
+    if (!('model_name' in model_dict) || !('model_header' in model_dict)) {
+      throw new Error("When passing a custom model as a dictionary, 'model_name' and 'model_header' keys must be provided.");
+    }
+
+    if (typeof model_dict.model_name !== 'string' || !model_dict.model_name.trim()) {
+      throw new Error("When passing a custom model as a dictionary, 'model_name' must be a non-empty string.");
+    }
+
+    if (!model_dict.model_header || typeof model_dict.model_header !== 'object') {
+      throw new Error("When passing a custom model as a dictionary, 'model_header' must be a dictionary containing valid header strings.");
+    }
+
+    const header: Record<string, string> = {};
+    for (const [k, v] of Object.entries(model_dict.model_header as Record<string, unknown>)) {
+      if (typeof v === 'string') header[k] = v;
+    }
+
+    return new Model(model_dict.model_name, header, false);
+  }
+}
+
@@ -0,0 +1,56 @@
+export class AuthError extends Error {
+  constructor(message = 'AuthError') {
+    super(message);
+    this.name = 'AuthError';
+  }
+}
+
+export class APIError extends Error {
+  constructor(message = 'APIError') {
+    super(message);
+    this.name = 'APIError';
+  }
+}
+
+export class ImageGenerationError extends APIError {
+  constructor(message = 'ImageGenerationError') {
+    super(message);
+    this.name = 'ImageGenerationError';
+  }
+}
+
+export class GeminiError extends Error {
+  constructor(message = 'GeminiError') {
+    super(message);
+    this.name = 'GeminiError';
+  }
+}
+
+export class TimeoutError extends GeminiError {
+  constructor(message = 'TimeoutError') {
+    super(message);
+    this.name = 'TimeoutError';
+  }
+}
+
+export class UsageLimitExceeded extends GeminiError {
+  constructor(message = 'UsageLimitExceeded') {
+    super(message);
+    this.name = 'UsageLimitExceeded';
+  }
+}
+
+export class ModelInvalid extends GeminiError {
+  constructor(message = 'ModelInvalid') {
+    super(message);
+    this.name = 'ModelInvalid';
+  }
+}
+
+export class TemporarilyBlocked extends GeminiError {
+  constructor(message = 'TemporarilyBlocked') {
+    super(message);
+    this.name = 'TemporarilyBlocked';
+  }
+}
+
@@ -0,0 +1,8 @@
+export { GeminiClient, ChatSession } from './client.js';
+
+export * from './exceptions.js';
+export * from './types/index.js';
+export * from './constants.js';
+export { logger, set_log_level, setLogLevel } from './utils/logger.js';
+export * as utils from './utils/index.js';
+
@@ -0,0 +1,45 @@
+import { GeneratedImage, type Image, WebImage } from './image.js';
+
+function decode_html(s: string | null | undefined): string | null | undefined {
+  if (s == null) return s;
+  return s
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(parseInt(dec, 10)));
+}
+
+export class Candidate {
+  public rcid: string;
+  public text: string;
+  public thoughts: string | null;
+  public web_images: WebImage[];
+  public generated_images: GeneratedImage[];
+
+  constructor(params: {
+    rcid: string;
+    text: string;
+    thoughts?: string | null;
+    web_images?: WebImage[];
+    generated_images?: GeneratedImage[];
+  }) {
+    this.rcid = params.rcid;
+    this.text = decode_html(params.text) ?? '';
+    this.thoughts = decode_html(params.thoughts) ?? null;
+    this.web_images = params.web_images ?? [];
+    this.generated_images = params.generated_images ?? [];
+  }
+
+  toString(): string {
+    return this.text;
+  }
+
+  get images(): Image[] {
+    return [...this.web_images, ...this.generated_images];
+  }
+}
@@ -0,0 +1,75 @@
+export class Gem {
+  constructor(
+    public id: string,
+    public name: string,
+    public description: string | null,
+    public prompt: string | null,
+    public predefined: boolean,
+  ) {}
+
+  toString(): string {
+    return `Gem(id='${this.id}', name='${this.name}', description='${this.description}', prompt='${this.prompt}', predefined=${this.predefined})`;
+  }
+}
+
+export class GemJar implements Iterable<Gem> {
+  private m = new Map<string, Gem>();
+
+  constructor(entries?: Iterable<[string, Gem]>) {
+    if (entries) for (const [id, gem] of entries) this.m.set(id, gem);
+  }
+
+  [Symbol.iterator](): Iterator<Gem> {
+    return this.m.values();
+  }
+
+  entries(): IterableIterator<[string, Gem]> {
+    return this.m.entries();
+  }
+
+  values(): IterableIterator<Gem> {
+    return this.m.values();
+  }
+
+  has(id: string): boolean {
+    return this.m.has(id);
+  }
+
+  set(id: string, gem: Gem): this {
+    this.m.set(id, gem);
+    return this;
+  }
+
+  get(id?: string | null, name?: string | null, def: Gem | null = null): Gem | null {
+    if (id == null && name == null) {
+      throw new Error('At least one of gem id or name must be provided.');
+    }
+
+    if (id != null) {
+      const g = this.m.get(id) ?? null;
+      if (!g) return def;
+      if (name != null) return g.name === name ? g : def;
+      return g;
+    }
+
+    if (name != null) {
+      for (const g of this.m.values()) {
+        if (g.name === name) return g;
+      }
+      return def;
+    }
+
+    return def;
+  }
+
+  filter(predefined: boolean | null = null, name: string | null = null): GemJar {
+    const out: [string, Gem][] = [];
+    for (const [id, gem] of this.m.entries()) {
+      if (predefined != null && gem.predefined !== predefined) continue;
+      if (name != null && gem.name !== name) continue;
+      out.push([id, gem]);
+    }
+    return new GemJar(out);
+  }
+}
+
@@ -0,0 +1,16 @@
+export class RPCData {
+  constructor(
+    public rpcid: string,
+    public payload: string,
+    public identifier: string = 'generic',
+  ) {}
+
+  toString(): string {
+    return `GRPC(rpcid='${this.rpcid}', payload='${this.payload}', identifier='${this.identifier}')`;
+  }
+
+  serialize(): unknown[] {
+    return [this.rpcid, this.payload, null, this.identifier];
+  }
+}
+
@@ -0,0 +1,114 @@
+import path from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+
+import { logger } from '../utils/logger.js';
+import { cookie_header, fetch_with_timeout } from '../utils/http.js';
+
+export class Image {
+  constructor(
+    public url: string,
+    public title = '[Image]',
+    public alt = '',
+    public proxy: string | null = null,
+  ) {}
+
+  toString(): string {
+    const u = this.url.length <= 20 ? this.url : `${this.url.slice(0, 8)}...${this.url.slice(-12)}`;
+    return `Image(title='${this.title}', alt='${this.alt}', url='${u}')`;
+  }
+
+  async save(
+    p: string = 'temp',
+    filename: string | null = null,
+    cookies: Record<string, string> | null = null,
+    verbose: boolean = false,
+    skip_invalid_filename: boolean = false,
+  ): Promise<string | null> {
+    filename = filename ?? this.url.split('/').pop()?.split('?')[0] ?? 'image';
+    const m = filename.match(/^(.*\.\w+)/);
+    if (m) filename = m[1]!;
+    else {
+      if (verbose) logger.warning(`Invalid filename: ${filename}`);
+      if (skip_invalid_filename) return null;
+    }
+
+    const headers: Record<string, string> = {
+      'User-Agent': 'Mozilla/5.0',
+      Accept: 'image/avif,image/webp,image/apng,image/*,*/*;q=0.8',
+      Referer: 'https://gemini.google.com/',
+    };
+    if (cookies) headers.Cookie = cookie_header(cookies);
+
+    let url = this.url;
+    let res: Response | null = null;
+    for (let i = 0; i < 10; i++) {
+      res = await fetch_with_timeout(url, {
+        method: 'GET',
+        headers,
+        redirect: 'manual',
+        timeout_ms: 30_000,
+      });
+
+      if (res.status >= 300 && res.status < 400) {
+        const loc = res.headers.get('location');
+        if (!loc) break;
+        url = new URL(loc, url).toString();
+        continue;
+      }
+
+      break;
+    }
+
+    if (!res) throw new Error('Image download failed: no response');
+
+    if (!res.ok) {
+      throw new Error(`Error downloading image: ${res.status} ${res.statusText}`);
+    }
+
+    const ct = res.headers.get('content-type');
+    if (ct && !ct.includes('image')) {
+      logger.warning(`Content type of ${filename} is not image, but ${ct}.`);
+    }
+
+    const dir = path.resolve(p);
+    await mkdir(dir, { recursive: true });
+
+    const dest = path.join(dir, filename);
+    const buf = Buffer.from(await res.arrayBuffer());
+    await writeFile(dest, buf);
+
+    if (verbose) logger.info(`Image saved as ${dest}`);
+    return dest;
+  }
+}
+
+export class WebImage extends Image {}
+
+export class GeneratedImage extends Image {
+  constructor(
+    url: string,
+    title: string,
+    alt: string,
+    proxy: string | null,
+    public cookies: Record<string, string>,
+  ) {
+    super(url, title, alt, proxy);
+    if (!cookies || Object.keys(cookies).length === 0) {
+      throw new Error('GeneratedImage is designed to be initialized with same cookies as GeminiClient.');
+    }
+  }
+
+  async save(
+    p: string = 'temp',
+    filename: string | null = null,
+    cookies: Record<string, string> | null = null,
+    verbose: boolean = false,
+    skip_invalid_filename: boolean = false,
+    full_size: boolean = true,
+  ): Promise<string | null> {
+    const u = full_size ? `${this.url}=s2048` : this.url;
+    const f = filename ?? `${new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14)}_${u.slice(-10)}.png`;
+    const img = new Image(u, this.title, this.alt, this.proxy);
+    return await img.save(p, f, cookies ?? this.cookies, verbose, skip_invalid_filename);
+  }
+}
@@ -0,0 +1,6 @@
+export { Candidate } from './candidate.js';
+export { Gem, GemJar } from './gem.js';
+export { RPCData } from './grpc.js';
+export { GeneratedImage, Image, WebImage } from './image.js';
+export { ModelOutput } from './modeloutput.js';
+
@@ -0,0 +1,35 @@
+import type { Image } from './image.js';
+import type { Candidate } from './candidate.js';
+
+export class ModelOutput {
+  public metadata: string[];
+  public candidates: Candidate[];
+  public chosen: number;
+
+  constructor(params: { metadata: string[]; candidates: Candidate[]; chosen?: number }) {
+    this.metadata = params.metadata;
+    this.candidates = params.candidates;
+    this.chosen = params.chosen ?? 0;
+  }
+
+  toString(): string {
+    return this.text;
+  }
+
+  get text(): string {
+    return this.candidates[this.chosen]?.text ?? '';
+  }
+
+  get thoughts(): string | null {
+    return this.candidates[this.chosen]?.thoughts ?? null;
+  }
+
+  get images(): Image[] {
+    return this.candidates[this.chosen]?.images ?? [];
+  }
+
+  get rcid(): string {
+    return this.candidates[this.chosen]?.rcid ?? '';
+  }
+}
+
@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+
+import { resolveGeminiWebCookiePath } from './paths.js';
+
+export type CookieMap = Record<string, string>;
+
+export type CookieFileData =
+  | {
+      cookies: CookieMap;
+      updated_at: number;
+      source?: string;
+    }
+  | {
+      version: number;
+      updatedAt: string;
+      cookieMap: CookieMap;
+      source?: string;
+    };
+
+export async function read_cookie_file(p: string = resolveGeminiWebCookiePath()): Promise<CookieMap | null> {
+  try {
+    if (!fs.existsSync(p) || !fs.statSync(p).isFile()) return null;
+    const raw = await readFile(p, 'utf8');
+    const data = JSON.parse(raw) as unknown;
+
+    if (data && typeof data === 'object' && 'cookies' in (data as any)) {
+      const cookies = (data as any).cookies as unknown;
+      if (cookies && typeof cookies === 'object') {
+        const out: CookieMap = {};
+        for (const [k, v] of Object.entries(cookies as Record<string, unknown>)) {
+          if (typeof v === 'string') out[k] = v;
+        }
+        return out;
+      }
+    }
+
+    if (data && typeof data === 'object' && 'cookieMap' in (data as any)) {
+      const cookies = (data as any).cookieMap as unknown;
+      if (cookies && typeof cookies === 'object') {
+        const out: CookieMap = {};
+        for (const [k, v] of Object.entries(cookies as Record<string, unknown>)) {
+          if (typeof v === 'string') out[k] = v;
+        }
+        return Object.keys(out).length > 0 ? out : null;
+      }
+    }
+
+    if (data && typeof data === 'object') {
+      const out: CookieMap = {};
+      for (const [k, v] of Object.entries(data as Record<string, unknown>)) {
+        if (typeof v === 'string') out[k] = v;
+      }
+      return Object.keys(out).length > 0 ? out : null;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function write_cookie_file(
+  cookies: CookieMap,
+  p: string = resolveGeminiWebCookiePath(),
+  source?: string,
+): Promise<void> {
+  const dir = path.dirname(p);
+  await mkdir(dir, { recursive: true });
+
+  const payload: CookieFileData = {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    cookieMap: cookies,
+    source,
+  };
+  await writeFile(p, JSON.stringify(payload, null, 2), 'utf8');
+}
+
+export const readCookieFile = read_cookie_file;
+export const writeCookieFile = write_cookie_file;
@@ -0,0 +1,34 @@
+import { APIError, ImageGenerationError } from '../exceptions.js';
+import { sleep } from './http.js';
+
+export function running(retry: number = 0) {
+  return <TArgs extends unknown[], TResult>(
+    fn: (client: any, ...args: TArgs) => Promise<TResult>,
+  ): ((client: any, ...args: TArgs) => Promise<TResult>) => {
+    const wrap = async (client: any, ...args: TArgs): Promise<TResult> => {
+      try {
+        if (!client?._running) {
+          await client.init?.({
+            timeout: client.timeout,
+            auto_close: client.auto_close,
+            close_delay: client.close_delay,
+            auto_refresh: client.auto_refresh,
+            refresh_interval: client.refresh_interval,
+            verbose: false,
+          });
+        }
+        return await fn(client, ...args);
+      } catch (e) {
+        let r = retry;
+        if (e instanceof ImageGenerationError) r = Math.min(1, r);
+        if (e instanceof APIError && r > 0) {
+          await sleep(1000);
+          return await running(r - 1)(fn)(client, ...args);
+        }
+        throw e;
+      }
+    };
+    return wrap;
+  };
+}
+
@@ -0,0 +1,192 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import { Endpoint, Headers } from '../constants.js';
+import { AuthError } from '../exceptions.js';
+import { cookie_header, extract_set_cookie_value, fetch_with_timeout } from './http.js';
+import { logger } from './logger.js';
+import { read_cookie_file, write_cookie_file } from './cookie-file.js';
+import { resolveGeminiWebDataDir, resolveGeminiWebCookiePath } from './paths.js';
+import { load_browser_cookies } from './load-browser-cookies.js';
+
+async function send_request(cookies: Record<string, string>, verbose: boolean): Promise<[string, Record<string, string>]> {
+  const res = await fetch_with_timeout(Endpoint.INIT, {
+    method: 'GET',
+    headers: { ...Headers.GEMINI, Cookie: cookie_header(cookies) },
+    redirect: 'follow',
+    timeout_ms: 30_000,
+  });
+
+  if (!res.ok) throw new Error(`Init failed: ${res.status} ${res.statusText}`);
+  const text = await res.text();
+  const m = text.match(/\"SNlM0e\":\"(.*?)\"/);
+  if (!m) throw new Error('Missing SNlM0e in response');
+  if (verbose) logger.debug('Init succeeded. Initializing client...');
+  return [m[1]!, cookies];
+}
+
+function merge_cookie_maps(...maps: Array<Record<string, string> | null | undefined>): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const m of maps) {
+    if (!m) continue;
+    for (const [k, v] of Object.entries(m)) {
+      if (typeof v === 'string' && v.length > 0) out[k] = v;
+    }
+  }
+  return out;
+}
+
+function read_cached_1psidts_file(dir: string, sid: string): string | null {
+  try {
+    const p = path.join(dir, `.cached_1psidts_${sid}.txt`);
+    if (!fs.existsSync(p) || !fs.statSync(p).isFile()) return null;
+    const v = fs.readFileSync(p, 'utf8').trim();
+    return v || null;
+  } catch {
+    return null;
+  }
+}
+
+function list_cached_1psidts(dir: string): Array<{ sid: string; sidts: string }> {
+  const out: Array<{ sid: string; sidts: string }> = [];
+  try {
+    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return out;
+    for (const f of fs.readdirSync(dir)) {
+      if (!f.startsWith('.cached_1psidts_') || !f.endsWith('.txt')) continue;
+      const sid = f.slice('.cached_1psidts_'.length, -'.txt'.length);
+      if (!sid) continue;
+      const sidts = read_cached_1psidts_file(dir, sid);
+      if (sidts) out.push({ sid, sidts });
+    }
+  } catch {}
+  return out;
+}
+
+async function fetch_google_extra_cookies(proxy: string | null, verbose: boolean): Promise<Record<string, string>> {
+  void proxy;
+  try {
+    const res = await fetch_with_timeout(Endpoint.GOOGLE, { timeout_ms: 15_000 });
+    const setCookie = res.headers.get('set-cookie');
+    const nid = extract_set_cookie_value(setCookie, 'NID');
+    if (nid) return { NID: nid };
+  } catch (e) {
+    if (verbose) logger.debug(`Skipping google.com preflight: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  return {};
+}
+
+export async function get_access_token(
+  base_cookies: Record<string, string>,
+  proxy: string | null = null,
+  verbose: boolean = false,
+): Promise<[string, Record<string, string>]> {
+  const extra = await fetch_google_extra_cookies(proxy, verbose);
+
+  const cacheDir = resolveGeminiWebDataDir();
+  const candidates: Record<string, string>[] = [];
+
+  const cookieFilePath = resolveGeminiWebCookiePath();
+  const cachedFile = await read_cookie_file(cookieFilePath);
+  const forceLogin = !!(process.env.GEMINI_WEB_LOGIN?.trim() || process.env.GEMINI_WEB_FORCE_LOGIN?.trim());
+  const shouldUseChromeFirst = forceLogin || (!cachedFile && !base_cookies['__Secure-1PSID'] && !base_cookies['__Secure-1PSIDTS']);
+
+  if (shouldUseChromeFirst) {
+    try {
+      const browser = await load_browser_cookies('google.com', verbose);
+      for (const cookies of Object.values(browser)) {
+        candidates.push(merge_cookie_maps(extra, cookies));
+      }
+    } catch (e) {
+      if (verbose) logger.warning(`Failed to load cookies via Chrome CDP: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  if (base_cookies['__Secure-1PSID'] && base_cookies['__Secure-1PSIDTS']) {
+    candidates.push(merge_cookie_maps(extra, base_cookies));
+  } else if (verbose) {
+    logger.debug('Skipping loading base cookies. Either __Secure-1PSID or __Secure-1PSIDTS is not provided.');
+  }
+
+  if (cachedFile) {
+    candidates.push(merge_cookie_maps(extra, cachedFile));
+  }
+
+  if (base_cookies['__Secure-1PSID'] && !base_cookies['__Secure-1PSIDTS']) {
+    const sid = base_cookies['__Secure-1PSID'];
+    const sidts = read_cached_1psidts_file(cacheDir, sid);
+    if (sidts) {
+      candidates.push(merge_cookie_maps(extra, base_cookies, { '__Secure-1PSIDTS': sidts }));
+    } else if (verbose) {
+      logger.debug('Skipping loading cached cookies. Cache file not found or empty.');
+    }
+  } else if (!base_cookies['__Secure-1PSID']) {
+    const caches = list_cached_1psidts(cacheDir);
+    for (const c of caches) {
+      candidates.push(merge_cookie_maps(extra, { '__Secure-1PSID': c.sid, '__Secure-1PSIDTS': c.sidts }));
+    }
+    if (caches.length === 0 && verbose) {
+      logger.debug('Skipping loading cached cookies. Cookies will be cached after successful initialization.');
+    }
+  }
+
+  const unique: Record<string, string>[] = [];
+  const seen = new Set<string>();
+  for (const c of candidates) {
+    const key = `${c['__Secure-1PSID'] ?? ''}:${c['__Secure-1PSIDTS'] ?? ''}:${c.NID ?? ''}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(c);
+  }
+
+  const try_candidates = async (): Promise<[string, Record<string, string>]> => {
+    if (unique.length === 0) throw new Error('no candidates');
+    const attempts = unique.map(async (c, i) => {
+      try {
+        if (verbose) logger.debug(`Init attempt (${i + 1}/${unique.length})...`);
+        return await send_request(c, verbose);
+      } catch (e) {
+        if (verbose) logger.debug(`Init attempt (${i + 1}/${unique.length}) failed: ${e instanceof Error ? e.message : String(e)}`);
+        throw e;
+      }
+    });
+    return (await Promise.any(attempts)) as [string, Record<string, string>];
+  };
+
+  try {
+    const [token, cookies] = await try_candidates();
+    await write_cookie_file(cookies, resolveGeminiWebCookiePath(), 'init').catch(() => {});
+    return [token, cookies];
+  } catch {
+    if (verbose) logger.debug('Cookie attempts failed. Falling back to Chrome CDP cookie load...');
+  }
+
+  const browser = await load_browser_cookies('google.com', verbose);
+  let valid = 0;
+  for (const cookies of Object.values(browser)) {
+    if (cookies['__Secure-1PSID']) valid++;
+    if (base_cookies['__Secure-1PSID'] && cookies['__Secure-1PSID'] && cookies['__Secure-1PSID'] !== base_cookies['__Secure-1PSID']) {
+      if (verbose) logger.debug('Skipping loaded browser cookies: __Secure-1PSID does not match the one provided.');
+      continue;
+    }
+    unique.push(merge_cookie_maps(extra, cookies));
+  }
+
+  if (valid === 0) {
+    throw new AuthError(
+      'No valid cookies available for initialization. Please pass __Secure-1PSID and __Secure-1PSIDTS manually.',
+    );
+  }
+
+  try {
+    const [token, cookies] = await try_candidates();
+    await write_cookie_file(cookies, resolveGeminiWebCookiePath(), 'init').catch(() => {});
+    return [token, cookies];
+  } catch {
+    throw new AuthError(
+      `Failed to initialize client. SECURE_1PSIDTS could get expired frequently, please make sure cookie values are up to date. (Failed initialization attempts: ${unique.length})`,
+    );
+  }
+}
+
+export const getAccessToken = get_access_token;
@@ -0,0 +1,57 @@
+export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    const t = setTimeout(() => {
+      if (signal) signal.removeEventListener('abort', onAbort);
+      resolve();
+    }, ms);
+
+    const onAbort = () => {
+      clearTimeout(t);
+      if (signal) signal.removeEventListener('abort', onAbort);
+      resolve();
+    };
+
+    if (signal) {
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+    }
+  });
+}
+
+export function cookie_header(cookies: Record<string, string>): string {
+  return Object.entries(cookies)
+    .filter(([, v]) => typeof v === 'string' && v.length > 0)
+    .map(([k, v]) => `${k}=${v}`)
+    .join('; ');
+}
+
+export const cookieHeader = cookie_header;
+
+export function extract_set_cookie_value(setCookie: string | null, name: string): string | null {
+  if (!setCookie) return null;
+  const re = new RegExp(`(?:^|[;,\\s])${name.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')}=([^;]+)`, 'i');
+  const m = setCookie.match(re);
+  if (!m) return null;
+  return m[1] ?? null;
+}
+
+export async function fetch_with_timeout(
+  url: string,
+  init: RequestInit & { timeout_ms?: number } = {},
+): Promise<Response> {
+  const { timeout_ms, ...rest } = init;
+  if (!timeout_ms || timeout_ms <= 0) return fetch(url, rest);
+
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeout_ms);
+  try {
+    return await fetch(url, { ...rest, signal: ctl.signal });
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+export const fetchWithTimeout = fetch_with_timeout;
@@ -0,0 +1,20 @@
+export { running } from './decorators.js';
+export { get_access_token, getAccessToken } from './get-access-token.js';
+export { load_browser_cookies, loadBrowserCookies } from './load-browser-cookies.js';
+export { logger, set_log_level, setLogLevel } from './logger.js';
+export { extract_json_from_response, extractJsonFromResponse, get_nested_value, getNestedValue } from './parsing.js';
+export { rotate_1psidts, rotate1psidts } from './rotate-1psidts.js';
+export { upload_file, uploadFile, parse_file_name, parseFileName } from './upload-file.js';
+export { read_cookie_file, readCookieFile, write_cookie_file, writeCookieFile } from './cookie-file.js';
+export {
+  resolveUserDataRoot,
+  resolveGeminiWebChromeProfileDir,
+  resolveGeminiWebCookiePath,
+  resolveGeminiWebDataDir,
+  resolveGeminiWebSessionPath,
+  resolveGeminiWebSessionsDir,
+} from './paths.js';
+export { cookie_header, cookieHeader, fetch_with_timeout, fetchWithTimeout, sleep } from './http.js';
+
+export const rotate_tasks = new Map<string, unknown>();
+
@@ -0,0 +1,271 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import fs from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import net from 'node:net';
+import process from 'node:process';
+
+import { logger } from './logger.js';
+import { fetch_with_timeout, sleep } from './http.js';
+import { read_cookie_file, type CookieMap, write_cookie_file } from './cookie-file.js';
+import { resolveGeminiWebChromeProfileDir, resolveGeminiWebCookiePath } from './paths.js';
+
+type CdpSendOptions = { sessionId?: string; timeoutMs?: number };
+
+class CdpConnection {
+  private ws: WebSocket;
+  private nextId = 0;
+  private pending = new Map<
+    number,
+    { resolve: (v: unknown) => void; reject: (e: Error) => void; timer: ReturnType<typeof setTimeout> | null }
+  >();
+
+  private constructor(ws: WebSocket) {
+    this.ws = ws;
+    this.ws.addEventListener('message', (event) => {
+      try {
+        const data = typeof event.data === 'string' ? event.data : new TextDecoder().decode(event.data as ArrayBuffer);
+        const msg = JSON.parse(data) as { id?: number; result?: unknown; error?: { message?: string } };
+        if (msg.id) {
+          const p = this.pending.get(msg.id);
+          if (p) {
+            this.pending.delete(msg.id);
+            if (p.timer) clearTimeout(p.timer);
+            if (msg.error?.message) p.reject(new Error(msg.error.message));
+            else p.resolve(msg.result);
+          }
+        }
+      } catch {}
+    });
+    this.ws.addEventListener('close', () => {
+      for (const [id, p] of this.pending.entries()) {
+        this.pending.delete(id);
+        if (p.timer) clearTimeout(p.timer);
+        p.reject(new Error('CDP connection closed.'));
+      }
+    });
+  }
+
+  static async connect(url: string, timeoutMs: number): Promise<CdpConnection> {
+    const ws = new WebSocket(url);
+    await new Promise<void>((resolve, reject) => {
+      const t = setTimeout(() => reject(new Error('CDP connection timeout.')), timeoutMs);
+      ws.addEventListener('open', () => {
+        clearTimeout(t);
+        resolve();
+      });
+      ws.addEventListener('error', () => {
+        clearTimeout(t);
+        reject(new Error('CDP connection failed.'));
+      });
+    });
+    return new CdpConnection(ws);
+  }
+
+  async send<T = unknown>(method: string, params?: Record<string, unknown>, opts?: CdpSendOptions): Promise<T> {
+    const id = ++this.nextId;
+    const msg: Record<string, unknown> = { id, method };
+    if (params) msg.params = params;
+    if (opts?.sessionId) msg.sessionId = opts.sessionId;
+
+    const timeoutMs = opts?.timeoutMs ?? 15_000;
+    const out = await new Promise<unknown>((resolve, reject) => {
+      const t =
+        timeoutMs > 0
+          ? setTimeout(() => {
+              this.pending.delete(id);
+              reject(new Error(`CDP timeout: ${method}`));
+            }, timeoutMs)
+          : null;
+      this.pending.set(id, { resolve, reject, timer: t });
+      this.ws.send(JSON.stringify(msg));
+    });
+    return out as T;
+  }
+
+  close(): void {
+    try {
+      this.ws.close();
+    } catch {}
+  }
+}
+
+async function get_free_port(): Promise<number> {
+  return await new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.unref();
+    srv.on('error', reject);
+    srv.listen(0, '127.0.0.1', () => {
+      const addr = srv.address();
+      if (!addr || typeof addr === 'string') {
+        srv.close(() => reject(new Error('Unable to allocate a free TCP port.')));
+        return;
+      }
+      const port = addr.port;
+      srv.close((err) => (err ? reject(err) : resolve(port)));
+    });
+  });
+}
+
+function find_chrome_executable(): string | null {
+  const override = process.env.GEMINI_WEB_CHROME_PATH?.trim();
+  if (override && fs.existsSync(override)) return override;
+
+  const candidates: string[] = [];
+  switch (process.platform) {
+    case 'darwin':
+      candidates.push(
+        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+        '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta',
+        '/Applications/Chromium.app/Contents/MacOS/Chromium',
+        '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+      );
+      break;
+    case 'win32':
+      candidates.push(
+        'C:\\\\Program Files\\\\Google\\\\Chrome\\\\Application\\\\chrome.exe',
+        'C:\\\\Program Files (x86)\\\\Google\\\\Chrome\\\\Application\\\\chrome.exe',
+        'C:\\\\Program Files\\\\Microsoft\\\\Edge\\\\Application\\\\msedge.exe',
+        'C:\\\\Program Files (x86)\\\\Microsoft\\\\Edge\\\\Application\\\\msedge.exe',
+      );
+      break;
+    default:
+      candidates.push(
+        '/usr/bin/google-chrome',
+        '/usr/bin/google-chrome-stable',
+        '/usr/bin/chromium',
+        '/usr/bin/chromium-browser',
+        '/snap/bin/chromium',
+        '/usr/bin/microsoft-edge',
+      );
+      break;
+  }
+
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+async function wait_for_chrome_debug_port(port: number, timeoutMs: number): Promise<string> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch_with_timeout(`http://127.0.0.1:${port}/json/version`, { timeout_ms: 5_000 });
+      if (!res.ok) throw new Error(`status=${res.status}`);
+      const j = (await res.json()) as { webSocketDebuggerUrl?: string };
+      if (j.webSocketDebuggerUrl) return j.webSocketDebuggerUrl;
+    } catch {}
+    await sleep(200);
+  }
+  throw new Error('Chrome debug port not ready');
+}
+
+async function launch_chrome(profileDir: string, port: number): Promise<ChildProcess> {
+  const chrome = find_chrome_executable();
+  if (!chrome) throw new Error('Chrome executable not found.');
+
+  const args = [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${profileDir}`,
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--disable-popup-blocking',
+    'https://gemini.google.com/app',
+  ];
+
+  return spawn(chrome, args, { stdio: 'ignore' });
+}
+
+async function fetch_google_cookies_via_cdp(
+  profileDir: string,
+  timeoutMs: number,
+  verbose: boolean,
+): Promise<CookieMap> {
+  await mkdir(profileDir, { recursive: true });
+
+  const port = await get_free_port();
+  const chrome = await launch_chrome(profileDir, port);
+
+  let cdp: CdpConnection | null = null;
+  try {
+    const wsUrl = await wait_for_chrome_debug_port(port, 30_000);
+    cdp = await CdpConnection.connect(wsUrl, 15_000);
+
+    const { targetId } = await cdp.send<{ targetId: string }>('Target.createTarget', {
+      url: 'https://gemini.google.com/app',
+      newWindow: true,
+    });
+    const { sessionId } = await cdp.send<{ sessionId: string }>('Target.attachToTarget', { targetId, flatten: true });
+    await cdp.send('Network.enable', {}, { sessionId });
+
+    if (verbose) {
+      logger.info('Chrome opened. If needed, complete Google login in the window. Waiting for cookies...');
+    }
+
+    const start = Date.now();
+    let last: CookieMap = {};
+
+    while (Date.now() - start < timeoutMs) {
+      const { cookies } = await cdp.send<{ cookies: Array<{ name: string; value: string }> }>(
+        'Network.getCookies',
+        { urls: ['https://gemini.google.com/', 'https://accounts.google.com/', 'https://www.google.com/'] },
+        { sessionId, timeoutMs: 10_000 },
+      );
+
+      const m: CookieMap = {};
+      for (const c of cookies) {
+        if (c?.name && typeof c.value === 'string') m[c.name] = c.value;
+      }
+
+      last = m;
+      if (m['__Secure-1PSID'] && (m['__Secure-1PSIDTS'] || Date.now() - start > 10_000)) {
+        return m;
+      }
+
+      await sleep(1000);
+    }
+
+    throw new Error(`Timed out waiting for Google cookies. Last keys: ${Object.keys(last).join(', ')}`);
+  } finally {
+    if (cdp) {
+      try {
+        await cdp.send('Browser.close', {}, { timeoutMs: 5_000 });
+      } catch {}
+      cdp.close();
+    }
+
+    try {
+      chrome.kill('SIGTERM');
+    } catch {}
+    setTimeout(() => {
+      if (!chrome.killed) {
+        try {
+          chrome.kill('SIGKILL');
+        } catch {}
+      }
+    }, 2_000).unref?.();
+  }
+}
+
+export async function load_browser_cookies(domain_name: string = '', verbose: boolean = true): Promise<Record<string, CookieMap>> {
+  const force = process.env.GEMINI_WEB_LOGIN?.trim() || process.env.GEMINI_WEB_FORCE_LOGIN?.trim();
+  if (!force) {
+    const cached = await read_cookie_file();
+    if (cached) return { chrome: cached };
+  }
+
+  const profileDir = process.env.GEMINI_WEB_CHROME_PROFILE_DIR?.trim() || resolveGeminiWebChromeProfileDir();
+  const cookies = await fetch_google_cookies_via_cdp(profileDir, 120_000, verbose);
+
+  const filtered: CookieMap = {};
+  for (const [k, v] of Object.entries(cookies)) {
+    if (typeof v === 'string' && v.length > 0) filtered[k] = v;
+  }
+
+  await write_cookie_file(filtered, resolveGeminiWebCookiePath(), 'cdp');
+  void domain_name;
+  return { chrome: filtered };
+}
+
+export const loadBrowserCookies = load_browser_cookies;
@@ -0,0 +1,42 @@
+export type LogLevel = 'TRACE' | 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR' | 'CRITICAL' | number;
+
+const lvl: Record<Exclude<LogLevel, number>, number> = {
+  TRACE: 0,
+  DEBUG: 1,
+  INFO: 2,
+  WARNING: 3,
+  ERROR: 4,
+  CRITICAL: 5,
+};
+
+let cur = lvl.INFO;
+
+function toNum(level: LogLevel): number {
+  if (typeof level === 'number') return level;
+  return lvl[level] ?? lvl.INFO;
+}
+
+export function set_log_level(level: LogLevel): void {
+  cur = toNum(level);
+}
+
+export const setLogLevel = set_log_level;
+
+function emit(level: Exclude<LogLevel, number>, args: unknown[]): void {
+  if (lvl[level] < cur) return;
+  const prefix = `[gemini_webapi] ${level}:`;
+
+  if (level === 'WARNING') console.warn(prefix, ...args);
+  else if (level === 'ERROR' || level === 'CRITICAL') console.error(prefix, ...args);
+  else console.log(prefix, ...args);
+}
+
+export const logger = {
+  trace: (...args: unknown[]) => emit('TRACE', args),
+  debug: (...args: unknown[]) => emit('DEBUG', args),
+  info: (...args: unknown[]) => emit('INFO', args),
+  warning: (...args: unknown[]) => emit('WARNING', args),
+  error: (...args: unknown[]) => emit('ERROR', args),
+  success: (...args: unknown[]) => emit('INFO', args),
+};
+
@@ -0,0 +1,44 @@
+import { logger } from './logger.js';
+
+export function get_nested_value<T = unknown>(data: unknown, path: number[], def?: T): T {
+  let cur: unknown = data;
+  for (let i = 0; i < path.length; i++) {
+    const k = path[i]!;
+    if (!Array.isArray(cur)) {
+      logger.debug(`Safe navigation: path ${JSON.stringify(path)} ended at index ${i} (key '${k}'), returning default.`);
+      return def as T;
+    }
+    cur = cur[k];
+    if (cur === undefined) {
+      logger.debug(`Safe navigation: path ${JSON.stringify(path)} ended at index ${i} (key '${k}'), returning default.`);
+      return def as T;
+    }
+  }
+
+  if (cur == null && def !== undefined) return def as T;
+  return cur as T;
+}
+
+export function extract_json_from_response(text: string): unknown {
+  if (typeof text !== 'string') {
+    throw new TypeError(`Input text is expected to be a string, got ${typeof text} instead.`);
+  }
+
+  let last: unknown = undefined;
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      last = JSON.parse(trimmed) as unknown;
+    } catch {}
+  }
+
+  if (last === undefined) {
+    throw new Error('Could not find a valid JSON object or array in the response.');
+  }
+
+  return last;
+}
+
+export const extractJsonFromResponse = extract_json_from_response;
+export const getNestedValue = get_nested_value;
@@ -43,3 +43,4 @@ export function resolveGeminiWebSessionPath(name: string): string {
  const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '_');
  return path.join(resolveGeminiWebSessionsDir(), `${sanitized}.json`);
 }
+
@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+
+import { Endpoint, Headers } from '../constants.js';
+import { AuthError } from '../exceptions.js';
+import { cookie_header, extract_set_cookie_value, fetch_with_timeout } from './http.js';
+import { resolveGeminiWebDataDir } from './paths.js';
+
+export async function rotate_1psidts(cookies: Record<string, string>, _proxy?: string | null): Promise<string | null> {
+  const p = resolveGeminiWebDataDir();
+  await mkdir(p, { recursive: true });
+
+  const sid = cookies['__Secure-1PSID'];
+  if (!sid) throw new Error('Missing __Secure-1PSID cookie.');
+
+  const cachePath = path.join(p, `.cached_1psidts_${sid}.txt`);
+
+  try {
+    const st = fs.statSync(cachePath);
+    if (Date.now() - st.mtimeMs <= 60_000) return null;
+  } catch {}
+
+  const res = await fetch_with_timeout(Endpoint.ROTATE_COOKIES, {
+    method: 'POST',
+    headers: { ...Headers.ROTATE_COOKIES, Cookie: cookie_header(cookies) },
+    body: '[000,"-0000000000000000000"]',
+    redirect: 'follow',
+    timeout_ms: 30_000,
+  });
+
+  if (res.status === 401) throw new AuthError('Failed to refresh cookies (401).');
+  if (!res.ok) throw new Error(`RotateCookies failed: ${res.status} ${res.statusText}`);
+
+  const setCookie = res.headers.get('set-cookie');
+  const v = extract_set_cookie_value(setCookie, '__Secure-1PSIDTS');
+  if (v) {
+    await writeFile(cachePath, v, 'utf8');
+    return v;
+  }
+
+  return null;
+}
+
+export const rotate1psidts = rotate_1psidts;
+
@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+
+import { Endpoint, Headers } from '../constants.js';
+
+export async function upload_file(file: string, _proxy?: string | null): Promise<string> {
+  if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
+    throw new Error(`${file} is not a valid file.`);
+  }
+
+  const filename = path.basename(file);
+  const content = await readFile(file);
+
+  const form = new FormData();
+  form.append('file', new Blob([content]), filename);
+
+  const res = await fetch(Endpoint.UPLOAD, {
+    method: 'POST',
+    headers: { ...Headers.UPLOAD },
+    body: form,
+    redirect: 'follow',
+  });
+
+  if (!res.ok) {
+    throw new Error(`Upload failed: ${res.status} ${res.statusText}`);
+  }
+
+  return await res.text();
+}
+
+export function parse_file_name(file: string): string {
+  if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
+    throw new Error(`${file} is not a valid file.`);
+  }
+  return path.basename(file);
+}
+
+export const uploadFile = upload_file;
+export const parseFileName = parse_file_name;
+
@@ -0,0 +1,490 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
+
+import { GeminiClient, GeneratedImage, Model, type ModelOutput } from './gemini-webapi/index.js';
+import { resolveGeminiWebChromeProfileDir, resolveGeminiWebCookiePath, resolveGeminiWebSessionPath, resolveGeminiWebSessionsDir } from './gemini-webapi/utils/index.js';
+
+type CliArgs = {
+  prompt: string | null;
+  promptFiles: string[];
+  modelId: string;
+  json: boolean;
+  imagePath: string | null;
+  referenceImages: string[];
+  sessionId: string | null;
+  listSessions: boolean;
+  login: boolean;
+  cookiePath: string | null;
+  profileDir: string | null;
+  help: boolean;
+};
+
+type SessionRecord = {
+  id: string;
+  metadata: Array<string | null>;
+  messages: Array<{ role: 'user' | 'assistant'; content: string; timestamp: string; error?: string }>;
+  createdAt: string;
+  updatedAt: string;
+};
+
+type LegacySessionV1 = {
+  version?: number;
+  sessionId?: string;
+  updatedAt?: string;
+  conversationId?: string | null;
+  responseId?: string | null;
+  choiceId?: string | null;
+  chatMetadata?: unknown;
+};
+
+function normalizeSessionMetadata(input: unknown): Array<string | null> {
+  if (Array.isArray(input)) {
+    const out: Array<string | null> = [];
+    for (const v of input.slice(0, 3)) out.push(typeof v === 'string' ? v : null);
+    return out.length > 0 ? out : [null, null, null];
+  }
+
+  if (input && typeof input === 'object') {
+    const v1 = input as LegacySessionV1;
+    if (Array.isArray(v1.chatMetadata)) return normalizeSessionMetadata(v1.chatMetadata);
+
+    const conv = typeof v1.conversationId === 'string' ? v1.conversationId : null;
+    const rid = typeof v1.responseId === 'string' ? v1.responseId : null;
+    const rcid = typeof v1.choiceId === 'string' ? v1.choiceId : null;
+    if (conv || rid || rcid) return [conv, rid, rcid];
+  }
+
+  return [null, null, null];
+}
+
+function printUsage(cookiePath: string, profileDir: string): void {
+  console.log(`Usage:
+  npx -y bun skills/baoyu-danger-gemini-web/scripts/main.ts --prompt "Hello"
+  npx -y bun skills/baoyu-danger-gemini-web/scripts/main.ts "Hello"
+  npx -y bun skills/baoyu-danger-gemini-web/scripts/main.ts --prompt "A cute cat" --image generated.png
+  npx -y bun skills/baoyu-danger-gemini-web/scripts/main.ts --promptfiles system.md content.md --image out.png
+
+Multi-turn conversation (agent generates unique sessionId):
+  npx -y bun skills/baoyu-danger-gemini-web/scripts/main.ts "Remember 42" --sessionId abc123
+  npx -y bun skills/baoyu-danger-gemini-web/scripts/main.ts "What number?" --sessionId abc123
+
+Options:
+  -p, --prompt <text>       Prompt text
+  --promptfiles <files...>  Read prompt from one or more files (concatenated in order)
+  -m, --model <id>          gemini-3-pro | gemini-2.5-pro | gemini-2.5-flash (default: gemini-3-pro)
+  --json                    Output JSON
+  --image [path]            Generate an image and save it (default: ./generated.png)
+  --reference <files...>    Reference images for vision input
+  --ref <files...>          Alias for --reference
+  --sessionId <id>          Session ID for multi-turn conversation (agent should generate unique ID)
+  --list-sessions           List saved sessions (max 100, sorted by update time)
+  --login                   Only refresh cookies, then exit
+  --cookie-path <path>      Cookie file path (default: ${cookiePath})
+  --profile-dir <path>      Chrome profile dir (default: ${profileDir})
+  -h, --help                Show help
+
+Env overrides:
+  GEMINI_WEB_DATA_DIR, GEMINI_WEB_COOKIE_PATH, GEMINI_WEB_CHROME_PROFILE_DIR, GEMINI_WEB_CHROME_PATH`);
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const out: CliArgs = {
+    prompt: null,
+    promptFiles: [],
+    modelId: 'gemini-3-pro',
+    json: false,
+    imagePath: null,
+    referenceImages: [],
+    sessionId: null,
+    listSessions: false,
+    login: false,
+    cookiePath: null,
+    profileDir: null,
+    help: false,
+  };
+
+  const positional: string[] = [];
+
+  const takeMany = (i: number): { items: string[]; next: number } => {
+    const items: string[] = [];
+    let j = i + 1;
+    while (j < argv.length) {
+      const v = argv[j]!;
+      if (v.startsWith('-')) break;
+      items.push(v);
+      j++;
+    }
+    return { items, next: j - 1 };
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+
+    if (a === '--help' || a === '-h') {
+      out.help = true;
+      continue;
+    }
+
+    if (a === '--json') {
+      out.json = true;
+      continue;
+    }
+
+    if (a === '--list-sessions') {
+      out.listSessions = true;
+      continue;
+    }
+
+    if (a === '--login') {
+      out.login = true;
+      continue;
+    }
+
+    if (a === '--prompt' || a === '-p') {
+      const v = argv[++i];
+      if (!v) throw new Error(`Missing value for ${a}`);
+      out.prompt = v;
+      continue;
+    }
+
+    if (a === '--promptfiles') {
+      const { items, next } = takeMany(i);
+      if (items.length === 0) throw new Error('Missing files for --promptfiles');
+      out.promptFiles.push(...items);
+      i = next;
+      continue;
+    }
+
+    if (a === '--model' || a === '-m') {
+      const v = argv[++i];
+      if (!v) throw new Error(`Missing value for ${a}`);
+      out.modelId = v;
+      continue;
+    }
+
+    if (a === '--sessionId') {
+      const v = argv[++i];
+      if (!v) throw new Error('Missing value for --sessionId');
+      out.sessionId = v;
+      continue;
+    }
+
+    if (a === '--cookie-path') {
+      const v = argv[++i];
+      if (!v) throw new Error('Missing value for --cookie-path');
+      out.cookiePath = v;
+      continue;
+    }
+
+    if (a === '--profile-dir') {
+      const v = argv[++i];
+      if (!v) throw new Error('Missing value for --profile-dir');
+      out.profileDir = v;
+      continue;
+    }
+
+    if (a === '--image' || a.startsWith('--image=')) {
+      let v: string | null = null;
+      if (a.startsWith('--image=')) {
+        v = a.slice('--image='.length).trim();
+      } else {
+        const maybe = argv[i + 1];
+        if (maybe && !maybe.startsWith('-')) {
+          v = maybe;
+          i++;
+        }
+      }
+
+      out.imagePath = v && v.length > 0 ? v : 'generated.png';
+      continue;
+    }
+
+    if (a === '--reference' || a === '--ref') {
+      const { items, next } = takeMany(i);
+      if (items.length === 0) throw new Error(`Missing files for ${a}`);
+      out.referenceImages.push(...items);
+      i = next;
+      continue;
+    }
+
+    if (a.startsWith('-')) {
+      throw new Error(`Unknown option: ${a}`);
+    }
+
+    positional.push(a);
+  }
+
+  if (!out.prompt && out.promptFiles.length === 0 && positional.length > 0) {
+    out.prompt = positional.join(' ');
+  }
+
+  return out;
+}
+
+function resolveModel(id: string): Model {
+  const k = id.trim();
+  if (k === 'gemini-3-pro') return Model.G_3_0_PRO;
+  if (k === 'gemini-3.0-pro') return Model.G_3_0_PRO;
+  if (k === 'gemini-2.5-pro') return Model.G_2_5_PRO;
+  if (k === 'gemini-2.5-flash') return Model.G_2_5_FLASH;
+  return Model.from_name(k);
+}
+
+async function readPromptFromFiles(files: string[]): Promise<string> {
+  const parts: string[] = [];
+  for (const f of files) {
+    parts.push(await readFile(f, 'utf8'));
+  }
+  return parts.join('\n\n');
+}
+
+async function readPromptFromStdin(): Promise<string | null> {
+  if (process.stdin.isTTY) return null;
+  try {
+    // Bun provides Bun.stdin; Node-compatible read can be flaky across runtimes.
+    const t = await Bun.stdin.text();
+    const v = t.trim();
+    return v.length > 0 ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeOutputImagePath(p: string): string {
+  const full = path.resolve(p);
+  const ext = path.extname(full);
+  if (ext) return full;
+  return `${full}.png`;
+}
+
+async function loadSession(id: string): Promise<SessionRecord | null> {
+  const p = resolveGeminiWebSessionPath(id);
+  try {
+    const raw = await readFile(p, 'utf8');
+    const j = JSON.parse(raw) as unknown;
+    if (!j || typeof j !== 'object') return null;
+
+    const sid = (typeof (j as any).id === 'string' && (j as any).id.trim()) || (typeof (j as any).sessionId === 'string' && (j as any).sessionId.trim()) || id;
+    const metadata = normalizeSessionMetadata((j as any).metadata ?? (j as any).chatMetadata ?? j);
+    const messages = Array.isArray((j as any).messages) ? ((j as any).messages as SessionRecord['messages']) : [];
+    const createdAt =
+      typeof (j as any).createdAt === 'string'
+        ? ((j as any).createdAt as string)
+        : typeof (j as any).updatedAt === 'string'
+          ? ((j as any).updatedAt as string)
+          : new Date().toISOString();
+    const updatedAt = typeof (j as any).updatedAt === 'string' ? ((j as any).updatedAt as string) : createdAt;
+
+    return {
+      id: sid,
+      metadata,
+      messages,
+      createdAt,
+      updatedAt,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function saveSession(rec: SessionRecord): Promise<void> {
+  const dir = resolveGeminiWebSessionsDir();
+  await mkdir(dir, { recursive: true });
+  const p = resolveGeminiWebSessionPath(rec.id);
+  const tmp = `${p}.tmp.${Date.now()}`;
+  await writeFile(tmp, JSON.stringify(rec, null, 2), 'utf8');
+  await fs.promises.rename(tmp, p);
+}
+
+async function listSessions(): Promise<SessionRecord[]> {
+  const dir = resolveGeminiWebSessionsDir();
+  try {
+    const names = await readdir(dir);
+    const items: Array<{ path: string; st: number }> = [];
+    for (const n of names) {
+      if (!n.endsWith('.json')) continue;
+      const p = path.join(dir, n);
+      try {
+        const s = await stat(p);
+        items.push({ path: p, st: s.mtimeMs });
+      } catch {}
+    }
+
+    items.sort((a, b) => b.st - a.st);
+    const out: SessionRecord[] = [];
+    for (const it of items.slice(0, 100)) {
+      try {
+        const raw = await readFile(it.path, 'utf8');
+        const j = JSON.parse(raw) as any;
+        const id =
+          (typeof j?.id === 'string' && j.id.trim()) ||
+          (typeof j?.sessionId === 'string' && j.sessionId.trim()) ||
+          path.basename(it.path, '.json');
+        out.push({
+          id,
+          metadata: normalizeSessionMetadata(j?.metadata ?? j?.chatMetadata ?? j),
+          messages: Array.isArray(j?.messages) ? j.messages : [],
+          createdAt:
+            typeof j?.createdAt === 'string'
+              ? j.createdAt
+              : typeof j?.updatedAt === 'string'
+                ? j.updatedAt
+                : new Date(it.st).toISOString(),
+          updatedAt: typeof j?.updatedAt === 'string' ? j.updatedAt : new Date(it.st).toISOString(),
+        });
+      } catch {}
+    }
+
+    out.sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
+    return out.slice(0, 100);
+  } catch {
+    return [];
+  }
+}
+
+function formatJson(out: ModelOutput, extra?: Record<string, unknown>): string {
+  const candidates = out.candidates.map((c) => ({
+    rcid: c.rcid,
+    text: c.text,
+    thoughts: c.thoughts,
+    images: c.images.map((img) => ({
+      url: img.url,
+      title: img.title,
+      alt: img.alt,
+      kind: img instanceof GeneratedImage ? 'generated' : 'web',
+    })),
+  }));
+
+  return JSON.stringify(
+    {
+      text: out.text,
+      thoughts: out.thoughts,
+      metadata: out.metadata,
+      chosen: out.chosen,
+      candidates,
+      ...extra,
+    },
+    null,
+    2,
+  );
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.cookiePath) process.env.GEMINI_WEB_COOKIE_PATH = args.cookiePath;
+  if (args.profileDir) process.env.GEMINI_WEB_CHROME_PROFILE_DIR = args.profileDir;
+
+  const cookiePath = resolveGeminiWebCookiePath();
+  const profileDir = resolveGeminiWebChromeProfileDir();
+
+  if (args.help) {
+    printUsage(cookiePath, profileDir);
+    return;
+  }
+
+  if (args.listSessions) {
+    const ss = await listSessions();
+    for (const s of ss) {
+      const n = s.messages.length;
+      const last = s.messages.slice(-1)[0];
+      const lastLine = last?.content ? String(last.content).split('\n')[0] : '';
+      console.log(`${s.id}\t${s.updatedAt}\t${n}\t${lastLine}`);
+    }
+    return;
+  }
+
+  if (args.login) {
+    process.env.GEMINI_WEB_LOGIN = '1';
+    const c = new GeminiClient();
+    await c.init({ verbose: true });
+    await c.close();
+    if (!args.json) console.log(`Cookie refreshed: ${cookiePath}`);
+    else console.log(JSON.stringify({ ok: true, cookiePath }, null, 2));
+    return;
+  }
+
+  let prompt: string | null = args.prompt;
+  if (!prompt && args.promptFiles.length > 0) prompt = await readPromptFromFiles(args.promptFiles);
+  if (!prompt) prompt = await readPromptFromStdin();
+
+  if (!prompt) {
+    printUsage(cookiePath, profileDir);
+    process.exitCode = 1;
+    return;
+  }
+
+  const model = resolveModel(args.modelId);
+
+  const c = new GeminiClient();
+  await c.init({ verbose: false });
+  try {
+    let sess: SessionRecord | null = null;
+    let chat = null as any;
+
+    if (args.sessionId) {
+      sess = (await loadSession(args.sessionId)) ?? {
+        id: args.sessionId,
+        metadata: [null, null, null],
+        messages: [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+      chat = c.start_chat({ metadata: sess.metadata, model });
+    }
+
+    const files = args.referenceImages.length > 0 ? args.referenceImages : null;
+
+    let out: ModelOutput;
+    if (chat) out = await chat.send_message(prompt, files);
+    else out = await c.generate_content(prompt, files, model);
+
+    let savedImage: string | null = null;
+    if (args.imagePath) {
+      const p = normalizeOutputImagePath(args.imagePath);
+      const dir = path.dirname(p);
+      await mkdir(dir, { recursive: true });
+
+      const img = out.images[0];
+      if (!img) {
+        throw new Error('No image returned in response.');
+      }
+
+      const fn = path.basename(p);
+      const dp = dir;
+
+      if (img instanceof GeneratedImage) {
+        savedImage = await img.save(dp, fn, undefined, false, false, true);
+      } else {
+        savedImage = await img.save(dp, fn, c.cookies, false, false);
+      }
+    }
+
+    if (sess && args.sessionId) {
+      const now = new Date().toISOString();
+      sess.updatedAt = now;
+      sess.metadata = (chat?.metadata ?? sess.metadata).slice(0, 3);
+      sess.messages.push({ role: 'user', content: prompt, timestamp: now });
+      sess.messages.push({ role: 'assistant', content: out.text ?? '', timestamp: now });
+      await saveSession(sess);
+    }
+
+    if (args.json) {
+      console.log(formatJson(out, { savedImage, sessionId: args.sessionId, model: model.model_name }));
+    } else if (args.imagePath) {
+      console.log(savedImage ?? '');
+    } else {
+      console.log(out.text);
+    }
+  } finally {
+    await c.close();
+  }
+}
+
+main().catch((e) => {
+  const msg = e instanceof Error ? e.message : String(e);
+  console.error(msg);
+  process.exit(1);
+});
@@ -0,0 +1,177 @@
+---
+name: baoyu-danger-x-to-markdown
+description: Convert X (Twitter) tweet or article URL to markdown. Uses reverse-engineered X API (private). Requires user consent before use.
+---
+
+# X to Markdown
+
+Converts X (Twitter) content to markdown format:
+- Tweet threads → Markdown with YAML front matter
+- X Articles → Full article content extraction
+
+## Script Directory
+
+**Important**: All scripts are located in the `scripts/` subdirectory of this skill.
+
+**Agent Execution Instructions**:
+1. Determine this SKILL.md file's directory path as `SKILL_DIR`
+2. Script path = `${SKILL_DIR}/scripts/<script-name>.ts`
+3. Replace all `${SKILL_DIR}` in this document with the actual path
+
+**Script Reference**:
+| Script | Purpose |
+|--------|---------|
+| `scripts/main.ts` | CLI entry point for URL conversion |
+
+## ⚠️ Disclaimer (REQUIRED)
+
+**Before using this skill**, the consent check MUST be performed.
+
+### Consent Check Flow
+
+**Step 1**: Check consent file
+
+```bash
+# macOS
+cat ~/Library/Application\ Support/baoyu-skills/x-to-markdown/consent.json 2>/dev/null
+
+# Linux
+cat ~/.local/share/baoyu-skills/x-to-markdown/consent.json 2>/dev/null
+
+# Windows (PowerShell)
+Get-Content "$env:APPDATA\baoyu-skills\x-to-markdown\consent.json" 2>$null
+```
+
+**Step 2**: If consent exists and `accepted: true` with matching `disclaimerVersion: "1.0"`:
+
+Print warning and proceed:
+```
+⚠️  Warning: Using reverse-engineered X API (not official). Accepted on: <acceptedAt date>
+```
+
+**Step 3**: If consent file doesn't exist or `disclaimerVersion` mismatch:
+
+Display disclaimer and ask user:
+
+```
+⚠️  DISCLAIMER
+
+This tool uses a reverse-engineered X (Twitter) API, NOT an official API.
+
+Risks:
+- May break without notice if X changes their API
+- No official support or guarantees
+- Account restrictions possible if API usage detected
+- Use at your own risk
+
+Do you accept these terms and wish to continue?
+```
+
+Use `AskUserQuestion` tool with options:
+- **Yes, I accept** - Continue and save consent
+- **No, I decline** - Exit immediately
+
+**Step 4**: On acceptance, create consent file:
+
+```bash
+# macOS
+mkdir -p ~/Library/Application\ Support/baoyu-skills/x-to-markdown
+cat > ~/Library/Application\ Support/baoyu-skills/x-to-markdown/consent.json << 'EOF'
+{
+  "version": 1,
+  "accepted": true,
+  "acceptedAt": "<ISO timestamp>",
+  "disclaimerVersion": "1.0"
+}
+EOF
+
+# Linux
+mkdir -p ~/.local/share/baoyu-skills/x-to-markdown
+cat > ~/.local/share/baoyu-skills/x-to-markdown/consent.json << 'EOF'
+{
+  "version": 1,
+  "accepted": true,
+  "acceptedAt": "<ISO timestamp>",
+  "disclaimerVersion": "1.0"
+}
+EOF
+```
+
+**Step 5**: On decline, output message and stop:
+```
+User declined the disclaimer. Exiting.
+```
+
+---
+
+## Usage
+
+```bash
+# Convert tweet (outputs markdown path)
+npx -y bun ${SKILL_DIR}/scripts/main.ts <url>
+
+# Save to specific file
+npx -y bun ${SKILL_DIR}/scripts/main.ts <url> -o output.md
+
+# JSON output
+npx -y bun ${SKILL_DIR}/scripts/main.ts <url> --json
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `<url>` | Tweet or article URL |
+| `-o <path>` | Output path (file or dir) |
+| `--json` | Output as JSON |
+| `--login` | Refresh cookies only |
+
+## File Structure
+
+```
+x-to-markdown/
+└── {username}/
+    └── {tweet-id}.md
+```
+
+## Supported URLs
+
+- `https://x.com/<user>/status/<id>`
+- `https://twitter.com/<user>/status/<id>`
+- `https://x.com/i/article/<id>`
+
+## Output Format
+
+```markdown
+---
+url: https://x.com/username/status/123
+author: "Display Name (@username)"
+tweet_count: 3
+---
+
+Tweet content...
+
+---
+
+Thread continuation...
+```
+
+## Authentication
+
+**Option 1**: Environment variables (recommended)
+- `X_AUTH_TOKEN` - auth_token cookie
+- `X_CT0` - ct0 cookie
+
+**Option 2**: Chrome login (auto if env vars not set)
+- First run opens Chrome for login
+- Cookies cached locally
+
+## Extension Support
+
+Custom configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-danger-x-to-markdown/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-danger-x-to-markdown/EXTEND.md` (user)
+
+If found, load before workflow. Extension content overrides defaults.
@@ -0,0 +1,143 @@
+import { resolveXToMarkdownChromeProfileDir } from "./paths.js";
+
+export const DEFAULT_BEARER_TOKEN =
+  "Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA";
+export const DEFAULT_USER_AGENT =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36";
+export const X_LOGIN_URL = "https://x.com/home";
+export const X_USER_DATA_DIR = resolveXToMarkdownChromeProfileDir();
+
+export const X_COOKIE_NAMES = ["auth_token", "ct0", "gt", "twid"] as const;
+export const X_REQUIRED_COOKIES = ["auth_token", "ct0"] as const;
+
+export const FALLBACK_QUERY_ID = "id8pHQbQi7eZ6P9mA1th1Q";
+export const FALLBACK_FEATURE_SWITCHES = [
+  "profile_label_improvements_pcf_label_in_post_enabled",
+  "responsive_web_profile_redirect_enabled",
+  "rweb_tipjar_consumption_enabled",
+  "verified_phone_label_enabled",
+  "responsive_web_graphql_skip_user_profile_image_extensions_enabled",
+  "responsive_web_graphql_timeline_navigation_enabled",
+];
+export const FALLBACK_FIELD_TOGGLES = ["withPayments", "withAuxiliaryUserLabels"];
+
+export const FALLBACK_TWEET_QUERY_ID = "HJ9lpOL-ZlOk5CkCw0JW6Q";
+export const FALLBACK_TWEET_FEATURE_SWITCHES = [
+  "creator_subscriptions_tweet_preview_api_enabled",
+  "premium_content_api_read_enabled",
+  "communities_web_enable_tweet_community_results_fetch",
+  "c9s_tweet_anatomy_moderator_badge_enabled",
+  "responsive_web_grok_analyze_button_fetch_trends_enabled",
+  "responsive_web_grok_analyze_post_followups_enabled",
+  "responsive_web_jetfuel_frame",
+  "responsive_web_grok_share_attachment_enabled",
+  "responsive_web_grok_annotations_enabled",
+  "articles_preview_enabled",
+  "responsive_web_edit_tweet_api_enabled",
+  "graphql_is_translatable_rweb_tweet_is_translatable_enabled",
+  "view_counts_everywhere_api_enabled",
+  "longform_notetweets_consumption_enabled",
+  "responsive_web_twitter_article_tweet_consumption_enabled",
+  "tweet_awards_web_tipping_enabled",
+  "responsive_web_grok_show_grok_translated_post",
+  "responsive_web_grok_analysis_button_from_backend",
+  "post_ctas_fetch_enabled",
+  "creator_subscriptions_quote_tweet_preview_enabled",
+  "freedom_of_speech_not_reach_fetch_enabled",
+  "standardized_nudges_misinfo",
+  "tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled",
+  "longform_notetweets_rich_text_read_enabled",
+  "longform_notetweets_inline_media_enabled",
+  "profile_label_improvements_pcf_label_in_post_enabled",
+  "responsive_web_profile_redirect_enabled",
+  "rweb_tipjar_consumption_enabled",
+  "verified_phone_label_enabled",
+  "responsive_web_grok_image_annotation_enabled",
+  "responsive_web_grok_imagine_annotation_enabled",
+  "responsive_web_grok_community_note_auto_translation_is_enabled",
+  "responsive_web_graphql_skip_user_profile_image_extensions_enabled",
+  "responsive_web_graphql_timeline_navigation_enabled",
+  "responsive_web_enhance_cards_enabled",
+];
+export const FALLBACK_TWEET_FIELD_TOGGLES = [
+  "withArticleRichContentState",
+  "withArticlePlainText",
+  "withGrokAnalyze",
+  "withDisallowedReplyControls",
+  "withPayments",
+  "withAuxiliaryUserLabels",
+];
+
+export const FALLBACK_TWEET_DETAIL_QUERY_ID = "_8aYOgEDz35BrBcBal1-_w";
+export const FALLBACK_TWEET_DETAIL_FEATURE_SWITCHES = [
+  "rweb_video_screen_enabled",
+  "profile_label_improvements_pcf_label_in_post_enabled",
+  "rweb_tipjar_consumption_enabled",
+  "verified_phone_label_enabled",
+  "creator_subscriptions_tweet_preview_api_enabled",
+  "responsive_web_graphql_timeline_navigation_enabled",
+  "responsive_web_graphql_skip_user_profile_image_extensions_enabled",
+  "premium_content_api_read_enabled",
+  "communities_web_enable_tweet_community_results_fetch",
+  "c9s_tweet_anatomy_moderator_badge_enabled",
+  "responsive_web_grok_analyze_button_fetch_trends_enabled",
+  "responsive_web_grok_analyze_post_followups_enabled",
+  "responsive_web_jetfuel_frame",
+  "responsive_web_grok_share_attachment_enabled",
+  "articles_preview_enabled",
+  "responsive_web_edit_tweet_api_enabled",
+  "graphql_is_translatable_rweb_tweet_is_translatable_enabled",
+  "view_counts_everywhere_api_enabled",
+  "longform_notetweets_consumption_enabled",
+  "responsive_web_twitter_article_tweet_consumption_enabled",
+  "tweet_awards_web_tipping_enabled",
+  "responsive_web_grok_show_grok_translated_post",
+  "responsive_web_grok_analysis_button_from_backend",
+  "creator_subscriptions_quote_tweet_preview_enabled",
+  "freedom_of_speech_not_reach_fetch_enabled",
+  "standardized_nudges_misinfo",
+  "tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled",
+  "longform_notetweets_rich_text_read_enabled",
+  "longform_notetweets_inline_media_enabled",
+  "responsive_web_grok_image_annotation_enabled",
+  "responsive_web_enhance_cards_enabled",
+];
+export const FALLBACK_TWEET_DETAIL_FEATURE_DEFAULTS: Record<string, boolean> = {
+  rweb_video_screen_enabled: false,
+  profile_label_improvements_pcf_label_in_post_enabled: true,
+  rweb_tipjar_consumption_enabled: true,
+  verified_phone_label_enabled: false,
+  creator_subscriptions_tweet_preview_api_enabled: true,
+  responsive_web_graphql_timeline_navigation_enabled: true,
+  responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+  premium_content_api_read_enabled: false,
+  communities_web_enable_tweet_community_results_fetch: true,
+  c9s_tweet_anatomy_moderator_badge_enabled: true,
+  responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+  responsive_web_grok_analyze_post_followups_enabled: true,
+  responsive_web_jetfuel_frame: false,
+  responsive_web_grok_share_attachment_enabled: true,
+  articles_preview_enabled: true,
+  responsive_web_edit_tweet_api_enabled: true,
+  graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+  view_counts_everywhere_api_enabled: true,
+  longform_notetweets_consumption_enabled: true,
+  responsive_web_twitter_article_tweet_consumption_enabled: true,
+  tweet_awards_web_tipping_enabled: false,
+  responsive_web_grok_show_grok_translated_post: false,
+  responsive_web_grok_analysis_button_from_backend: true,
+  creator_subscriptions_quote_tweet_preview_enabled: false,
+  freedom_of_speech_not_reach_fetch_enabled: true,
+  standardized_nudges_misinfo: true,
+  tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+  longform_notetweets_rich_text_read_enabled: true,
+  longform_notetweets_inline_media_enabled: true,
+  responsive_web_grok_image_annotation_enabled: true,
+  responsive_web_enhance_cards_enabled: false,
+};
+export const FALLBACK_TWEET_DETAIL_FIELD_TOGGLES = [
+  "withArticleRichContentState",
+  "withArticlePlainText",
+  "withGrokAnalyze",
+  "withDisallowedReplyControls",
+];
@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+
+import { resolveXToMarkdownCookiePath } from "./paths.js";
+
+export type CookieMap = Record<string, string>;
+
+export type CookieFileData =
+  | {
+      cookies: CookieMap;
+      updated_at: number;
+      source?: string;
+    }
+  | {
+      version: number;
+      updatedAt: string;
+      cookieMap: CookieMap;
+      source?: string;
+    };
+
+export async function read_cookie_file(
+  p: string = resolveXToMarkdownCookiePath()
+): Promise<CookieMap | null> {
+  try {
+    if (!fs.existsSync(p) || !fs.statSync(p).isFile()) return null;
+    const raw = await readFile(p, "utf8");
+    const data = JSON.parse(raw) as unknown;
+
+    if (data && typeof data === "object" && "cookies" in (data as any)) {
+      const cookies = (data as any).cookies as unknown;
+      if (cookies && typeof cookies === "object") {
+        const out: CookieMap = {};
+        for (const [k, v] of Object.entries(cookies as Record<string, unknown>)) {
+          if (typeof v === "string") out[k] = v;
+        }
+        return Object.keys(out).length > 0 ? out : null;
+      }
+    }
+
+    if (data && typeof data === "object" && "cookieMap" in (data as any)) {
+      const cookies = (data as any).cookieMap as unknown;
+      if (cookies && typeof cookies === "object") {
+        const out: CookieMap = {};
+        for (const [k, v] of Object.entries(cookies as Record<string, unknown>)) {
+          if (typeof v === "string") out[k] = v;
+        }
+        return Object.keys(out).length > 0 ? out : null;
+      }
+    }
+
+    if (data && typeof data === "object") {
+      const out: CookieMap = {};
+      for (const [k, v] of Object.entries(data as Record<string, unknown>)) {
+        if (typeof v === "string") out[k] = v;
+      }
+      return Object.keys(out).length > 0 ? out : null;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function write_cookie_file(
+  cookies: CookieMap,
+  p: string = resolveXToMarkdownCookiePath(),
+  source?: string
+): Promise<void> {
+  const dir = path.dirname(p);
+  await mkdir(dir, { recursive: true });
+
+  const payload: CookieFileData = {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    cookieMap: cookies,
+    source,
+  };
+  await writeFile(p, JSON.stringify(payload, null, 2), "utf8");
+}
+
+export const readCookieFile = read_cookie_file;
+export const writeCookieFile = write_cookie_file;
+
@@ -0,0 +1,423 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs";
+import { mkdir } from "node:fs/promises";
+import net from "node:net";
+import process from "node:process";
+
+import { read_cookie_file, write_cookie_file } from "./cookie-file.js";
+import { resolveXToMarkdownCookiePath } from "./paths.js";
+import { X_COOKIE_NAMES, X_REQUIRED_COOKIES, X_LOGIN_URL, X_USER_DATA_DIR } from "./constants.js";
+import type { CookieLike } from "./types.js";
+
+type CdpSendOptions = { sessionId?: string; timeoutMs?: number };
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function fetchWithTimeout(
+  url: string,
+  init: RequestInit & { timeoutMs?: number } = {}
+): Promise<Response> {
+  const { timeoutMs, ...rest } = init;
+  if (!timeoutMs || timeoutMs <= 0) return fetch(url, rest);
+
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...rest, signal: ctl.signal });
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+class CdpConnection {
+  private ws: WebSocket;
+  private nextId = 0;
+  private pending = new Map<
+    number,
+    { resolve: (v: unknown) => void; reject: (e: Error) => void; timer: ReturnType<typeof setTimeout> | null }
+  >();
+
+  private constructor(ws: WebSocket) {
+    this.ws = ws;
+    this.ws.addEventListener("message", (event) => {
+      try {
+        const data =
+          typeof event.data === "string"
+            ? event.data
+            : new TextDecoder().decode(event.data as ArrayBuffer);
+        const msg = JSON.parse(data) as { id?: number; result?: unknown; error?: { message?: string } };
+        if (msg.id) {
+          const p = this.pending.get(msg.id);
+          if (p) {
+            this.pending.delete(msg.id);
+            if (p.timer) clearTimeout(p.timer);
+            if (msg.error?.message) p.reject(new Error(msg.error.message));
+            else p.resolve(msg.result);
+          }
+        }
+      } catch {}
+    });
+    this.ws.addEventListener("close", () => {
+      for (const [id, p] of this.pending.entries()) {
+        this.pending.delete(id);
+        if (p.timer) clearTimeout(p.timer);
+        p.reject(new Error("CDP connection closed."));
+      }
+    });
+  }
+
+  static async connect(url: string, timeoutMs: number): Promise<CdpConnection> {
+    const ws = new WebSocket(url);
+    await new Promise<void>((resolve, reject) => {
+      const t = setTimeout(() => reject(new Error("CDP connection timeout.")), timeoutMs);
+      ws.addEventListener("open", () => {
+        clearTimeout(t);
+        resolve();
+      });
+      ws.addEventListener("error", () => {
+        clearTimeout(t);
+        reject(new Error("CDP connection failed."));
+      });
+    });
+    return new CdpConnection(ws);
+  }
+
+  async send<T = unknown>(
+    method: string,
+    params?: Record<string, unknown>,
+    opts?: CdpSendOptions
+  ): Promise<T> {
+    const id = ++this.nextId;
+    const msg: Record<string, unknown> = { id, method };
+    if (params) msg.params = params;
+    if (opts?.sessionId) msg.sessionId = opts.sessionId;
+
+    const timeoutMs = opts?.timeoutMs ?? 15_000;
+    const out = await new Promise<unknown>((resolve, reject) => {
+      const t =
+        timeoutMs > 0
+          ? setTimeout(() => {
+              this.pending.delete(id);
+              reject(new Error(`CDP timeout: ${method}`));
+            }, timeoutMs)
+          : null;
+      this.pending.set(id, { resolve, reject, timer: t });
+      this.ws.send(JSON.stringify(msg));
+    });
+    return out as T;
+  }
+
+  close(): void {
+    try {
+      this.ws.close();
+    } catch {}
+  }
+}
+
+async function getFreePort(): Promise<number> {
+  return await new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.unref();
+    srv.on("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      if (!addr || typeof addr === "string") {
+        srv.close(() => reject(new Error("Unable to allocate a free TCP port.")));
+        return;
+      }
+      const port = addr.port;
+      srv.close((err) => (err ? reject(err) : resolve(port)));
+    });
+  });
+}
+
+function findChromeExecutable(): string | null {
+  const override = process.env.X_CHROME_PATH?.trim();
+  if (override && fs.existsSync(override)) return override;
+
+  const candidates: string[] = [];
+  switch (process.platform) {
+    case "darwin":
+      candidates.push(
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+        "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+      );
+      break;
+    case "win32":
+      candidates.push(
+        "C:\\\\Program Files\\\\Google\\\\Chrome\\\\Application\\\\chrome.exe",
+        "C:\\\\Program Files (x86)\\\\Google\\\\Chrome\\\\Application\\\\chrome.exe",
+        "C:\\\\Program Files\\\\Microsoft\\\\Edge\\\\Application\\\\msedge.exe",
+        "C:\\\\Program Files (x86)\\\\Microsoft\\\\Edge\\\\Application\\\\msedge.exe"
+      );
+      break;
+    default:
+      candidates.push(
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        "/snap/bin/chromium",
+        "/usr/bin/microsoft-edge"
+      );
+      break;
+  }
+
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+async function waitForChromeDebugPort(port: number, timeoutMs: number): Promise<string> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetchWithTimeout(`http://127.0.0.1:${port}/json/version`, { timeoutMs: 5_000 });
+      if (!res.ok) throw new Error(`status=${res.status}`);
+      const j = (await res.json()) as { webSocketDebuggerUrl?: string };
+      if (j.webSocketDebuggerUrl) return j.webSocketDebuggerUrl;
+    } catch {}
+    await sleep(200);
+  }
+  throw new Error("Chrome debug port not ready");
+}
+
+async function launchChrome(profileDir: string, port: number): Promise<ChildProcess> {
+  const chrome = findChromeExecutable();
+  if (!chrome) throw new Error("Chrome executable not found.");
+
+  const args = [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${profileDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-popup-blocking",
+    X_LOGIN_URL,
+  ];
+
+  return spawn(chrome, args, { stdio: "ignore" });
+}
+
+async function fetchXCookiesViaCdp(
+  profileDir: string,
+  timeoutMs: number,
+  verbose: boolean,
+  log?: (message: string) => void
+): Promise<Record<string, string>> {
+  await mkdir(profileDir, { recursive: true });
+
+  const port = await getFreePort();
+  const chrome = await launchChrome(profileDir, port);
+
+  let cdp: CdpConnection | null = null;
+  try {
+    const wsUrl = await waitForChromeDebugPort(port, 30_000);
+    cdp = await CdpConnection.connect(wsUrl, 15_000);
+
+    const { targetId } = await cdp.send<{ targetId: string }>("Target.createTarget", {
+      url: X_LOGIN_URL,
+      newWindow: true,
+    });
+    const { sessionId } = await cdp.send<{ sessionId: string }>("Target.attachToTarget", { targetId, flatten: true });
+    await cdp.send("Network.enable", {}, { sessionId });
+
+    if (verbose) {
+      log?.("[x-cookies] Chrome opened. If needed, complete X login in the window. Waiting for cookies...");
+    }
+
+    const start = Date.now();
+    let last: Record<string, string> = {};
+
+    while (Date.now() - start < timeoutMs) {
+      const { cookies } = await cdp.send<{ cookies: CookieLike[] }>(
+        "Network.getCookies",
+        { urls: ["https://x.com/", "https://twitter.com/"] },
+        { sessionId, timeoutMs: 10_000 }
+      );
+
+      const m = buildXCookieMap((cookies ?? []).filter(Boolean));
+      last = m;
+      if (hasRequiredXCookies(m)) {
+        return m;
+      }
+
+      await sleep(1000);
+    }
+
+    throw new Error(`Timed out waiting for X cookies. Last keys: ${Object.keys(last).join(", ")}`);
+  } finally {
+    if (cdp) {
+      try {
+        await cdp.send("Browser.close", {}, { timeoutMs: 5_000 });
+      } catch {}
+      cdp.close();
+    }
+
+    try {
+      chrome.kill("SIGTERM");
+    } catch {}
+    setTimeout(() => {
+      if (!chrome.killed) {
+        try {
+          chrome.kill("SIGKILL");
+        } catch {}
+      }
+    }, 2_000).unref?.();
+  }
+}
+
+function resolveCookieDomain(cookie: CookieLike): string | null {
+  const rawDomain = cookie.domain?.trim();
+  if (rawDomain) {
+    return rawDomain.startsWith(".") ? rawDomain.slice(1) : rawDomain;
+  }
+  const rawUrl = cookie.url?.trim();
+  if (rawUrl) {
+    try {
+      return new URL(rawUrl).hostname;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+function pickCookieValue<T extends CookieLike>(cookies: T[], name: string): string | undefined {
+  const matches = cookies.filter((cookie) => cookie.name === name && typeof cookie.value === "string");
+  if (matches.length === 0) return undefined;
+
+  const preferred = matches.find((cookie) => {
+    const domain = resolveCookieDomain(cookie);
+    return domain === "x.com" && (cookie.path ?? "/") === "/";
+  });
+  const xDomain = matches.find((cookie) => (resolveCookieDomain(cookie) ?? "").endsWith("x.com"));
+  const twitterDomain = matches.find((cookie) => (resolveCookieDomain(cookie) ?? "").endsWith("twitter.com"));
+  return (preferred ?? xDomain ?? twitterDomain ?? matches[0])?.value;
+}
+
+function buildXCookieMap<T extends CookieLike>(cookies: T[]): Record<string, string> {
+  const cookieMap: Record<string, string> = {};
+  for (const name of X_COOKIE_NAMES) {
+    const value = pickCookieValue(cookies, name);
+    if (value) cookieMap[name] = value;
+  }
+  return cookieMap;
+}
+
+export function hasRequiredXCookies(cookieMap: Record<string, string>): boolean {
+  return X_REQUIRED_COOKIES.every((name) => Boolean(cookieMap[name]));
+}
+
+function filterXCookieMap(cookieMap: Record<string, string>): Record<string, string> {
+  const filtered: Record<string, string> = {};
+  for (const name of X_COOKIE_NAMES) {
+    const value = cookieMap[name];
+    if (value) filtered[name] = value;
+  }
+  return filtered;
+}
+
+function buildInlineCookiesFromEnv(): CookieLike[] {
+  const cookies: CookieLike[] = [];
+  const authToken = process.env.X_AUTH_TOKEN?.trim();
+  const ct0 = process.env.X_CT0?.trim();
+  const gt = process.env.X_GUEST_TOKEN?.trim();
+  const twid = process.env.X_TWID?.trim();
+
+  if (authToken) {
+    cookies.push({ name: "auth_token", value: authToken, domain: "x.com", path: "/" });
+  }
+  if (ct0) {
+    cookies.push({ name: "ct0", value: ct0, domain: "x.com", path: "/" });
+  }
+  if (gt) {
+    cookies.push({ name: "gt", value: gt, domain: "x.com", path: "/" });
+  }
+  if (twid) {
+    cookies.push({ name: "twid", value: twid, domain: "x.com", path: "/" });
+  }
+
+  return cookies;
+}
+
+async function loadXCookiesFromInline(log?: (message: string) => void): Promise<Record<string, string>> {
+  const inline = buildInlineCookiesFromEnv();
+  if (inline.length === 0) return {};
+
+  const cookieMap = buildXCookieMap(
+    inline.filter((cookie): cookie is CookieLike => Boolean(cookie?.name && typeof cookie.value === "string"))
+  );
+
+  if (Object.keys(cookieMap).length > 0) {
+    log?.(`[x-cookies] Loaded X cookies from env: ${Object.keys(cookieMap).length} cookie(s).`);
+  } else {
+    log?.("[x-cookies] Env cookies provided but no X cookies matched.");
+  }
+
+  return cookieMap;
+}
+
+async function loadXCookiesFromFile(log?: (message: string) => void): Promise<Record<string, string>> {
+  const cookiePath = resolveXToMarkdownCookiePath();
+  const fileMap = filterXCookieMap((await read_cookie_file(cookiePath)) ?? {});
+  if (Object.keys(fileMap).length > 0) {
+    log?.(`[x-cookies] Loaded X cookies from file: ${cookiePath} (${Object.keys(fileMap).length} cookie(s))`);
+  }
+  return fileMap;
+}
+
+async function loadXCookiesFromCdp(log?: (message: string) => void): Promise<Record<string, string>> {
+  try {
+    const cookieMap = await fetchXCookiesViaCdp(X_USER_DATA_DIR, 5 * 60 * 1000, true, log);
+    if (!hasRequiredXCookies(cookieMap)) return cookieMap;
+
+    const cookiePath = resolveXToMarkdownCookiePath();
+    try {
+      await write_cookie_file(cookieMap, cookiePath, "cdp");
+      log?.(`[x-cookies] Cookies saved to ${cookiePath}`);
+    } catch (error) {
+      log?.(
+        `[x-cookies] Failed to write cookie file (${cookiePath}): ${
+          error instanceof Error ? error.message : String(error ?? "")
+        }`
+      );
+    }
+    if (cookieMap.auth_token) log?.(`[x-cookies] auth_token: ${cookieMap.auth_token.slice(0, 20)}...`);
+    if (cookieMap.ct0) log?.(`[x-cookies] ct0: ${cookieMap.ct0.slice(0, 20)}...`);
+    return cookieMap;
+  } catch (error) {
+    log?.(
+      `[x-cookies] Failed to load cookies via Chrome DevTools Protocol: ${
+        error instanceof Error ? error.message : String(error ?? "")
+      }`
+    );
+    return {};
+  }
+}
+
+export async function loadXCookies(log?: (message: string) => void): Promise<Record<string, string>> {
+  const inlineMap = await loadXCookiesFromInline(log);
+  const fileMap = await loadXCookiesFromFile(log);
+  const combined = { ...fileMap, ...inlineMap };
+
+  if (hasRequiredXCookies(combined)) return combined;
+
+  const cdpMap = await loadXCookiesFromCdp(log);
+  return { ...fileMap, ...cdpMap, ...inlineMap };
+}
+
+export async function refreshXCookies(log?: (message: string) => void): Promise<Record<string, string>> {
+  return loadXCookiesFromCdp(log);
+}
+
+export function buildCookieHeader(cookieMap: Record<string, string>): string | undefined {
+  const entries = Object.entries(cookieMap).filter(([, value]) => value);
+  if (entries.length === 0) return undefined;
+  return entries.map(([key, value]) => `${key}=${value}`).join("; ");
+}
@@ -0,0 +1,389 @@
+import {
+  DEFAULT_BEARER_TOKEN,
+  DEFAULT_USER_AGENT,
+  FALLBACK_FEATURE_SWITCHES,
+  FALLBACK_FIELD_TOGGLES,
+  FALLBACK_QUERY_ID,
+  FALLBACK_TWEET_DETAIL_FEATURE_DEFAULTS,
+  FALLBACK_TWEET_DETAIL_FEATURE_SWITCHES,
+  FALLBACK_TWEET_DETAIL_FIELD_TOGGLES,
+  FALLBACK_TWEET_DETAIL_QUERY_ID,
+  FALLBACK_TWEET_FEATURE_SWITCHES,
+  FALLBACK_TWEET_FIELD_TOGGLES,
+  FALLBACK_TWEET_QUERY_ID,
+} from "./constants.js";
+import {
+  buildFeatureMap,
+  buildFieldToggleMap,
+  buildRequestHeaders,
+  buildTweetFieldToggleMap,
+  fetchHomeHtml,
+  fetchText,
+  parseStringList,
+} from "./http.js";
+import type { ArticleQueryInfo } from "./types.js";
+
+function isNonEmptyObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && Object.keys(value as Record<string, unknown>).length > 0);
+}
+
+function unwrapTweetResult(result: any): any {
+  if (!result) return null;
+  if (result.__typename === "TweetWithVisibilityResults" && result.tweet) {
+    return result.tweet;
+  }
+  return result;
+}
+
+function extractArticleFromTweet(payload: unknown): unknown {
+  const root = (payload as { data?: any }).data ?? payload;
+  const result = root?.tweetResult?.result ?? root?.tweet_result?.result ?? root?.tweet_result;
+  const tweet = unwrapTweetResult(result);
+  const legacy = tweet?.legacy ?? {};
+  const article = legacy?.article ?? tweet?.article;
+  return (
+    article?.article_results?.result ??
+    legacy?.article_results?.result ??
+    tweet?.article_results?.result ??
+    null
+  );
+}
+
+function extractTweetFromPayload(payload: unknown): unknown {
+  const root = (payload as { data?: any }).data ?? payload;
+  const result = root?.tweetResult?.result ?? root?.tweet_result?.result ?? root?.tweet_result;
+  return unwrapTweetResult(result);
+}
+
+function extractArticleFromEntity(payload: unknown): unknown {
+  const root = (payload as { data?: any }).data ?? payload;
+  return (
+    root?.article_result_by_rest_id?.result ??
+    root?.article_result_by_rest_id ??
+    root?.article_entity_result?.result ??
+    null
+  );
+}
+
+async function resolveArticleQueryInfo(userAgent: string): Promise<ArticleQueryInfo> {
+  const html = await fetchHomeHtml(userAgent);
+
+  const bundleMatch = html.match(/"bundle\\.TwitterArticles":"([a-z0-9]+)"/);
+  if (!bundleMatch) {
+    return {
+      queryId: FALLBACK_QUERY_ID,
+      featureSwitches: FALLBACK_FEATURE_SWITCHES,
+      fieldToggles: FALLBACK_FIELD_TOGGLES,
+      html,
+    };
+  }
+
+  const bundleHash = bundleMatch[1];
+  const chunkUrl = `https://abs.twimg.com/responsive-web/client-web/bundle.TwitterArticles.${bundleHash}a.js`;
+  const chunk = await fetchText(chunkUrl, {
+    headers: {
+      "user-agent": userAgent,
+    },
+  });
+
+  const queryIdMatch = chunk.match(/queryId:\"([^\"]+)\",operationName:\"ArticleEntityResultByRestId\"/);
+  const featureMatch = chunk.match(
+    /operationName:\"ArticleEntityResultByRestId\"[\s\S]*?featureSwitches:\[(.*?)\]/
+  );
+  const fieldToggleMatch = chunk.match(
+    /operationName:\"ArticleEntityResultByRestId\"[\s\S]*?fieldToggles:\[(.*?)\]/
+  );
+
+  const featureSwitches = parseStringList(featureMatch?.[1]);
+  const fieldToggles = parseStringList(fieldToggleMatch?.[1]);
+
+  return {
+    queryId: queryIdMatch?.[1] ?? FALLBACK_QUERY_ID,
+    featureSwitches: featureSwitches.length > 0 ? featureSwitches : FALLBACK_FEATURE_SWITCHES,
+    fieldToggles: fieldToggles.length > 0 ? fieldToggles : FALLBACK_FIELD_TOGGLES,
+    html,
+  };
+}
+
+function resolveMainChunkHash(html: string): string | null {
+  const match = html.match(/main\\.([a-z0-9]+)\\.js/);
+  return match?.[1] ?? null;
+}
+
+function resolveApiChunkHash(html: string): string | null {
+  const match = html.match(/api:\"([a-zA-Z0-9_-]+)\"/);
+  return match?.[1] ?? null;
+}
+
+async function resolveTweetDetailQueryInfo(userAgent: string): Promise<ArticleQueryInfo> {
+  const html = await fetchHomeHtml(userAgent);
+  const apiHash = resolveApiChunkHash(html);
+  if (!apiHash) {
+    return {
+      queryId: FALLBACK_TWEET_DETAIL_QUERY_ID,
+      featureSwitches: FALLBACK_TWEET_DETAIL_FEATURE_SWITCHES,
+      fieldToggles: FALLBACK_TWEET_DETAIL_FIELD_TOGGLES,
+      html,
+    };
+  }
+
+  const chunkUrl = `https://abs.twimg.com/responsive-web/client-web/api.${apiHash}a.js`;
+  const chunk = await fetchText(chunkUrl, {
+    headers: {
+      "user-agent": userAgent,
+    },
+  });
+
+  const queryIdMatch = chunk.match(/queryId:\"([^\"]+)\",operationName:\"TweetDetail\"/);
+  const featureMatch = chunk.match(
+    /operationName:\"TweetDetail\"[\s\S]*?featureSwitches:\[(.*?)\]/
+  );
+  const fieldToggleMatch = chunk.match(
+    /operationName:\"TweetDetail\"[\s\S]*?fieldToggles:\[(.*?)\]/
+  );
+
+  const featureSwitches = parseStringList(featureMatch?.[1]);
+  const fieldToggles = parseStringList(fieldToggleMatch?.[1]);
+
+  return {
+    queryId: queryIdMatch?.[1] ?? FALLBACK_TWEET_DETAIL_QUERY_ID,
+    featureSwitches: featureSwitches.length > 0 ? featureSwitches : FALLBACK_TWEET_DETAIL_FEATURE_SWITCHES,
+    fieldToggles: fieldToggles.length > 0 ? fieldToggles : FALLBACK_TWEET_DETAIL_FIELD_TOGGLES,
+    html,
+  };
+}
+
+function buildTweetDetailFieldToggleMap(keys: string[]): Record<string, boolean> {
+  const toggles = buildFieldToggleMap(keys);
+  if (Object.prototype.hasOwnProperty.call(toggles, "withArticlePlainText")) {
+    toggles.withArticlePlainText = false;
+  }
+  if (Object.prototype.hasOwnProperty.call(toggles, "withGrokAnalyze")) {
+    toggles.withGrokAnalyze = false;
+  }
+  if (Object.prototype.hasOwnProperty.call(toggles, "withDisallowedReplyControls")) {
+    toggles.withDisallowedReplyControls = false;
+  }
+  return toggles;
+}
+
+async function resolveTweetQueryInfo(userAgent: string): Promise<ArticleQueryInfo> {
+  const html = await fetchHomeHtml(userAgent);
+  const mainHash = resolveMainChunkHash(html);
+  if (!mainHash) {
+    return {
+      queryId: FALLBACK_TWEET_QUERY_ID,
+      featureSwitches: FALLBACK_TWEET_FEATURE_SWITCHES,
+      fieldToggles: FALLBACK_TWEET_FIELD_TOGGLES,
+      html,
+    };
+  }
+
+  const chunkUrl = `https://abs.twimg.com/responsive-web/client-web/main.${mainHash}.js`;
+  const chunk = await fetchText(chunkUrl, {
+    headers: {
+      "user-agent": userAgent,
+    },
+  });
+
+  const queryIdMatch = chunk.match(/queryId:\"([^\"]+)\",operationName:\"TweetResultByRestId\"/);
+  const featureMatch = chunk.match(
+    /operationName:\"TweetResultByRestId\"[\s\S]*?featureSwitches:\[(.*?)\]/
+  );
+  const fieldToggleMatch = chunk.match(
+    /operationName:\"TweetResultByRestId\"[\s\S]*?fieldToggles:\[(.*?)\]/
+  );
+
+  const featureSwitches = parseStringList(featureMatch?.[1]);
+  const fieldToggles = parseStringList(fieldToggleMatch?.[1]);
+
+  return {
+    queryId: queryIdMatch?.[1] ?? FALLBACK_TWEET_QUERY_ID,
+    featureSwitches: featureSwitches.length > 0 ? featureSwitches : FALLBACK_TWEET_FEATURE_SWITCHES,
+    fieldToggles: fieldToggles.length > 0 ? fieldToggles : FALLBACK_TWEET_FIELD_TOGGLES,
+    html,
+  };
+}
+
+async function fetchTweetResult(
+  tweetId: string,
+  cookieMap: Record<string, string>,
+  userAgent: string,
+  bearerToken: string
+): Promise<unknown> {
+  const queryInfo = await resolveTweetQueryInfo(userAgent);
+  const features = buildFeatureMap(queryInfo.html, queryInfo.featureSwitches);
+  const fieldToggles = buildTweetFieldToggleMap(queryInfo.fieldToggles);
+
+  const url = new URL(`https://x.com/i/api/graphql/${queryInfo.queryId}/TweetResultByRestId`);
+  url.searchParams.set(
+    "variables",
+    JSON.stringify({
+      tweetId,
+      withCommunity: false,
+      includePromotedContent: false,
+      withVoice: true,
+    })
+  );
+  if (Object.keys(features).length > 0) {
+    url.searchParams.set("features", JSON.stringify(features));
+  }
+  if (Object.keys(fieldToggles).length > 0) {
+    url.searchParams.set("fieldToggles", JSON.stringify(fieldToggles));
+  }
+
+  const response = await fetch(url.toString(), {
+    headers: buildRequestHeaders(cookieMap, userAgent, bearerToken),
+  });
+
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`X API error (${response.status}): ${text.slice(0, 400)}`);
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Failed to parse response JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export async function fetchTweetDetail(
+  tweetId: string,
+  cookieMap: Record<string, string>,
+  cursor?: string
+): Promise<unknown> {
+  const userAgent = process.env.X_USER_AGENT?.trim() || DEFAULT_USER_AGENT;
+  const bearerToken = process.env.X_BEARER_TOKEN?.trim() || DEFAULT_BEARER_TOKEN;
+  const queryInfo = await resolveTweetDetailQueryInfo(userAgent);
+  const features = buildFeatureMap(
+    queryInfo.html,
+    queryInfo.featureSwitches,
+    FALLBACK_TWEET_DETAIL_FEATURE_DEFAULTS
+  );
+  const fieldToggles = buildTweetDetailFieldToggleMap(queryInfo.fieldToggles);
+
+  const url = new URL(`https://x.com/i/api/graphql/${queryInfo.queryId}/TweetDetail`);
+  url.searchParams.set(
+    "variables",
+    JSON.stringify({
+      focalTweetId: tweetId,
+      cursor,
+      referrer: cursor ? "tweet" : undefined,
+      with_rux_injections: false,
+      includePromotedContent: true,
+      withCommunity: true,
+      withQuickPromoteEligibilityTweetFields: true,
+      withBirdwatchNotes: true,
+      withVoice: true,
+      withV2Timeline: true,
+      withDownvotePerspective: false,
+      withReactionsMetadata: false,
+      withReactionsPerspective: false,
+      withSuperFollowsTweetFields: false,
+      withSuperFollowsUserFields: false,
+    })
+  );
+  if (Object.keys(features).length > 0) {
+    url.searchParams.set("features", JSON.stringify(features));
+  }
+  if (Object.keys(fieldToggles).length > 0) {
+    url.searchParams.set("fieldToggles", JSON.stringify(fieldToggles));
+  }
+
+  const response = await fetch(url.toString(), {
+    headers: buildRequestHeaders(cookieMap, userAgent, bearerToken),
+  });
+
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`X API error (${response.status}): ${text.slice(0, 400)}`);
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Failed to parse response JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+async function fetchArticleEntityById(
+  articleEntityId: string,
+  cookieMap: Record<string, string>,
+  userAgent: string,
+  bearerToken: string
+): Promise<unknown> {
+  const queryInfo = await resolveArticleQueryInfo(userAgent);
+  const features = buildFeatureMap(queryInfo.html, queryInfo.featureSwitches);
+  const fieldToggles = buildFieldToggleMap(queryInfo.fieldToggles);
+
+  const url = new URL(`https://x.com/i/api/graphql/${queryInfo.queryId}/ArticleEntityResultByRestId`);
+  url.searchParams.set("variables", JSON.stringify({ articleEntityId }));
+  if (Object.keys(features).length > 0) {
+    url.searchParams.set("features", JSON.stringify(features));
+  }
+  if (Object.keys(fieldToggles).length > 0) {
+    url.searchParams.set("fieldToggles", JSON.stringify(fieldToggles));
+  }
+
+  const response = await fetch(url.toString(), {
+    headers: buildRequestHeaders(cookieMap, userAgent, bearerToken),
+  });
+
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`X API error (${response.status}): ${text.slice(0, 400)}`);
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Failed to parse response JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export async function fetchXArticle(
+  articleId: string,
+  cookieMap: Record<string, string>,
+  raw: boolean
+): Promise<unknown> {
+  const userAgent = process.env.X_USER_AGENT?.trim() || DEFAULT_USER_AGENT;
+  const bearerToken = process.env.X_BEARER_TOKEN?.trim() || DEFAULT_BEARER_TOKEN;
+
+  const tweetPayload = await fetchTweetResult(articleId, cookieMap, userAgent, bearerToken);
+  if (raw) {
+    return tweetPayload;
+  }
+
+  const articleFromTweet = extractArticleFromTweet(tweetPayload);
+  if (isNonEmptyObject(articleFromTweet)) {
+    return articleFromTweet;
+  }
+
+  const articlePayload = await fetchArticleEntityById(articleId, cookieMap, userAgent, bearerToken);
+  const articleFromEntity = extractArticleFromEntity(articlePayload);
+  if (isNonEmptyObject(articleFromEntity)) {
+    return articleFromEntity;
+  }
+  return articleFromEntity ?? articlePayload;
+}
+
+export async function fetchXTweet(
+  tweetId: string,
+  cookieMap: Record<string, string>,
+  raw: boolean
+): Promise<unknown> {
+  const userAgent = process.env.X_USER_AGENT?.trim() || DEFAULT_USER_AGENT;
+  const bearerToken = process.env.X_BEARER_TOKEN?.trim() || DEFAULT_BEARER_TOKEN;
+
+  const tweetPayload = await fetchTweetResult(tweetId, cookieMap, userAgent, bearerToken);
+  if (raw) {
+    return tweetPayload;
+  }
+
+  const tweet = extractTweetFromPayload(tweetPayload);
+  if (isNonEmptyObject(tweet)) {
+    return tweet;
+  }
+  return tweet ?? tweetPayload;
+}
@@ -0,0 +1,117 @@
+import { buildCookieHeader } from "./cookies.js";
+
+let cachedHomeHtml: { userAgent: string; html: string } | null = null;
+
+export async function fetchText(url: string, init?: RequestInit): Promise<string> {
+  const response = await fetch(url, init);
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`Request failed (${response.status}) for ${url}: ${text.slice(0, 200)}`);
+  }
+  return text;
+}
+
+export async function fetchHomeHtml(userAgent: string): Promise<string> {
+  if (cachedHomeHtml?.userAgent === userAgent) {
+    return cachedHomeHtml.html;
+  }
+  const html = await fetchText("https://x.com", {
+    headers: {
+      "user-agent": userAgent,
+    },
+  });
+  cachedHomeHtml = { userAgent, html };
+  return html;
+}
+
+export function parseStringList(raw: string | undefined): string[] {
+  if (!raw) return [];
+  return raw
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .map((item) => item.replace(/^\"|\"$/g, ""));
+}
+
+export function resolveFeatureValue(html: string, key: string): boolean | undefined {
+  const keyPattern = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const unescaped = new RegExp(`"${keyPattern}"\\s*:\\s*\\{"value"\\s*:\\s*(true|false)`);
+  const escaped = new RegExp(`\\\\"${keyPattern}\\\\"\\s*:\\s*\\\\{\\\\"value\\\\"\\s*:\\s*(true|false)`);
+  const match = html.match(unescaped) ?? html.match(escaped);
+  if (!match) return undefined;
+  return match[1] === "true";
+}
+
+export function buildFeatureMap(
+  html: string,
+  keys: string[],
+  defaults?: Record<string, boolean>
+): Record<string, boolean> {
+  const features: Record<string, boolean> = {};
+  for (const key of keys) {
+    const value = resolveFeatureValue(html, key);
+    if (value !== undefined) {
+      features[key] = value;
+    } else if (defaults && Object.prototype.hasOwnProperty.call(defaults, key)) {
+      features[key] = defaults[key] ?? true;
+    } else {
+      features[key] = true;
+    }
+  }
+  if (!Object.prototype.hasOwnProperty.call(features, "responsive_web_graphql_exclude_directive_enabled")) {
+    features.responsive_web_graphql_exclude_directive_enabled = true;
+  }
+  return features;
+}
+
+export function buildFieldToggleMap(keys: string[]): Record<string, boolean> {
+  const toggles: Record<string, boolean> = {};
+  for (const key of keys) {
+    toggles[key] = true;
+  }
+  return toggles;
+}
+
+export function buildTweetFieldToggleMap(keys: string[]): Record<string, boolean> {
+  const toggles: Record<string, boolean> = {};
+  for (const key of keys) {
+    if (key === "withGrokAnalyze" || key === "withDisallowedReplyControls") {
+      toggles[key] = false;
+    } else {
+      toggles[key] = true;
+    }
+  }
+  return toggles;
+}
+
+export function buildRequestHeaders(
+  cookieMap: Record<string, string>,
+  userAgent: string,
+  bearerToken: string
+): Record<string, string> {
+  const headers: Record<string, string> = {
+    authorization: bearerToken,
+    "user-agent": userAgent,
+    accept: "application/json",
+    "x-twitter-active-user": "yes",
+    "x-twitter-client-language": "en",
+    "accept-language": "en",
+  };
+
+  if (cookieMap.auth_token) {
+    headers["x-twitter-auth-type"] = "OAuth2Session";
+  }
+
+  const cookieHeader = buildCookieHeader(cookieMap);
+  if (cookieHeader) {
+    headers.cookie = cookieHeader;
+  }
+  if (cookieMap.ct0) {
+    headers["x-csrf-token"] = cookieMap.ct0;
+  }
+  if (process.env.X_CLIENT_TRANSACTION_ID?.trim()) {
+    headers["x-client-transaction-id"] = process.env.X_CLIENT_TRANSACTION_ID.trim();
+  }
+
+  return headers;
+}
@@ -0,0 +1,419 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import process from "node:process";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+
+import { fetchXArticle } from "./graphql.js";
+import { formatArticleMarkdown } from "./markdown.js";
+import { hasRequiredXCookies, loadXCookies, refreshXCookies } from "./cookies.js";
+import { resolveXToMarkdownConsentPath } from "./paths.js";
+import { tweetToMarkdown } from "./tweet-to-markdown.js";
+
+type CliArgs = {
+  url: string | null;
+  output: string | null;
+  json: boolean;
+  login: boolean;
+  help: boolean;
+};
+
+type ConsentRecord = {
+  version: number;
+  accepted: boolean;
+  acceptedAt: string;
+  disclaimerVersion: string;
+};
+
+const DISCLAIMER_VERSION = "1.0";
+
+function printUsage(exitCode: number): never {
+  const cmd = "npx -y bun skills/baoyu-danger-x-to-markdown/scripts/main.ts";
+  console.log(`X (Twitter) to Markdown
+
+Usage:
+  ${cmd} <url>
+  ${cmd} --url <url>
+
+Options:
+  --output <path>, -o  Output path (file or dir). Default: ./x-to-markdown/<slug>/
+  --json               Output as JSON
+  --login              Refresh cookies only, then exit
+  --help, -h           Show help
+
+Examples:
+  ${cmd} https://x.com/username/status/1234567890
+  ${cmd} https://x.com/i/article/1234567890 -o ./article.md
+  ${cmd} https://x.com/username/status/1234567890 -o ./out/
+  ${cmd} https://x.com/username/status/1234567890 --json | jq -r '.markdownPath'
+  ${cmd} --login
+`);
+  process.exit(exitCode);
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const out: CliArgs = {
+    url: null,
+    output: null,
+    json: false,
+    login: false,
+    help: false,
+  };
+
+  const positional: string[] = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+
+    if (a === "--help" || a === "-h") {
+      out.help = true;
+      continue;
+    }
+
+    if (a === "--json") {
+      out.json = true;
+      continue;
+    }
+
+    if (a === "--login") {
+      out.login = true;
+      continue;
+    }
+
+    if (a === "--url") {
+      const v = argv[++i];
+      if (!v) throw new Error("Missing value for --url");
+      out.url = v;
+      continue;
+    }
+
+    if (a === "--output" || a === "-o") {
+      const v = argv[++i];
+      if (!v) throw new Error(`Missing value for ${a}`);
+      out.output = v;
+      continue;
+    }
+
+    if (a.startsWith("-")) {
+      throw new Error(`Unknown option: ${a}`);
+    }
+
+    positional.push(a);
+  }
+
+  if (!out.url && positional.length > 0) {
+    out.url = positional[0]!;
+  }
+
+  return out;
+}
+
+function normalizeInputUrl(input: string): string {
+  const trimmed = input.trim();
+  if (!trimmed) return "";
+  try {
+    return new URL(trimmed).toString();
+  } catch {
+    return trimmed;
+  }
+}
+
+function parseArticleId(input: string): string | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+
+  try {
+    const parsed = new URL(trimmed);
+    const match = parsed.pathname.match(/\/(?:i\/)?article\/(\d+)/);
+    if (match?.[1]) return match[1];
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function parseTweetId(input: string): string | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  if (/^\d+$/.test(trimmed)) return trimmed;
+
+  try {
+    const parsed = new URL(trimmed);
+    const match = parsed.pathname.match(/\/status(?:es)?\/(\d+)/);
+    if (match?.[1]) return match[1];
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function parseTweetUsername(input: string): string | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = new URL(trimmed);
+    const match = parsed.pathname.match(/^\/([^/]+)\/status(?:es)?\/\d+/);
+    if (match?.[1]) return match[1];
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function sanitizeSlug(input: string): string {
+  return input
+    .trim()
+    .replace(/^@/, "")
+    .replace(/[^a-zA-Z0-9_-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^[-_]+|[-_]+$/g, "")
+    .slice(0, 120);
+}
+
+function formatBackupTimestamp(date: Date = new Date()): string {
+  const pad2 = (n: number) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}${pad2(date.getMonth() + 1)}${pad2(date.getDate())}-${pad2(date.getHours())}${pad2(
+    date.getMinutes()
+  )}${pad2(date.getSeconds())}`;
+}
+
+async function backupDirIfExists(dir: string, log: (message: string) => void): Promise<void> {
+  try {
+    if (!fs.existsSync(dir)) return;
+    const stat = fs.statSync(dir);
+    if (!stat.isDirectory()) return;
+    const backup = `${dir}-backup-${formatBackupTimestamp()}`;
+    await rename(dir, backup);
+    log(`[x-to-markdown] Existing directory moved to: ${backup}`);
+  } catch (error) {
+    throw new Error(
+      `Failed to backup existing directory (${dir}): ${error instanceof Error ? error.message : String(error ?? "")}`
+    );
+  }
+}
+
+function resolveDefaultOutputDir(slug: string): string {
+  return path.resolve(process.cwd(), "x-to-markdown", slug);
+}
+
+async function resolveOutputPath(
+  normalizedUrl: string,
+  kind: "tweet" | "article",
+  argsOutput: string | null,
+  log: (message: string) => void
+): Promise<{ outputDir: string; markdownPath: string; slug: string }> {
+  const articleId = kind === "article" ? parseArticleId(normalizedUrl) : null;
+  const tweetId = kind === "tweet" ? parseTweetId(normalizedUrl) : null;
+  const username = kind === "tweet" ? parseTweetUsername(normalizedUrl) : null;
+
+  const userSlug = username ? sanitizeSlug(username) : null;
+  const idPart = articleId ?? tweetId ?? String(Date.now());
+  const slug = userSlug ?? idPart;
+
+  const defaultFileName = kind === "article" ? `${idPart}.md` : `${idPart}.md`;
+
+  if (argsOutput) {
+    const wantsDir = argsOutput.endsWith("/") || argsOutput.endsWith("\\");
+    const resolved = path.resolve(argsOutput);
+    try {
+      if (wantsDir || (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory())) {
+        const outputDir = path.join(resolved, slug);
+        await backupDirIfExists(outputDir, log);
+        await mkdir(outputDir, { recursive: true });
+        return { outputDir, markdownPath: path.join(outputDir, defaultFileName), slug };
+      }
+    } catch {
+      // treat as file path
+    }
+
+    const outputDir = path.dirname(resolved);
+    await mkdir(outputDir, { recursive: true });
+    return { outputDir, markdownPath: resolved, slug };
+  }
+
+  const outputDir = resolveDefaultOutputDir(slug);
+  await backupDirIfExists(outputDir, log);
+  await mkdir(outputDir, { recursive: true });
+  return { outputDir, markdownPath: path.join(outputDir, defaultFileName), slug };
+}
+
+function formatMetaMarkdown(meta: Record<string, string | number | null | undefined>): string {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(meta)) {
+    if (value === undefined || value === null || value === "") continue;
+    if (typeof value === "number") {
+      lines.push(`${key}: ${value}`);
+    } else {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+
+async function promptYesNo(question: string): Promise<boolean> {
+  if (!process.stdin.isTTY) return false;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  try {
+    const answer = await new Promise<string>((resolve) => rl.question(question, resolve));
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+function isValidConsent(value: unknown): value is ConsentRecord {
+  if (!value || typeof value !== "object") return false;
+  const record = value as Partial<ConsentRecord>;
+  return (
+    record.accepted === true &&
+    record.disclaimerVersion === DISCLAIMER_VERSION &&
+    typeof record.acceptedAt === "string" &&
+    record.acceptedAt.length > 0
+  );
+}
+
+async function ensureConsent(log: (message: string) => void): Promise<void> {
+  const consentPath = resolveXToMarkdownConsentPath();
+
+  try {
+    if (fs.existsSync(consentPath) && fs.statSync(consentPath).isFile()) {
+      const raw = await readFile(consentPath, "utf8");
+      const parsed = JSON.parse(raw) as unknown;
+      if (isValidConsent(parsed)) {
+        log(
+          `⚠️  Warning: Using reverse-engineered X API (not official). Accepted on: ${(parsed as ConsentRecord).acceptedAt}`
+        );
+        return;
+      }
+    }
+  } catch {
+    // fall through to prompt
+  }
+
+  log(`⚠️  DISCLAIMER
+
+This tool uses a reverse-engineered X (Twitter) API, NOT an official API.
+
+Risks:
+- May break without notice if X changes their API
+- No official support or guarantees
+- Account restrictions possible if API usage detected
+- Use at your own risk
+`);
+
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      `Consent required. Run in a TTY or create ${consentPath} with accepted: true and disclaimerVersion: ${DISCLAIMER_VERSION}`
+    );
+  }
+
+  const accepted = await promptYesNo("Do you accept these terms and wish to continue? (y/N): ");
+  if (!accepted) {
+    throw new Error("User declined the disclaimer. Exiting.");
+  }
+
+  await mkdir(path.dirname(consentPath), { recursive: true });
+  const payload: ConsentRecord = {
+    version: 1,
+    accepted: true,
+    acceptedAt: new Date().toISOString(),
+    disclaimerVersion: DISCLAIMER_VERSION,
+  };
+  await writeFile(consentPath, JSON.stringify(payload, null, 2), "utf8");
+  log(`[x-to-markdown] Consent saved to: ${consentPath}`);
+}
+
+async function convertArticleToMarkdown(
+  inputUrl: string,
+  articleId: string,
+  log: (message: string) => void
+): Promise<string> {
+  log("[x-to-markdown] Loading cookies...");
+  const cookieMap = await loadXCookies(log);
+  if (!hasRequiredXCookies(cookieMap)) {
+    throw new Error("Missing auth cookies. Provide X_AUTH_TOKEN and X_CT0 or log in via Chrome.");
+  }
+
+  log(`[x-to-markdown] Fetching article ${articleId}...`);
+  const article = await fetchXArticle(articleId, cookieMap, false);
+  const body = formatArticleMarkdown(article).trimEnd();
+
+  const title = typeof (article as any)?.title === "string" ? String((article as any).title).trim() : "";
+  const meta = formatMetaMarkdown({
+    url: `https://x.com/i/article/${articleId}`,
+    requested_url: inputUrl,
+    title: title || null,
+  });
+
+  return [meta, body].filter(Boolean).join("\n\n").trimEnd();
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) printUsage(0);
+  if (!args.login && !args.url) printUsage(1);
+
+  const log = (message: string) => console.error(message);
+  await ensureConsent(log);
+
+  if (args.login) {
+    log("[x-to-markdown] Refreshing cookies via browser login...");
+    const cookieMap = await refreshXCookies(log);
+    if (!hasRequiredXCookies(cookieMap)) {
+      throw new Error("Missing auth cookies after login. Please ensure you are logged in to X.");
+    }
+    log("[x-to-markdown] Cookies refreshed.");
+    return;
+  }
+
+  const normalizedUrl = normalizeInputUrl(args.url ?? "");
+  const articleId = parseArticleId(normalizedUrl);
+  const tweetId = parseTweetId(normalizedUrl);
+  if (!articleId && !tweetId) {
+    throw new Error("Invalid X url. Examples: https://x.com/<user>/status/<id> or https://x.com/i/article/<id>");
+  }
+
+  const kind = articleId ? ("article" as const) : ("tweet" as const);
+  const { outputDir, markdownPath, slug } = await resolveOutputPath(normalizedUrl, kind, args.output, log);
+
+  const markdown =
+    kind === "article" && articleId
+      ? await convertArticleToMarkdown(normalizedUrl, articleId, log)
+      : await tweetToMarkdown(normalizedUrl, { log });
+
+  await writeFile(markdownPath, markdown, "utf8");
+  log(`[x-to-markdown] Saved: ${markdownPath}`);
+
+  if (args.json) {
+    console.log(
+      JSON.stringify(
+        {
+          url: articleId ? `https://x.com/i/article/${articleId}` : normalizedUrl,
+          requested_url: normalizedUrl,
+          type: kind,
+          slug,
+          outputDir,
+          markdownPath,
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    console.log(markdownPath);
+  }
+}
+
+await main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error ?? ""));
+  process.exit(1);
+});
@@ -0,0 +1,306 @@
+import type {
+  ArticleBlock,
+  ArticleContentState,
+  ArticleEntity,
+  ArticleMediaInfo,
+} from "./types.js";
+
+function coerceArticleEntity(value: unknown): ArticleEntity | null {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value as ArticleEntity;
+  if (
+    typeof candidate.title === "string" ||
+    typeof candidate.plain_text === "string" ||
+    typeof candidate.preview_text === "string" ||
+    candidate.content_state
+  ) {
+    return candidate;
+  }
+  return null;
+}
+
+function escapeMarkdownAlt(text: string): string {
+  return text.replace(/[\[\]]/g, "\\$&");
+}
+
+function normalizeCaption(caption?: string): string {
+  const trimmed = caption?.trim();
+  if (!trimmed) return "";
+  return trimmed.replace(/\s+/g, " ");
+}
+
+function resolveMediaUrl(info?: ArticleMediaInfo): string | undefined {
+  if (!info) return undefined;
+  if (info.original_img_url) return info.original_img_url;
+  if (info.preview_image?.original_img_url) return info.preview_image.original_img_url;
+  const variants = info.variants ?? [];
+  const mp4 = variants
+    .filter((variant) => variant?.content_type?.includes("video"))
+    .sort((a, b) => (b.bit_rate ?? 0) - (a.bit_rate ?? 0))[0];
+  return mp4?.url ?? variants[0]?.url;
+}
+
+function buildMediaById(article: ArticleEntity): Map<string, string> {
+  const map = new Map<string, string>();
+  for (const entity of article.media_entities ?? []) {
+    if (!entity?.media_id) continue;
+    const url = resolveMediaUrl(entity.media_info);
+    if (url) {
+      map.set(entity.media_id, url);
+    }
+  }
+  return map;
+}
+
+function collectMediaUrls(
+  article: ArticleEntity,
+  usedUrls: Set<string>,
+  excludeUrl?: string
+): string[] {
+  const urls: string[] = [];
+  const addUrl = (url?: string) => {
+    if (!url) return;
+    if (excludeUrl && url === excludeUrl) {
+      usedUrls.add(url);
+      return;
+    }
+    if (usedUrls.has(url)) return;
+    usedUrls.add(url);
+    urls.push(url);
+  };
+
+  for (const entity of article.media_entities ?? []) {
+    addUrl(resolveMediaUrl(entity?.media_info));
+  }
+
+  return urls;
+}
+
+function resolveEntityMediaLines(
+  entityKey: number | undefined,
+  entityMap: ArticleContentState["entityMap"] | undefined,
+  mediaById: Map<string, string>,
+  usedUrls: Set<string>
+): string[] {
+  if (entityKey === undefined || !entityMap) return [];
+  const entry = entityMap[String(entityKey)];
+  const value = entry?.value;
+  if (!value) return [];
+  const type = value.type;
+  if (type !== "MEDIA" && type !== "IMAGE") return [];
+
+  const caption = normalizeCaption(value.data?.caption);
+  const altText = caption ? escapeMarkdownAlt(caption) : "";
+  const lines: string[] = [];
+
+  const mediaItems = value.data?.mediaItems ?? [];
+  for (const item of mediaItems) {
+    const mediaId =
+      typeof item?.mediaId === "string"
+        ? item.mediaId
+        : typeof item?.media_id === "string"
+          ? item.media_id
+          : undefined;
+    const url = mediaId ? mediaById.get(mediaId) : undefined;
+    if (url && !usedUrls.has(url)) {
+      usedUrls.add(url);
+      lines.push(`![${altText}](${url})`);
+    }
+  }
+
+  const fallbackUrl = typeof value.data?.url === "string" ? value.data.url : undefined;
+  if (fallbackUrl && !usedUrls.has(fallbackUrl)) {
+    usedUrls.add(fallbackUrl);
+    lines.push(`![${altText}](${fallbackUrl})`);
+  }
+
+  return lines;
+}
+
+function renderContentBlocks(
+  blocks: ArticleBlock[],
+  entityMap: ArticleContentState["entityMap"] | undefined,
+  mediaById: Map<string, string>,
+  usedUrls: Set<string>
+): string[] {
+  const lines: string[] = [];
+  let previousKind: "list" | "quote" | "heading" | "text" | "code" | "media" | null = null;
+  let listKind: "ordered" | "unordered" | null = null;
+  let orderedIndex = 0;
+  let inCodeBlock = false;
+
+  const pushBlock = (
+    blockLines: string[],
+    kind: "list" | "quote" | "heading" | "text" | "media"
+  ) => {
+    if (blockLines.length === 0) return;
+    if (
+      lines.length > 0 &&
+      previousKind &&
+      !(previousKind === kind && (kind === "list" || kind === "quote" || kind === "media"))
+    ) {
+      lines.push("");
+    }
+    lines.push(...blockLines);
+    previousKind = kind;
+  };
+
+  const collectMediaLines = (block: ArticleBlock): string[] => {
+    const ranges = Array.isArray(block.entityRanges) ? block.entityRanges : [];
+    const mediaLines: string[] = [];
+    for (const range of ranges) {
+      if (typeof range?.key !== "number") continue;
+      mediaLines.push(...resolveEntityMediaLines(range.key, entityMap, mediaById, usedUrls));
+    }
+    return mediaLines;
+  };
+
+  for (const block of blocks) {
+    const type = typeof block?.type === "string" ? block.type : "unstyled";
+    const text = typeof block?.text === "string" ? block.text : "";
+
+    if (type === "code-block") {
+      if (!inCodeBlock) {
+        if (lines.length > 0) {
+          lines.push("");
+        }
+        lines.push("```");
+        inCodeBlock = true;
+      }
+      lines.push(text);
+      previousKind = "code";
+      listKind = null;
+      orderedIndex = 0;
+      continue;
+    }
+
+    if (type === "atomic") {
+      if (inCodeBlock) {
+        lines.push("```");
+        inCodeBlock = false;
+        previousKind = "code";
+      }
+      listKind = null;
+      orderedIndex = 0;
+      const mediaLines = collectMediaLines(block);
+      if (mediaLines.length > 0) {
+        pushBlock(mediaLines, "media");
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      lines.push("```");
+      inCodeBlock = false;
+      previousKind = "code";
+    }
+
+    if (type === "unordered-list-item") {
+      listKind = "unordered";
+      orderedIndex = 0;
+      pushBlock([`- ${text}`], "list");
+      continue;
+    }
+
+    if (type === "ordered-list-item") {
+      if (listKind !== "ordered") {
+        orderedIndex = 0;
+      }
+      listKind = "ordered";
+      orderedIndex += 1;
+      pushBlock([`${orderedIndex}. ${text}`], "list");
+      continue;
+    }
+
+    listKind = null;
+    orderedIndex = 0;
+
+    switch (type) {
+      case "header-one":
+        pushBlock([`# ${text}`], "heading");
+        break;
+      case "header-two":
+        pushBlock([`## ${text}`], "heading");
+        break;
+      case "header-three":
+        pushBlock([`### ${text}`], "heading");
+        break;
+      case "header-four":
+        pushBlock([`#### ${text}`], "heading");
+        break;
+      case "header-five":
+        pushBlock([`##### ${text}`], "heading");
+        break;
+      case "header-six":
+        pushBlock([`###### ${text}`], "heading");
+        break;
+      case "blockquote": {
+        const quoteLines = text.length > 0 ? text.split("\n") : [""];
+        pushBlock(quoteLines.map((line) => `> ${line}`), "quote");
+        break;
+      }
+      default:
+        pushBlock([text], "text");
+        break;
+    }
+
+    const trailingMediaLines = collectMediaLines(block);
+    if (trailingMediaLines.length > 0) {
+      pushBlock(trailingMediaLines, "media");
+    }
+  }
+
+  if (inCodeBlock) {
+    lines.push("```");
+  }
+
+  return lines;
+}
+
+export function formatArticleMarkdown(article: unknown): string {
+  const candidate = coerceArticleEntity(article);
+  if (!candidate) {
+    return `\`\`\`json\n${JSON.stringify(article, null, 2)}\n\`\`\``;
+  }
+
+  const lines: string[] = [];
+  const usedUrls = new Set<string>();
+  const mediaById = buildMediaById(candidate);
+  const title = typeof candidate.title === "string" ? candidate.title.trim() : "";
+  if (title) {
+    lines.push(`# ${title}`);
+  }
+
+  const coverUrl = resolveMediaUrl(candidate.cover_media?.media_info);
+  if (coverUrl) {
+    if (lines.length > 0) lines.push("");
+    lines.push(`![](${coverUrl})`);
+    usedUrls.add(coverUrl);
+  }
+
+  const blocks = candidate.content_state?.blocks;
+  const entityMap = candidate.content_state?.entityMap;
+  if (Array.isArray(blocks) && blocks.length > 0) {
+    const rendered = renderContentBlocks(blocks, entityMap, mediaById, usedUrls);
+    if (rendered.length > 0) {
+      if (lines.length > 0) lines.push("");
+      lines.push(...rendered);
+    }
+  } else if (typeof candidate.plain_text === "string") {
+    if (lines.length > 0) lines.push("");
+    lines.push(candidate.plain_text.trim());
+  } else if (typeof candidate.preview_text === "string") {
+    if (lines.length > 0) lines.push("");
+    lines.push(candidate.preview_text.trim());
+  }
+
+  const mediaUrls = collectMediaUrls(candidate, usedUrls, coverUrl);
+  if (mediaUrls.length > 0) {
+    lines.push("", "## Media", "");
+    for (const url of mediaUrls) {
+      lines.push(`![](${url})`);
+    }
+  }
+
+  return lines.join("\n").trimEnd();
+}
@@ -0,0 +1,41 @@
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+
+const APP_DATA_DIR = "baoyu-skills";
+const X_TO_MARKDOWN_DATA_DIR = "x-to-markdown";
+const COOKIE_FILE_NAME = "cookies.json";
+const PROFILE_DIR_NAME = "chrome-profile";
+const CONSENT_FILE_NAME = "consent.json";
+
+export function resolveUserDataRoot(): string {
+  if (process.platform === "win32") {
+    return process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support");
+  }
+  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+}
+
+export function resolveXToMarkdownDataDir(): string {
+  const override = process.env.X_DATA_DIR?.trim();
+  if (override) return path.resolve(override);
+  return path.join(resolveUserDataRoot(), APP_DATA_DIR, X_TO_MARKDOWN_DATA_DIR);
+}
+
+export function resolveXToMarkdownCookiePath(): string {
+  const override = process.env.X_COOKIE_PATH?.trim();
+  if (override) return path.resolve(override);
+  return path.join(resolveXToMarkdownDataDir(), COOKIE_FILE_NAME);
+}
+
+export function resolveXToMarkdownChromeProfileDir(): string {
+  const override = process.env.X_CHROME_PROFILE_DIR?.trim();
+  if (override) return path.resolve(override);
+  return path.join(resolveXToMarkdownDataDir(), PROFILE_DIR_NAME);
+}
+
+export function resolveXToMarkdownConsentPath(): string {
+  return path.join(resolveXToMarkdownDataDir(), CONSENT_FILE_NAME);
+}
@@ -0,0 +1,295 @@
+type ThreadLike = {
+  requestedId?: string;
+  rootId?: string;
+  tweets?: unknown[];
+  totalTweets?: number;
+  user?: any;
+};
+
+type TweetPhoto = {
+  src: string;
+  alt?: string;
+};
+
+type TweetVideo = {
+  url: string;
+  poster?: string;
+  alt?: string;
+  type?: string;
+};
+
+export type ThreadTweetsMarkdownOptions = {
+  username?: string;
+  headingLevel?: number;
+  startIndex?: number;
+  includeTweetUrls?: boolean;
+};
+
+export type ThreadMarkdownOptions = ThreadTweetsMarkdownOptions & {
+  includeHeader?: boolean;
+  title?: string;
+  sourceUrl?: string;
+};
+
+function coerceThread(value: unknown): ThreadLike | null {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value as ThreadLike;
+  if (!Array.isArray(candidate.tweets)) return null;
+  return candidate;
+}
+
+function escapeMarkdownAlt(text: string): string {
+  return text.replace(/[\[\]]/g, "\\$&");
+}
+
+function normalizeAlt(text?: string | null): string {
+  const trimmed = text?.trim();
+  if (!trimmed) return "";
+  return trimmed.replace(/\s+/g, " ");
+}
+
+function parseTweetText(tweet: any): string {
+  const noteText = tweet?.note_tweet?.note_tweet_results?.result?.text;
+  const legacyText = tweet?.legacy?.full_text ?? tweet?.legacy?.text ?? "";
+  return (noteText ?? legacyText ?? "").trim();
+}
+
+function parsePhotos(tweet: any): TweetPhoto[] {
+  const media = tweet?.legacy?.extended_entities?.media ?? [];
+  return media
+    .reduce((acc: TweetPhoto[], item: any) => {
+      if (item?.type !== "photo") {
+        return acc;
+      }
+      const src = item.media_url_https ?? item.media_url;
+      if (!src) {
+        return acc;
+      }
+      const alt = normalizeAlt(item.ext_alt_text);
+      acc.push({ src, alt });
+      return acc;
+    }, [])
+    .filter((photo) => Boolean(photo.src));
+}
+
+function parseVideos(tweet: any): TweetVideo[] {
+  const media = tweet?.legacy?.extended_entities?.media ?? [];
+  return media
+    .reduce((acc: TweetVideo[], item: any) => {
+      if (!item?.type || !["animated_gif", "video"].includes(item.type)) {
+        return acc;
+      }
+      const variants = item?.video_info?.variants ?? [];
+      const sources = variants
+        .map((variant: any) => ({
+          contentType: variant?.content_type,
+          url: variant?.url,
+          bitrate: variant?.bitrate ?? 0,
+        }))
+        .filter((variant: any) => Boolean(variant.url));
+
+      const videoSources = sources.filter((variant: any) =>
+        String(variant.contentType ?? "").includes("video")
+      );
+      const sorted = (videoSources.length > 0 ? videoSources : sources).sort(
+        (a: any, b: any) => (b.bitrate ?? 0) - (a.bitrate ?? 0)
+      );
+      const best = sorted[0];
+      if (!best?.url) {
+        return acc;
+      }
+      const alt = normalizeAlt(item.ext_alt_text);
+      acc.push({
+        url: best.url,
+        poster: item.media_url_https ?? item.media_url ?? undefined,
+        alt,
+        type: item.type,
+      });
+      return acc;
+    }, [])
+    .filter((video) => Boolean(video.url));
+}
+
+function unwrapTweetResult(result: any): any {
+  if (!result) return null;
+  if (result.__typename === "TweetWithVisibilityResults" && result.tweet) {
+    return result.tweet;
+  }
+  return result;
+}
+
+function resolveTweetId(tweet: any): string | undefined {
+  return tweet?.legacy?.id_str ?? tweet?.rest_id;
+}
+
+function buildTweetUrl(username: string | undefined, tweetId: string | undefined): string | null {
+  if (!tweetId) return null;
+  if (username) {
+    return `https://x.com/${username}/status/${tweetId}`;
+  }
+  return `https://x.com/i/web/status/${tweetId}`;
+}
+
+function formatTweetMarkdown(
+  tweet: any,
+  index: number,
+  options: ThreadTweetsMarkdownOptions
+): string[] {
+  const headingLevel = options.headingLevel ?? 2;
+  const includeTweetUrls = options.includeTweetUrls ?? true;
+  const headingPrefix = "#".repeat(Math.min(Math.max(headingLevel, 1), 6));
+  const tweetId = resolveTweetId(tweet);
+  const tweetUrl = includeTweetUrls ? buildTweetUrl(options.username, tweetId) : null;
+
+  const lines: string[] = [];
+  lines.push(`${headingPrefix} ${index}`);
+  if (tweetUrl) {
+    lines.push(tweetUrl);
+  }
+  lines.push("");
+
+  const text = parseTweetText(tweet);
+  const photos = parsePhotos(tweet);
+  const videos = parseVideos(tweet);
+  const quoted = unwrapTweetResult(tweet?.quoted_status_result?.result);
+
+  const bodyLines: string[] = [];
+  if (text) {
+    bodyLines.push(...text.split(/\r?\n/));
+  }
+
+  const quotedLines = formatQuotedTweetMarkdown(quoted);
+  if (quotedLines.length > 0) {
+    if (bodyLines.length > 0) bodyLines.push("");
+    bodyLines.push(...quotedLines);
+  }
+
+  const photoLines = photos.map((photo) => {
+    const alt = photo.alt ? escapeMarkdownAlt(photo.alt) : "";
+    return `![${alt}](${photo.src})`;
+  });
+  if (photoLines.length > 0) {
+    if (bodyLines.length > 0) bodyLines.push("");
+    bodyLines.push(...photoLines);
+  }
+
+  const videoLines: string[] = [];
+  for (const video of videos) {
+    if (video.poster) {
+      const alt = video.alt ? escapeMarkdownAlt(video.alt) : "video";
+      videoLines.push(`![${alt}](${video.poster})`);
+    }
+    videoLines.push(`[${video.type ?? "video"}](${video.url})`);
+  }
+  if (videoLines.length > 0) {
+    if (bodyLines.length > 0) bodyLines.push("");
+    bodyLines.push(...videoLines);
+  }
+
+  if (bodyLines.length === 0) {
+    bodyLines.push("_No text or media._");
+  }
+
+  lines.push(...bodyLines);
+  return lines;
+}
+
+function formatQuotedTweetMarkdown(quoted: any): string[] {
+  if (!quoted) return [];
+  const quotedUser = quoted?.core?.user_results?.result?.legacy;
+  const quotedUsername = quotedUser?.screen_name;
+  const quotedName = quotedUser?.name;
+  const quotedAuthor =
+    quotedUsername && quotedName
+      ? `${quotedName} (@${quotedUsername})`
+      : quotedUsername
+        ? `@${quotedUsername}`
+        : quotedName ?? "Unknown";
+
+  const quotedId = resolveTweetId(quoted);
+  const quotedUrl =
+    buildTweetUrl(quotedUsername, quotedId) ??
+    (quotedId ? `https://x.com/i/web/status/${quotedId}` : "unavailable");
+
+  const quotedText = parseTweetText(quoted);
+  const lines: string[] = [];
+  lines.push(`Author: ${quotedAuthor}`);
+  lines.push(`URL: ${quotedUrl}`);
+  if (quotedText) {
+    lines.push("", ...quotedText.split(/\r?\n/));
+  } else {
+    lines.push("", "(no content)");
+  }
+
+  return lines.map((line) => `> ${line}`.trimEnd());
+}
+
+export function formatThreadTweetsMarkdown(
+  tweets: unknown[],
+  options: ThreadTweetsMarkdownOptions = {}
+): string {
+  const lines: string[] = [];
+  const startIndex = options.startIndex ?? 1;
+  if (!Array.isArray(tweets) || tweets.length === 0) {
+    return "";
+  }
+
+  tweets.forEach((tweet, index) => {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push(...formatTweetMarkdown(tweet, startIndex + index, options));
+  });
+
+  return lines.join("\n").trimEnd();
+}
+
+export function formatThreadMarkdown(
+  thread: unknown,
+  options: ThreadMarkdownOptions = {}
+): string {
+  const candidate = coerceThread(thread);
+  if (!candidate) {
+    return `\`\`\`json\n${JSON.stringify(thread, null, 2)}\n\`\`\``;
+  }
+
+  const tweets = candidate.tweets ?? [];
+  const firstTweet = tweets[0] as any;
+  const user = candidate.user ?? firstTweet?.core?.user_results?.result?.legacy;
+  const username = user?.screen_name;
+  const name = user?.name;
+
+  const includeHeader = options.includeHeader ?? true;
+  const lines: string[] = [];
+  if (includeHeader) {
+    if (options.title) {
+      lines.push(`# ${options.title}`);
+    } else if (username) {
+      lines.push(`# Thread by @${username}${name ? ` (${name})` : ""}`);
+    } else {
+      lines.push("# Thread");
+    }
+
+    const sourceUrl = options.sourceUrl ?? buildTweetUrl(username, candidate.rootId ?? candidate.requestedId);
+    if (sourceUrl) {
+      lines.push(`Source: ${sourceUrl}`);
+    }
+    if (typeof candidate.totalTweets === "number") {
+      lines.push(`Tweets: ${candidate.totalTweets}`);
+    }
+  }
+
+  const tweetMarkdown = formatThreadTweetsMarkdown(tweets, {
+    ...options,
+    username,
+  });
+
+  if (tweetMarkdown) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push(tweetMarkdown);
+  }
+
+  return lines.join("\n").trimEnd();
+}
@@ -0,0 +1,311 @@
+import { fetchTweetDetail } from "./graphql.js";
+
+type TweetEntry = {
+  tweet: any;
+  user?: any;
+};
+
+type ParsedEntries = {
+  entries: TweetEntry[];
+  moreCursor?: string;
+  topCursor?: string;
+  bottomCursor?: string;
+};
+
+type ThreadResult = {
+  requestedId: string;
+  rootId: string;
+  tweets: any[];
+  totalTweets: number;
+  user?: any;
+  responses?: unknown[];
+};
+
+function unwrapTweetResult(result: any): any {
+  if (!result) return null;
+  if (result.__typename === "TweetWithVisibilityResults" && result.tweet) {
+    return result.tweet;
+  }
+  return result;
+}
+
+function extractTweetEntry(itemContent: any): TweetEntry | null {
+  const result = itemContent?.tweet_results?.result;
+  if (!result) return null;
+  const resolved = unwrapTweetResult(result?.tweet ?? result);
+  if (!resolved) return null;
+  const user = resolved?.core?.user_results?.result?.legacy;
+  return { tweet: resolved, user };
+}
+
+function parseInstruction(instruction?: any): ParsedEntries {
+  const { entries: entities, moduleItems } = instruction || {};
+  const entries: TweetEntry[] = [];
+  let moreCursor: string | undefined;
+  let topCursor: string | undefined;
+  let bottomCursor: string | undefined;
+
+  const parseItems = (items: any[]) => {
+    items?.forEach((item) => {
+      const itemContent = item?.item?.itemContent ?? item?.itemContent;
+      if (!itemContent) {
+        return;
+      }
+
+      if (
+        itemContent.cursorType &&
+        ["ShowMore", "ShowMoreThreads"].includes(itemContent.cursorType) &&
+        itemContent.itemType === "TimelineTimelineCursor"
+      ) {
+        moreCursor = itemContent.value;
+        return;
+      }
+
+      const entry = extractTweetEntry(itemContent);
+      if (entry) {
+        entries.push(entry);
+      }
+    });
+  };
+
+  if (moduleItems) {
+    parseItems(moduleItems);
+  }
+
+  for (const entity of entities ?? []) {
+    if (entity?.content?.clientEventInfo?.component === "you_might_also_like") {
+      continue;
+    }
+
+    const { itemContent, items, cursorType, entryType, value } = entity?.content ?? {};
+    if (cursorType === "Bottom" && entryType === "TimelineTimelineCursor") {
+      bottomCursor = value;
+    }
+
+    if (
+      itemContent?.cursorType === "Bottom" &&
+      itemContent?.itemType === "TimelineTimelineCursor"
+    ) {
+      bottomCursor = bottomCursor ?? itemContent?.value;
+    }
+
+    if (cursorType === "Top" && entryType === "TimelineTimelineCursor") {
+      topCursor = topCursor ?? value;
+    }
+
+    if (itemContent) {
+      const entry = extractTweetEntry(itemContent);
+      if (entry) {
+        entries.push(entry);
+      }
+      if (
+        itemContent.cursorType &&
+        ["ShowMore", "ShowMoreThreads"].includes(itemContent.cursorType) &&
+        itemContent.itemType === "TimelineTimelineCursor"
+      ) {
+        moreCursor = moreCursor ?? itemContent.value;
+      }
+
+      if (itemContent.cursorType === "Top" && itemContent.itemType === "TimelineTimelineCursor") {
+        topCursor = topCursor ?? itemContent.value;
+      }
+    }
+
+    if (items) {
+      parseItems(items);
+    }
+  }
+
+  return { entries, moreCursor, topCursor, bottomCursor };
+}
+
+function parseTweetsAndToken(response: any): ParsedEntries {
+  const instruction =
+    response?.data?.threaded_conversation_with_injections_v2?.instructions?.find(
+      (ins: any) => ins?.type === "TimelineAddEntries" || ins?.type === "TimelineAddToModule"
+    ) ??
+    response?.data?.threaded_conversation_with_injections?.instructions?.find(
+      (ins: any) => ins?.type === "TimelineAddEntries" || ins?.type === "TimelineAddToModule"
+    );
+
+  return parseInstruction(instruction);
+}
+
+function toTimestamp(value: string | undefined): number {
+  if (!value) return 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+export async function fetchTweetThread(
+  tweetId: string,
+  cookieMap: Record<string, string>,
+  includeResponses = false
+): Promise<ThreadResult | null> {
+  const responses: unknown[] = [];
+  const res = await fetchTweetDetail(tweetId, cookieMap);
+  if (includeResponses) {
+    responses.push(res);
+  }
+
+  let { entries, moreCursor, topCursor, bottomCursor } = parseTweetsAndToken(res);
+  if (!entries.length) {
+    const errorMessage = res?.errors?.[0]?.message;
+    if (errorMessage) {
+      throw new Error(errorMessage);
+    }
+    return null;
+  }
+
+  let allEntries = entries.slice();
+  const root = allEntries.find((entry) => entry.tweet?.legacy?.id_str === tweetId);
+  if (!root) {
+    throw new Error("Can not fetch the root tweet");
+  }
+
+  let rootEntry = root.tweet.legacy;
+
+  const isSameThread = (entry: TweetEntry) => {
+    const tweet = entry.tweet?.legacy;
+    if (!tweet) return false;
+    return (
+      tweet.user_id_str === rootEntry.user_id_str &&
+      tweet.conversation_id_str === rootEntry.conversation_id_str &&
+      (tweet.id_str === rootEntry.id_str ||
+        tweet.in_reply_to_user_id_str === rootEntry.user_id_str ||
+        tweet.in_reply_to_status_id_str === rootEntry.conversation_id_str ||
+        !tweet.in_reply_to_user_id_str)
+    );
+  };
+
+  const inThread = (items: TweetEntry[]) => items.some(isSameThread);
+
+  let hasThread = inThread(entries);
+  let maxRequestCount = 1000;
+  let topHasThread = true;
+
+  while (topCursor && topHasThread && maxRequestCount > 0) {
+    const newRes = await fetchTweetDetail(tweetId, cookieMap, topCursor);
+    if (includeResponses) {
+      responses.push(newRes);
+    }
+
+    const parsed = parseTweetsAndToken(newRes);
+    topHasThread = inThread(parsed.entries);
+    topCursor = parsed.topCursor;
+    allEntries = parsed.entries.concat(allEntries);
+    maxRequestCount--;
+  }
+
+  async function checkMoreTweets(focalId: string) {
+    while (moreCursor && hasThread && maxRequestCount > 0) {
+      const newRes = await fetchTweetDetail(focalId, cookieMap, moreCursor);
+      if (includeResponses) {
+        responses.push(newRes);
+      }
+
+      const parsed = parseTweetsAndToken(newRes);
+      moreCursor = parsed.moreCursor;
+      bottomCursor = bottomCursor ?? parsed.bottomCursor;
+
+      hasThread = inThread(parsed.entries);
+      allEntries = allEntries.concat(parsed.entries);
+      maxRequestCount--;
+    }
+
+    if (bottomCursor) {
+      const newRes = await fetchTweetDetail(focalId, cookieMap, bottomCursor);
+      if (includeResponses) {
+        responses.push(newRes);
+      }
+
+      const parsed = parseTweetsAndToken(newRes);
+      allEntries = allEntries.concat(parsed.entries);
+      bottomCursor = undefined;
+    }
+  }
+
+  await checkMoreTweets(tweetId);
+
+  const allThreadEntries = allEntries.filter(
+    (entry) => entry.tweet?.legacy?.id_str === tweetId || isSameThread(entry)
+  );
+  const lastEntity = allThreadEntries[allThreadEntries.length - 1];
+  if (lastEntity?.tweet?.legacy?.id_str) {
+    const lastRes = await fetchTweetDetail(lastEntity.tweet.legacy.id_str, cookieMap);
+    if (includeResponses) {
+      responses.push(lastRes);
+    }
+
+    const parsed = parseTweetsAndToken(lastRes);
+    hasThread = inThread(parsed.entries);
+    allEntries = allEntries.concat(parsed.entries);
+    moreCursor = parsed.moreCursor;
+    bottomCursor = parsed.bottomCursor;
+    maxRequestCount--;
+
+    await checkMoreTweets(lastEntity.tweet.legacy.id_str);
+  }
+
+  const distinctEntries: TweetEntry[] = [];
+  const entriesMap = allEntries.reduce((acc, entry) => {
+    const id = entry.tweet?.legacy?.id_str ?? entry.tweet?.rest_id;
+    if (id && !acc.has(id)) {
+      distinctEntries.push(entry);
+      acc.set(id, entry);
+    }
+    return acc;
+  }, new Map<string, TweetEntry>());
+  allEntries = distinctEntries;
+
+  while (rootEntry.in_reply_to_status_id_str) {
+    const parent = entriesMap.get(rootEntry.in_reply_to_status_id_str)?.tweet?.legacy;
+    if (
+      parent &&
+      parent.user_id_str === rootEntry.user_id_str &&
+      parent.conversation_id_str === rootEntry.conversation_id_str &&
+      parent.id_str !== rootEntry.id_str
+    ) {
+      rootEntry = parent;
+    } else {
+      break;
+    }
+  }
+
+  allEntries = allEntries.sort((a, b) => {
+    const aTime = toTimestamp(a.tweet?.legacy?.created_at);
+    const bTime = toTimestamp(b.tweet?.legacy?.created_at);
+    return aTime - bTime;
+  });
+
+  const rootIndex = allEntries.findIndex(
+    (entry) => entry.tweet?.legacy?.id_str === rootEntry.id_str
+  );
+  if (rootIndex > 0) {
+    allEntries = allEntries.slice(rootIndex);
+  }
+
+  const threadEntries = allEntries.filter(
+    (entry) => entry.tweet?.legacy?.id_str === tweetId || isSameThread(entry)
+  );
+
+  if (!threadEntries.length) {
+    return null;
+  }
+
+  const tweets = threadEntries.map((entry) => entry.tweet);
+  const user = threadEntries[0].user ?? threadEntries[0].tweet?.core?.user_results?.result?.legacy;
+  const result: ThreadResult = {
+    requestedId: tweetId,
+    rootId: rootEntry.id_str ?? tweetId,
+    tweets,
+    totalTweets: tweets.length,
+    user,
+  };
+
+  if (includeResponses) {
+    result.responses = responses;
+  }
+
+  return result;
+}
@@ -0,0 +1,96 @@
+import { fetchXArticle } from "./graphql.js";
+import type { ArticleEntity } from "./types.js";
+
+function coerceArticleEntity(value: unknown): ArticleEntity | null {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value as ArticleEntity;
+  if (
+    typeof candidate.title === "string" ||
+    typeof candidate.plain_text === "string" ||
+    typeof candidate.preview_text === "string" ||
+    candidate.content_state
+  ) {
+    return candidate;
+  }
+  return null;
+}
+
+function hasArticleContent(article: ArticleEntity): boolean {
+  const blocks = article.content_state?.blocks;
+  if (Array.isArray(blocks) && blocks.length > 0) {
+    return true;
+  }
+  if (typeof article.plain_text === "string" && article.plain_text.trim()) {
+    return true;
+  }
+  if (typeof article.preview_text === "string" && article.preview_text.trim()) {
+    return true;
+  }
+  return false;
+}
+
+function parseArticleIdFromUrl(raw: string | undefined): string | null {
+  if (!raw) return null;
+  try {
+    const parsed = new URL(raw);
+    const match = parsed.pathname.match(/\/(?:i\/)?article\/(\d+)/);
+    if (match?.[1]) return match[1];
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function extractArticleIdFromUrls(urls: any[] | undefined): string | null {
+  if (!Array.isArray(urls)) return null;
+  for (const url of urls) {
+    const candidate =
+      url?.expanded_url ?? url?.url ?? (url?.display_url ? `https://${url.display_url}` : undefined);
+    const id = parseArticleIdFromUrl(candidate);
+    if (id) return id;
+  }
+  return null;
+}
+
+export function extractArticleEntityFromTweet(tweet: any): unknown | null {
+  return (
+    tweet?.article?.article_results?.result ??
+    tweet?.article?.result ??
+    tweet?.legacy?.article?.article_results?.result ??
+    tweet?.legacy?.article?.result ??
+    tweet?.article_results?.result ??
+    null
+  );
+}
+
+export function extractArticleIdFromTweet(tweet: any): string | null {
+  const embedded = extractArticleEntityFromTweet(tweet);
+  const embeddedArticle = embedded as { rest_id?: string } | null;
+  if (embeddedArticle?.rest_id) {
+    return embeddedArticle.rest_id;
+  }
+
+  const noteUrls = tweet?.note_tweet?.note_tweet_results?.result?.entity_set?.urls;
+  const legacyUrls = tweet?.legacy?.entities?.urls;
+  return extractArticleIdFromUrls(noteUrls) ?? extractArticleIdFromUrls(legacyUrls);
+}
+
+export async function resolveArticleEntityFromTweet(
+  tweet: any,
+  cookieMap: Record<string, string>
+): Promise<unknown | null> {
+  if (!tweet) return null;
+  const embedded = extractArticleEntityFromTweet(tweet);
+  const embeddedArticle = coerceArticleEntity(embedded);
+  if (embeddedArticle && hasArticleContent(embeddedArticle)) {
+    return embedded;
+  }
+
+  const articleId = extractArticleIdFromTweet(tweet);
+  if (!articleId) {
+    return embedded ?? null;
+  }
+
+  const fetched = await fetchXArticle(articleId, cookieMap, false);
+  return fetched ?? embedded ?? null;
+}
@@ -0,0 +1,190 @@
+#!/usr/bin/env npx tsx
+
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { hasRequiredXCookies, loadXCookies } from "./cookies.js";
+import { fetchTweetThread } from "./thread.js";
+import { formatArticleMarkdown } from "./markdown.js";
+import { formatThreadTweetsMarkdown } from "./thread-markdown.js";
+import { resolveArticleEntityFromTweet } from "./tweet-article.js";
+
+type TweetToMarkdownOptions = {
+  log?: (message: string) => void;
+};
+
+function parseArgs(): { url?: string } {
+  const args = process.argv.slice(2);
+  let url: string | undefined;
+
+  for (const arg of args) {
+    if (!arg.startsWith("-") && !url) {
+      url = arg;
+    }
+  }
+
+  return { url };
+}
+
+function normalizeInputUrl(input: string): string {
+  const trimmed = input.trim();
+  if (!trimmed) return "";
+  try {
+    return new URL(trimmed).toString();
+  } catch {
+    return trimmed;
+  }
+}
+
+function parseTweetId(input: string): string | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  if (/^\d+$/.test(trimmed)) return trimmed;
+
+  try {
+    const parsed = new URL(trimmed);
+    const match = parsed.pathname.match(/\/status(?:es)?\/(\d+)/);
+    if (match?.[1]) return match[1];
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function buildTweetUrl(username: string | undefined, tweetId: string | undefined): string | null {
+  if (!tweetId) return null;
+  if (username) {
+    return `https://x.com/${username}/status/${tweetId}`;
+  }
+  return `https://x.com/i/web/status/${tweetId}`;
+}
+
+function formatMetaMarkdown(meta: Record<string, string | number | null | undefined>): string {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(meta)) {
+    if (value === undefined || value === null || value === "") continue;
+    if (typeof value === "number") {
+      lines.push(`${key}: ${value}`);
+    } else {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+
+function extractTweetText(tweet: any): string {
+  const noteText = tweet?.note_tweet?.note_tweet_results?.result?.text;
+  const legacyText = tweet?.legacy?.full_text ?? tweet?.legacy?.text ?? "";
+  return (noteText ?? legacyText ?? "").trim();
+}
+
+function isOnlyUrl(text: string): boolean {
+  const trimmed = text.trim();
+  if (!trimmed) return true;
+  return /^https?:\/\/\S+$/.test(trimmed);
+}
+
+export async function tweetToMarkdown(
+  inputUrl: string,
+  options: TweetToMarkdownOptions = {}
+): Promise<string> {
+  const normalizedUrl = normalizeInputUrl(inputUrl);
+  const tweetId = parseTweetId(normalizedUrl);
+  if (!tweetId) {
+    throw new Error("Invalid tweet url. Example: https://x.com/<user>/status/<tweet_id>");
+  }
+
+  const log = options.log ?? (() => {});
+  log("[tweet-to-markdown] Loading cookies...");
+  const cookieMap = await loadXCookies(log);
+  if (!hasRequiredXCookies(cookieMap)) {
+    throw new Error("Missing auth cookies. Provide X_AUTH_TOKEN and X_CT0 or log in via Chrome.");
+  }
+
+  log(`[tweet-to-markdown] Fetching thread for ${tweetId}...`);
+  const thread = await fetchTweetThread(tweetId, cookieMap);
+  if (!thread) {
+    throw new Error("Failed to fetch thread.");
+  }
+
+  const tweets = thread.tweets ?? [];
+  if (tweets.length === 0) {
+    throw new Error("No tweets found in thread.");
+  }
+
+  const firstTweet = tweets[0] as any;
+  const user = thread.user ?? firstTweet?.core?.user_results?.result?.legacy;
+  const username = user?.screen_name;
+  const name = user?.name;
+  const author =
+    username && name ? `${name} (@${username})` : username ? `@${username}` : name ?? null;
+  const authorUrl = username ? `https://x.com/${username}` : undefined;
+  const requestedUrl = normalizedUrl || buildTweetUrl(username, tweetId) || inputUrl.trim();
+  const rootUrl = buildTweetUrl(username, thread.rootId ?? tweetId) ?? requestedUrl;
+
+  const meta = formatMetaMarkdown({
+    url: rootUrl,
+    requested_url: requestedUrl,
+    author,
+    author_name: name ?? null,
+    author_username: username ?? null,
+    author_url: authorUrl ?? null,
+    tweet_count: thread.totalTweets ?? tweets.length,
+  });
+
+  const parts: string[] = [meta];
+
+  const articleEntity = await resolveArticleEntityFromTweet(firstTweet, cookieMap);
+  let remainingTweets = tweets;
+  if (articleEntity) {
+    const articleMarkdown = formatArticleMarkdown(articleEntity).trimEnd();
+    if (articleMarkdown) {
+      parts.push(articleMarkdown);
+      const firstTweetText = extractTweetText(firstTweet);
+      if (isOnlyUrl(firstTweetText)) {
+        remainingTweets = tweets.slice(1);
+      }
+    }
+  }
+
+  if (remainingTweets.length > 0) {
+    const hasArticle = parts.length > 1;
+    if (hasArticle) {
+      parts.push("## Thread");
+    }
+    const tweetMarkdown = formatThreadTweetsMarkdown(remainingTweets, {
+      username,
+      headingLevel: hasArticle ? 3 : 2,
+      startIndex: 1,
+      includeTweetUrls: true,
+    });
+    if (tweetMarkdown) {
+      parts.push(tweetMarkdown);
+    }
+  }
+
+  return parts.join("\n\n").trimEnd();
+}
+
+async function main() {
+  const { url } = parseArgs();
+  if (!url) {
+    console.error("Usage:");
+    console.error("  npx -y bun skills/baoyu-danger-x-to-markdown/scripts/tweet-to-markdown.ts <tweet url>");
+    process.exit(1);
+  }
+
+  const markdown = await tweetToMarkdown(url, { log: console.log });
+  console.log(markdown);
+}
+
+const isCliExecution =
+  process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+
+if (isCliExecution) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+}
@@ -0,0 +1,79 @@
+export type CookieLike = {
+  name?: string;
+  value?: string;
+  domain?: string;
+  path?: string;
+  url?: string;
+};
+
+export type ArticleQueryInfo = {
+  queryId: string;
+  featureSwitches: string[];
+  fieldToggles: string[];
+  html: string;
+};
+
+export type ArticleEntityRange = {
+  key?: number;
+  offset?: number;
+  length?: number;
+};
+
+export type ArticleBlock = {
+  type?: string;
+  text?: string;
+  entityRanges?: ArticleEntityRange[];
+};
+
+export type ArticleEntityMapMediaItem = {
+  mediaId?: string;
+  media_id?: string;
+  localMediaId?: string;
+};
+
+export type ArticleEntityMapEntry = {
+  key?: string;
+  value?: {
+    type?: string;
+    mutability?: string;
+    data?: {
+      caption?: string;
+      mediaItems?: ArticleEntityMapMediaItem[];
+      url?: string;
+    };
+  };
+};
+
+export type ArticleContentState = {
+  blocks?: ArticleBlock[];
+  entityMap?: Record<string, ArticleEntityMapEntry>;
+};
+
+export type ArticleMediaInfo = {
+  __typename?: string;
+  original_img_url?: string;
+  preview_image?: {
+    original_img_url?: string;
+  };
+  variants?: Array<{
+    content_type?: string;
+    url?: string;
+    bit_rate?: number;
+  }>;
+};
+
+export type ArticleMediaEntity = {
+  media_id?: string;
+  media_info?: ArticleMediaInfo;
+};
+
+export type ArticleEntity = {
+  title?: string;
+  plain_text?: string;
+  preview_text?: string;
+  content_state?: ArticleContentState;
+  cover_media?: {
+    media_info?: ArticleMediaInfo;
+  };
+  media_entities?: ArticleMediaEntity[];
+};
@@ -1,180 +0,0 @@
---
-name: baoyu-gemini-web
-description: Image generation skill using Gemini Web. Generates images from text prompts via Google Gemini. Also supports text generation. Use as the image generation backend for other skills like cover-image, xhs-images, article-illustrator.
---
-
-# Gemini Web Client
-
-Supports:
- Text generation
- Image generation (download + save)
- Reference image upload (attach images for vision tasks)
- Multi-turn conversations within the same executor instance (`keepSession`)
- Experimental video generation (`generateVideo`) — Gemini may return an async placeholder; download might require Gemini web UI
-
-## Script Directory
-
-**Important**: All scripts are located in the `scripts/` subdirectory of this skill.
-
-**Agent Execution Instructions**:
-1. Determine this SKILL.md file's directory path as `SKILL_DIR`
-2. Script path = `${SKILL_DIR}/scripts/<script-name>.ts`
-3. Replace all `${SKILL_DIR}` in this document with the actual path
-
-**Script Reference**:
-| Script | Purpose |
-|--------|---------|
-| `scripts/main.ts` | CLI entry point for text/image generation |
-| `scripts/executor.ts` | Programmatic Gemini executor API |
-
-## Quick start
-
-```bash
-npx -y bun scripts/main.ts "Hello, Gemini"
-npx -y bun scripts/main.ts --prompt "Explain quantum computing"
-npx -y bun scripts/main.ts --prompt "A cute cat" --image cat.png
-npx -y bun scripts/main.ts --promptfiles system.md content.md --image out.png
-
-# Multi-turn conversation (agent generates unique sessionId)
-npx -y bun scripts/main.ts "Remember this: 42" --sessionId my-unique-id-123
-npx -y bun scripts/main.ts "What number?" --sessionId my-unique-id-123
-```
-
-## Executor options (programmatic)
-
-This skill is typically consumed via `createGeminiWebExecutor(geminiOptions)` (see `scripts/executor.ts`).
-
-Key options in `GeminiWebOptions`:
- `referenceImages?: string | string[]` Upload local images as references (vision input).
- `keepSession?: boolean` Reuse Gemini `chatMetadata` to continue the same conversation across calls (required if you want reference images to persist across multiple messages).
- `generateVideo?: string` Generate a video and (best-effort) download to the given path. Gemini may return `video_gen_chip` (async); in that case you must open Gemini web UI to download the result.
-
-Notes:
- `generateVideo` cannot be combined with `generateImage` / `editImage`.
- When `keepSession=true` and `referenceImages` is set, reference images are uploaded once per executor instance.
-
-## Commands
-
-### Text generation
-
-```bash
-# Simple prompt (positional)
-npx -y bun scripts/main.ts "Your prompt here"
-
-# Explicit prompt flag
-npx -y bun scripts/main.ts --prompt "Your prompt here"
-npx -y bun scripts/main.ts -p "Your prompt here"
-
-# With model selection
-npx -y bun scripts/main.ts -p "Hello" -m gemini-2.5-pro
-
-# Pipe from stdin
-echo "Summarize this" | npx -y bun scripts/main.ts
-```
-
-### Image generation
-
-```bash
-# Generate image with default path (./generated.png)
-npx -y bun scripts/main.ts --prompt "A sunset over mountains" --image
-
-# Generate image with custom path
-npx -y bun scripts/main.ts --prompt "A cute robot" --image robot.png
-
-# Shorthand
-npx -y bun scripts/main.ts "A dragon" --image=dragon.png
-```
-
-### Output formats
-
-```bash
-# Plain text (default)
-npx -y bun scripts/main.ts "Hello"
-
-# JSON output
-npx -y bun scripts/main.ts "Hello" --json
-```
-
-## Options
-
-| Option | Description |
-|--------|-------------|
-| `--prompt <text>`, `-p` | Prompt text |
-| `--promptfiles <files...>` | Read prompt from files (concatenated in order) |
-| `--model <id>`, `-m` | Model: gemini-3-pro (default), gemini-2.5-pro, gemini-2.5-flash |
-| `--image [path]` | Generate image, save to path (default: generated.png) |
-| `--sessionId <id>` | Session ID for multi-turn conversation (agent generates unique ID) |
-| `--list-sessions` | List saved sessions (max 100, sorted by update time) |
-| `--json` | Output as JSON |
-| `--login` | Refresh cookies only, then exit |
-| `--cookie-path <path>` | Custom cookie file path |
-| `--profile-dir <path>` | Chrome profile directory |
-| `--help`, `-h` | Show help |
-
-CLI note: `scripts/main.ts` supports text generation, image generation, and multi-turn conversations via `--sessionId`. Reference images and video generation are exposed via the executor API.
-
-## Models
-
- `gemini-3-pro` - Default, latest model
- `gemini-2.5-pro` - Previous generation pro
- `gemini-2.5-flash` - Fast, lightweight
-
-## Authentication
-
-First run opens Chrome to authenticate with Google. Cookies are cached for subsequent runs.
-
-```bash
-# Force cookie refresh
-npx -y bun scripts/main.ts --login
-```
-
-## Environment variables
-
-| Variable | Description |
-|----------|-------------|
-| `GEMINI_WEB_DATA_DIR` | Data directory |
-| `GEMINI_WEB_COOKIE_PATH` | Cookie file path |
-| `GEMINI_WEB_CHROME_PROFILE_DIR` | Chrome profile directory |
-| `GEMINI_WEB_CHROME_PATH` | Chrome executable path |
-
-## Examples
-
-### Generate text response
-```bash
-npx -y bun scripts/main.ts "What is the capital of France?"
-```
-
-### Generate image
-```bash
-npx -y bun scripts/main.ts "A photorealistic image of a golden retriever puppy" --image puppy.png
-```
-
-### Get JSON output for parsing
-```bash
-npx -y bun scripts/main.ts "Hello" --json | jq '.text'
-```
-
-### Generate image from prompt files
-```bash
-# Concatenate system.md + content.md as prompt
-npx -y bun scripts/main.ts --promptfiles system.md content.md --image output.png
-```
-
-### Multi-turn conversation
-```bash
-# Start a session with unique ID (agent generates this)
-npx -y bun scripts/main.ts "You are a helpful math tutor." --sessionId task-abc123
-
-# Continue the conversation (remembers context)
-npx -y bun scripts/main.ts "What is 2+2?" --sessionId task-abc123
-npx -y bun scripts/main.ts "Now multiply that by 10" --sessionId task-abc123
-
-# List recent sessions (max 100, sorted by update time)
-npx -y bun scripts/main.ts --list-sessions
-```
-
-Session files are stored in `~/Library/Application Support/baoyu-skills/gemini-web/sessions/<id>.json` and contain:
- `id`: Session ID
- `metadata`: Gemini chat metadata for continuation
- `messages`: Array of `{role, content, timestamp, error?}`
- `createdAt`, `updatedAt`: Timestamps
@@ -1,340 +0,0 @@
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import { mkdir } from 'node:fs/promises';
-import net from 'node:net';
-import process from 'node:process';
-
-import { fetchGeminiAccessToken } from './client.js';
-import type { GeminiWebLog } from './cookie-store.js';
-import { buildGeminiCookieMap, hasRequiredGeminiCookies } from './cookie-store.js';
-import { resolveGeminiWebChromeProfileDir } from './paths.js';
-
-const GEMINI_URL = 'https://gemini.google.com/app';
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function getFreePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.unref();
-    server.on('error', reject);
-    server.listen(0, '127.0.0.1', () => {
-      const address = server.address();
-      if (!address || typeof address === 'string') {
-        server.close(() => reject(new Error('Unable to allocate a free TCP port for Chrome debugging.')));
-        return;
-      }
-      const port = address.port;
-      server.close((err) => {
-        if (err) reject(err);
-        else resolve(port);
-      });
-    });
-  });
-}
-
-function findChromeExecutable(): string | undefined {
-  const override = process.env.GEMINI_WEB_CHROME_PATH?.trim();
-  if (override && fs.existsSync(override)) return override;
-
-  const candidates: string[] = [];
-  switch (process.platform) {
-    case 'darwin':
-      candidates.push(
-        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-        '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
-        '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta',
-        '/Applications/Chromium.app/Contents/MacOS/Chromium',
-        '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
-      );
-      break;
-    case 'win32':
-      candidates.push(
-        'C:\\\\Program Files\\\\Google\\\\Chrome\\\\Application\\\\chrome.exe',
-        'C:\\\\Program Files (x86)\\\\Google\\\\Chrome\\\\Application\\\\chrome.exe',
-        'C:\\\\Program Files\\\\Microsoft\\\\Edge\\\\Application\\\\msedge.exe',
-        'C:\\\\Program Files (x86)\\\\Microsoft\\\\Edge\\\\Application\\\\msedge.exe',
-      );
-      break;
-    default:
-      candidates.push(
-        '/usr/bin/google-chrome',
-        '/usr/bin/google-chrome-stable',
-        '/usr/bin/chromium',
-        '/usr/bin/chromium-browser',
-        '/snap/bin/chromium',
-        '/usr/bin/microsoft-edge',
-        '/usr/bin/microsoft-edge-stable',
-      );
-      break;
-  }
-
-  for (const p of candidates) {
-    if (fs.existsSync(p)) return p;
-  }
-  return undefined;
-}
-
-async function fetchJson<T = unknown>(url: string): Promise<T> {
-  const res = await fetch(url, { redirect: 'follow' });
-  if (!res.ok) {
-    throw new Error(`Request failed: ${res.status} ${res.statusText} (${url})`);
-  }
-  return (await res.json()) as T;
-}
-
-async function waitForChromeDebugPort(
-  port: number,
-  timeoutMs: number,
-): Promise<{ webSocketDebuggerUrl: string }> {
-  const start = Date.now();
-  let lastError: unknown = null;
-
-  while (Date.now() - start < timeoutMs) {
-    try {
-      const version = await fetchJson<{ webSocketDebuggerUrl?: string }>(
-        `http://127.0.0.1:${port}/json/version`,
-      );
-      if (version.webSocketDebuggerUrl) {
-        return { webSocketDebuggerUrl: version.webSocketDebuggerUrl };
-      }
-      lastError = new Error('Missing webSocketDebuggerUrl');
-    } catch (error) {
-      lastError = error;
-    }
-
-    await sleep(200);
-  }
-
-  throw new Error(
-    `Chrome debugging endpoint did not become ready within ${timeoutMs}ms: ${lastError instanceof Error ? lastError.message : String(lastError)}`,
-  );
-}
-
-class CdpConnection {
-  private ws: WebSocket;
-  private nextId = 0;
-  private pending = new Map<
-    number,
-    { resolve: (value: unknown) => void; reject: (reason: Error) => void; timer: ReturnType<typeof setTimeout> | null }
-  >();
-
-  private constructor(ws: WebSocket) {
-    this.ws = ws;
-    this.ws.addEventListener('message', (event) => {
-      try {
-        const data = (() => {
-          if (typeof event.data === 'string') return event.data;
-          if (event.data instanceof ArrayBuffer) {
-            return new TextDecoder().decode(new Uint8Array(event.data));
-          }
-          if (ArrayBuffer.isView(event.data)) {
-            return new TextDecoder().decode(event.data);
-          }
-          return String(event.data);
-        })();
-        const msg = JSON.parse(data) as { id?: number; result?: unknown; error?: { message?: string } };
-        if (!msg.id) return;
-        const pending = this.pending.get(msg.id);
-        if (!pending) return;
-        this.pending.delete(msg.id);
-        if (pending.timer) clearTimeout(pending.timer);
-        if (msg.error?.message) pending.reject(new Error(msg.error.message));
-        else pending.resolve(msg.result);
-      } catch {
-        // ignore malformed events
-      }
-    });
-
-    this.ws.addEventListener('close', () => {
-      for (const [id, pending] of this.pending.entries()) {
-        this.pending.delete(id);
-        if (pending.timer) clearTimeout(pending.timer);
-        pending.reject(new Error('Chrome DevTools connection closed.'));
-      }
-    });
-  }
-
-  static async connect(url: string, timeoutMs: number): Promise<CdpConnection> {
-    const ws = new WebSocket(url);
-    await new Promise<void>((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error('Timed out connecting to Chrome DevTools.')), timeoutMs);
-      ws.addEventListener('open', () => {
-        clearTimeout(timer);
-        resolve();
-      });
-      ws.addEventListener('error', () => {
-        clearTimeout(timer);
-        reject(new Error('Failed to connect to Chrome DevTools.'));
-      });
-    });
-    return new CdpConnection(ws);
-  }
-
-  async send<T = unknown>(
-    method: string,
-    params?: Record<string, unknown>,
-    options?: { sessionId?: string; timeoutMs?: number },
-  ): Promise<T> {
-    const id = (this.nextId += 1);
-    const message: Record<string, unknown> = { id, method };
-    if (params) message.params = params;
-    if (options?.sessionId) message.sessionId = options.sessionId;
-
-    const timeoutMs = options?.timeoutMs ?? 15_000;
-
-    const result = await new Promise<unknown>((resolve, reject) => {
-      const timer =
-        timeoutMs > 0
-          ? setTimeout(() => {
-              this.pending.delete(id);
-              reject(new Error(`CDP command timeout (${method}) after ${timeoutMs}ms.`));
-            }, timeoutMs)
-          : null;
-      this.pending.set(id, {
-        resolve,
-        reject: (reason) => reject(reason),
-        timer,
-      });
-      this.ws.send(JSON.stringify(message));
-    });
-
-    return result as T;
-  }
-
-  close(): void {
-    try {
-      this.ws.close();
-    } catch {
-      // ignore
-    }
-  }
-}
-
-export async function getGeminiCookieMapViaChrome(options?: {
-  timeoutMs?: number;
-  debugConnectTimeoutMs?: number;
-  tokenCheckTimeoutMs?: number;
-  pollIntervalMs?: number;
-  log?: GeminiWebLog;
-  userDataDir?: string;
-  chromePath?: string;
-}): Promise<Record<string, string>> {
-  const log = options?.log;
-  const timeoutMs = options?.timeoutMs ?? 5 * 60_000;
-  const debugConnectTimeoutMs = options?.debugConnectTimeoutMs ?? 30_000;
-  const tokenCheckTimeoutMs = options?.tokenCheckTimeoutMs ?? 30_000;
-  const pollIntervalMs = options?.pollIntervalMs ?? 2_000;
-  const userDataDir = options?.userDataDir ?? resolveGeminiWebChromeProfileDir();
-
-  const chromePath = options?.chromePath ?? findChromeExecutable();
-  if (!chromePath) {
-    throw new Error(
-      'Unable to locate a Chrome/Chromium executable. Install Google Chrome or set GEMINI_WEB_CHROME_PATH.',
-    );
-  }
-
-  await mkdir(userDataDir, { recursive: true });
-
-  const port = await getFreePort();
-  log?.(`[gemini-web] Launching Chrome for cookie sync (profile: ${userDataDir})`);
-
-  const chrome = spawn(
-    chromePath,
-    [
-      `--remote-debugging-port=${port}`,
-      `--user-data-dir=${userDataDir}`,
-      '--no-first-run',
-      '--no-default-browser-check',
-      '--disable-blink-features=AutomationControlled',
-      '--start-maximized',
-      GEMINI_URL,
-    ],
-    { stdio: 'ignore' },
-  );
-
-  let cdp: CdpConnection | null = null;
-  try {
-    const { webSocketDebuggerUrl } = await waitForChromeDebugPort(port, debugConnectTimeoutMs);
-    cdp = await CdpConnection.connect(webSocketDebuggerUrl, debugConnectTimeoutMs);
-
-    const { targetId } = await cdp.send<{ targetId: string }>('Target.createTarget', { url: GEMINI_URL });
-    const { sessionId } = await cdp.send<{ sessionId: string }>('Target.attachToTarget', {
-      targetId,
-      flatten: true,
-    });
-
-    await cdp.send('Page.enable', {}, { sessionId });
-    await cdp.send('Network.enable', {}, { sessionId });
-
-    log?.('[gemini-web] Please log in to Gemini in the opened browser window.');
-    log?.('[gemini-web] Waiting for cookies to become available...');
-
-    const start = Date.now();
-    let lastTokenError: string | null = null;
-    while (Date.now() - start < timeoutMs) {
-      const response = await cdp.send<{ cookies?: unknown[] }>(
-        'Network.getCookies',
-        { urls: [GEMINI_URL, 'https://google.com/'] },
-        { sessionId, timeoutMs: 10_000 },
-      );
-
-      const rawCookies = Array.isArray(response.cookies) ? response.cookies : [];
-      const cookieMap = buildGeminiCookieMap(
-        rawCookies.filter(
-          (cookie): cookie is { name?: string; value?: string; domain?: string; path?: string; url?: string } =>
-            Boolean(cookie && typeof cookie === 'object'),
-        ),
-      );
-
-      if (hasRequiredGeminiCookies(cookieMap)) {
-        try {
-          const controller = new AbortController();
-          const timer = setTimeout(() => controller.abort(), tokenCheckTimeoutMs);
-          try {
-            await fetchGeminiAccessToken(cookieMap, controller.signal);
-          } finally {
-            clearTimeout(timer);
-          }
-          log?.('[gemini-web] Gemini cookies detected.');
-          return cookieMap;
-        } catch (error) {
-          lastTokenError = error instanceof Error ? error.message : String(error);
-        }
-      }
-
-      await sleep(pollIntervalMs);
-    }
-
-    throw new Error(
-      `Timed out waiting for Gemini cookies after ${timeoutMs}ms${lastTokenError ? ` (last error: ${lastTokenError})` : ''}.`,
-    );
-  } finally {
-    if (cdp) {
-      try {
-        await cdp.send('Browser.close', {}, { timeoutMs: 5_000 });
-      } catch {
-        // ignore
-      }
-      cdp.close();
-    }
-
-    const killTimer = setTimeout(() => {
-      if (!chrome.killed) {
-        try {
-          chrome.kill('SIGKILL');
-        } catch {
-          // ignore
-        }
-      }
-    }, 2_000);
-    killTimer.unref?.();
-    try {
-      chrome.kill('SIGTERM');
-    } catch {
-      // ignore
-    }
-  }
-}
@@ -1,527 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-
-export type GeminiWebModelId = 'gemini-3-pro' | 'gemini-2.5-pro' | 'gemini-2.5-flash';
-
-export interface GeminiWebRunInput {
-  prompt: string;
-  files?: string[];
-  model: GeminiWebModelId;
-  cookieMap: Record<string, string>;
-  chatMetadata?: unknown;
-  signal?: AbortSignal;
-}
-
-export interface GeminiWebCandidateImage {
-  url: string;
-  title?: string;
-  alt?: string;
-  kind: 'web' | 'generated' | 'raw';
-}
-
-export interface GeminiWebRunOutput {
-  rawResponseText: string;
-  text: string;
-  thoughts: string | null;
-  metadata: unknown;
-  images: GeminiWebCandidateImage[];
-  errorCode?: number;
-  errorMessage?: string;
-}
-
-const USER_AGENT =
-  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
-
-const MODEL_HEADER_NAME = 'x-goog-ext-525001261-jspb';
-const MODEL_HEADERS: Record<GeminiWebModelId, string> = {
-  'gemini-3-pro': '[1,null,null,null,"9d8ca3786ebdfbea",null,null,0,[4]]',
-  'gemini-2.5-pro': '[1,null,null,null,"4af6c7f5da75d65d",null,null,0,[4]]',
-  'gemini-2.5-flash': '[1,null,null,null,"9ec249fc9ad08861",null,null,0,[4]]',
-};
-
-const GEMINI_APP_URL = 'https://gemini.google.com/app';
-const GEMINI_STREAM_GENERATE_URL =
-  'https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate';
-const GEMINI_UPLOAD_URL = 'https://content-push.googleapis.com/upload';
-const GEMINI_UPLOAD_PUSH_ID = 'feeds/mcudyrk2a4khkz';
-
-function getNestedValue<T>(value: unknown, pathParts: Array<string | number>, fallback: T): T {
-  let current: unknown = value;
-  for (const part of pathParts) {
-    if (current == null) return fallback;
-    if (typeof part === 'number') {
-      if (!Array.isArray(current)) return fallback;
-      current = current[part];
-    } else {
-      if (typeof current !== 'object') return fallback;
-      current = (current as Record<string, unknown>)[part];
-    }
-  }
-  return (current as T) ?? fallback;
-}
-
-function buildCookieHeader(cookieMap: Record<string, string>): string {
-  return Object.entries(cookieMap)
-    .filter(([, value]) => typeof value === 'string' && value.length > 0)
-    .map(([name, value]) => `${name}=${value}`)
-    .join('; ');
-}
-
-function getSetCookieHeaders(res: Response): string[] {
-  const headers = res.headers as unknown as { getSetCookie?: () => string[] };
-  if (typeof headers.getSetCookie === 'function') {
-    try {
-      return headers.getSetCookie();
-    } catch {
-      return [];
-    }
-  }
-  const raw = res.headers.get('set-cookie');
-  return raw ? [raw] : [];
-}
-
-function applySetCookiesToMap(setCookies: string[], cookieMap: Record<string, string>): void {
-  for (const raw of setCookies) {
-    const first = raw.split(';')[0]?.trim();
-    if (!first) continue;
-    const idx = first.indexOf('=');
-    if (idx <= 0) continue;
-    const name = first.slice(0, idx).trim();
-    const value = first.slice(idx + 1).trim();
-    if (!name) continue;
-    cookieMap[name] = value;
-  }
-}
-
-async function fetchWithCookieJar(
-  url: string,
-  init: Omit<RequestInit, 'redirect' | 'headers'> & { headers?: Record<string, string> },
-  cookieMap: Record<string, string>,
-  signal?: AbortSignal,
-  maxRedirects = 20,
-): Promise<Response> {
-  let current = url;
-  for (let i = 0; i <= maxRedirects; i += 1) {
-    const cookieHeader = buildCookieHeader(cookieMap);
-    const headers: Record<string, string> = {
-      ...(init.headers ?? {}),
-      ...(cookieHeader ? { cookie: cookieHeader } : {}),
-      'user-agent': USER_AGENT,
-    };
-
-    const res = await fetch(current, { ...init, redirect: 'manual', signal, headers });
-    applySetCookiesToMap(getSetCookieHeaders(res), cookieMap);
-
-    if (res.status >= 300 && res.status < 400) {
-      const location = res.headers.get('location');
-      if (!location) return res;
-      current = new URL(location, current).toString();
-      continue;
-    }
-
-    return res;
-  }
-
-  throw new Error(`Too many redirects while fetching ${url} (>${maxRedirects}).`);
-}
-
-export async function fetchGeminiAccessToken(
-  cookieMap: Record<string, string>,
-  signal?: AbortSignal,
-): Promise<string> {
-  const res = await fetchWithCookieJar(GEMINI_APP_URL, { method: 'GET' }, cookieMap, signal);
-  const html = await res.text();
-
-  const tokens = ['SNlM0e', 'thykhd'] as const;
-  for (const key of tokens) {
-    const match = html.match(new RegExp(`"${key}":"(.*?)"`));
-    if (match?.[1]) return match[1];
-  }
-  throw new Error(
-    'Unable to locate Gemini access token on gemini.google.com/app (missing SNlM0e/thykhd).',
-  );
-}
-
-function trimGeminiJsonEnvelope(text: string): string {
-  const start = text.indexOf('[');
-  const end = text.lastIndexOf(']');
-  if (start === -1 || end === -1 || end <= start) {
-    throw new Error('Gemini response did not contain a JSON payload.');
-  }
-  return text.slice(start, end + 1);
-}
-
-function extractErrorCode(responseJson: unknown): number | undefined {
-  const code = getNestedValue<number>(responseJson, [0, 5, 2, 0, 1, 0], -1);
-  return typeof code === 'number' && code >= 0 ? code : undefined;
-}
-
-function extractGgdlUrls(rawText: string): string[] {
-  const matches =
-    rawText.match(/https?:\/\/[^/\s"']*googleusercontent\.com\/gg-dl\/[^\s"']+/g) ?? [];
-  const seen = new Set<string>();
-  const urls: string[] = [];
-  for (const match of matches) {
-    if (seen.has(match)) continue;
-    seen.add(match);
-    urls.push(match);
-  }
-  return urls;
-}
-
-function extractImageGenerationContentUrls(rawText: string): string[] {
-  const matches =
-    rawText.match(/https?:\/\/googleusercontent\.com\/image_generation_content\/\d+/g) ?? [];
-  const seen = new Set<string>();
-  const urls: string[] = [];
-  for (const match of matches) {
-    if (seen.has(match)) continue;
-    seen.add(match);
-    urls.push(match);
-  }
-  return urls;
-}
-
-function ensureFullSizeImageUrl(url: string): string {
-  const trimmed = url.trim();
-  let normalized = trimmed;
-  const backslashIndex = normalized.indexOf('\\');
-  if (backslashIndex >= 0) normalized = normalized.slice(0, backslashIndex);
-  // Some Gemini responses embed a size suffix as "/=s2048" which breaks downloads.
-  normalized = normalized.replace(/\/=s(?=\d+(?:$|[?#]))/, '=s');
-  normalized = normalized.replace(/\/=s(?=$|[?#])/, '=s');
-  if (normalized.endsWith('/')) normalized = normalized.slice(0, -1);
-  if (normalized.includes('=s2048')) return normalized;
-  if (normalized.includes('=s')) return normalized;
-  return `${normalized}=s2048`;
-}
-
-async function fetchWithCookiePreservingRedirects(
-  url: string,
-  init: Omit<RequestInit, 'redirect'>,
-  signal?: AbortSignal,
-  maxRedirects = 10,
-): Promise<Response> {
-  let current = url;
-  for (let i = 0; i <= maxRedirects; i += 1) {
-    const res = await fetch(current, { ...init, redirect: 'manual', signal });
-    if (res.status >= 300 && res.status < 400) {
-      const location = res.headers.get('location');
-      if (!location) return res;
-      current = new URL(location, current).toString();
-      continue;
-    }
-    return res;
-  }
-  throw new Error(`Too many redirects while downloading image (>${maxRedirects}).`);
-}
-
-export async function downloadGeminiImage(
-  url: string,
-  cookieMap: Record<string, string>,
-  outputPath: string,
-  signal?: AbortSignal,
-): Promise<void> {
-  const cookieHeader = buildCookieHeader(cookieMap);
-  const res = await fetchWithCookiePreservingRedirects(ensureFullSizeImageUrl(url), {
-    headers: {
-      cookie: cookieHeader,
-      'user-agent': USER_AGENT,
-    },
-  }, signal);
-  if (!res.ok) {
-    throw new Error(`Failed to download image: ${res.status} ${res.statusText} (${res.url})`);
-  }
-
-  const data = new Uint8Array(await res.arrayBuffer());
-  await mkdir(path.dirname(outputPath), { recursive: true });
-  await writeFile(outputPath, data);
-}
-
-async function uploadGeminiFile(filePath: string, signal?: AbortSignal): Promise<{ id: string; name: string }> {
-  const absPath = path.resolve(process.cwd(), filePath);
-  const data = await readFile(absPath);
-  const fileName = path.basename(absPath);
-  const form = new FormData();
-  form.append('file', new Blob([data]), fileName);
-
-  const res = await fetch(GEMINI_UPLOAD_URL, {
-    method: 'POST',
-    redirect: 'follow',
-    signal,
-    headers: {
-      'push-id': GEMINI_UPLOAD_PUSH_ID,
-      'user-agent': USER_AGENT,
-    },
-    body: form,
-  });
-  const text = await res.text();
-  if (!res.ok) {
-    throw new Error(`File upload failed: ${res.status} ${res.statusText} (${text.slice(0, 200)})`);
-  }
-  return { id: text, name: fileName };
-}
-
-function guessMimeType(fileName: string): string {
-  const ext = path.extname(fileName).toLowerCase();
-  switch (ext) {
-    case '.png':
-      return 'image/png';
-    case '.jpg':
-    case '.jpeg':
-      return 'image/jpeg';
-    case '.webp':
-      return 'image/webp';
-    case '.gif':
-      return 'image/gif';
-    case '.mp4':
-      return 'video/mp4';
-    case '.mov':
-      return 'video/quicktime';
-    case '.webm':
-      return 'video/webm';
-    default:
-      return 'application/octet-stream';
-  }
-}
-
-function buildGeminiFReqPayload(
-  prompt: string,
-  uploaded: Array<{ id: string; name: string }>,
-  chatMetadata: unknown,
-): string {
-  const promptPayload =
-    uploaded.length > 0
-      ? [
-          prompt,
-          0,
-          null,
-          // Matches gemini-web payload format: [[[fileId, 1, null, mimeType], fileName]] for an attachment.
-          uploaded.map((file) => [[file.id, 1, null, guessMimeType(file.name)], file.name]),
-        ]
-      : [prompt];
-
-  const innerList: unknown[] = [promptPayload, null, chatMetadata ?? null];
-  return JSON.stringify([null, JSON.stringify(innerList)]);
-}
-
-export function parseGeminiStreamGenerateResponse(rawText: string): {
-  metadata: unknown;
-  text: string;
-  thoughts: string | null;
-  images: GeminiWebCandidateImage[];
-  errorCode?: number;
-} {
-  const responseJson = JSON.parse(trimGeminiJsonEnvelope(rawText)) as unknown;
-  const errorCode = extractErrorCode(responseJson);
-
-  const parts = Array.isArray(responseJson) ? responseJson : [];
-  let bodyIndex = 0;
-  let body: unknown = null;
-  for (let i = 0; i < parts.length; i += 1) {
-    const partBody = getNestedValue<string | null>(parts[i], [2], null);
-    if (!partBody) continue;
-    try {
-      const parsed = JSON.parse(partBody) as unknown;
-      const candidateList = getNestedValue<unknown[]>(parsed, [4], []);
-      if (Array.isArray(candidateList) && candidateList.length > 0) {
-        bodyIndex = i;
-        body = parsed;
-        break;
-      }
-    } catch {
-      // ignore
-    }
-  }
-
-  const candidateList = getNestedValue<unknown[]>(body, [4], []);
-  const firstCandidate = candidateList[0];
-  const textRaw = getNestedValue<string>(firstCandidate, [1, 0], '');
-  const cardContent = /^http:\/\/googleusercontent\.com\/card_content\/\d+/.test(textRaw);
-  const text = cardContent
-    ? (getNestedValue<string | null>(firstCandidate, [22, 0], null) ?? textRaw)
-    : textRaw;
-  const thoughts = getNestedValue<string | null>(firstCandidate, [37, 0, 0], null);
-  const conversationMeta = getNestedValue<unknown[]>(body, [1], []);
-  const conversationId =
-    typeof conversationMeta[0] === 'string' && conversationMeta[0].length > 0
-      ? conversationMeta[0]
-      : null;
-  const responseId =
-    typeof conversationMeta[1] === 'string' && conversationMeta[1].length > 0
-      ? conversationMeta[1]
-      : null;
-  const choiceIdRaw = getNestedValue<string | null>(firstCandidate, [0], null);
-  const choiceId = typeof choiceIdRaw === 'string' && choiceIdRaw.length > 0 ? choiceIdRaw : null;
-  const metadata =
-    conversationId && responseId && choiceId ? [conversationId, responseId, choiceId] : conversationMeta;
-
-  const images: GeminiWebCandidateImage[] = [];
-
-  const webImages = getNestedValue<unknown[]>(firstCandidate, [12, 1], []);
-  for (const webImage of webImages) {
-    const url = getNestedValue<string | null>(webImage, [0, 0, 0], null);
-    if (!url) continue;
-    images.push({
-      kind: 'web',
-      url,
-      title: getNestedValue<string | undefined>(webImage, [7, 0], undefined),
-      alt: getNestedValue<string | undefined>(webImage, [0, 4], undefined),
-    });
-  }
-
-  const hasGenerated = Boolean(getNestedValue<unknown>(firstCandidate, [12, 7, 0], null));
-  if (hasGenerated) {
-    let imgBody: unknown = null;
-    for (let i = bodyIndex; i < parts.length; i += 1) {
-      const partBody = getNestedValue<string | null>(parts[i], [2], null);
-      if (!partBody) continue;
-      try {
-        const parsed = JSON.parse(partBody) as unknown;
-        const candidateImages = getNestedValue<unknown | null>(parsed, [4, 0, 12, 7, 0], null);
-        if (candidateImages != null) {
-          imgBody = parsed;
-          break;
-        }
-      } catch {
-        // ignore
-      }
-    }
-
-    const imgCandidate = getNestedValue<unknown>(imgBody ?? body, [4, 0], null);
-
-    const generated = getNestedValue<unknown[]>(imgCandidate, [12, 7, 0], []);
-    for (const genImage of generated) {
-      const url = getNestedValue<string | null>(genImage, [0, 3, 3], null);
-      if (!url) continue;
-      images.push({
-        kind: 'generated',
-        url,
-        title: '[Generated Image]',
-        alt: '',
-      });
-    }
-  }
-
-  return { metadata, text, thoughts, images, errorCode };
-}
-
-export function isGeminiModelUnavailable(errorCode: number | undefined): boolean {
-  return errorCode === 1052;
-}
-
-export async function runGeminiWebOnce(input: GeminiWebRunInput): Promise<GeminiWebRunOutput> {
-  const at = await fetchGeminiAccessToken(input.cookieMap, input.signal);
-  const cookieHeader = buildCookieHeader(input.cookieMap);
-
-  const uploaded: Array<{ id: string; name: string }> = [];
-  for (const file of input.files ?? []) {
-    if (input.signal?.aborted) {
-      throw new Error('Gemini web run aborted before upload.');
-    }
-    uploaded.push(await uploadGeminiFile(file, input.signal));
-  }
-
-  const fReq = buildGeminiFReqPayload(input.prompt, uploaded, input.chatMetadata ?? null);
-  const params = new URLSearchParams();
-  params.set('at', at);
-  params.set('f.req', fReq);
-
-  const res = await fetch(GEMINI_STREAM_GENERATE_URL, {
-    method: 'POST',
-    redirect: 'follow',
-    signal: input.signal,
-    headers: {
-      'content-type': 'application/x-www-form-urlencoded;charset=utf-8',
-      origin: 'https://gemini.google.com',
-      referer: 'https://gemini.google.com/',
-      'x-same-domain': '1',
-      'user-agent': USER_AGENT,
-      cookie: cookieHeader,
-      [MODEL_HEADER_NAME]: MODEL_HEADERS[input.model],
-    },
-    body: params.toString(),
-  });
-
-  const rawResponseText = await res.text();
-  if (!res.ok) {
-    return {
-      rawResponseText,
-      text: '',
-      thoughts: null,
-      metadata: input.chatMetadata ?? null,
-      images: [],
-      errorMessage: `Gemini request failed: ${res.status} ${res.statusText}`,
-    };
-  }
-
-  try {
-    const parsed = parseGeminiStreamGenerateResponse(rawResponseText);
-    return {
-      rawResponseText,
-      text: parsed.text ?? '',
-      thoughts: parsed.thoughts,
-      metadata: parsed.metadata,
-      images: parsed.images,
-      errorCode: parsed.errorCode,
-    };
-  } catch (error) {
-    let responseJson: unknown = null;
-    try {
-      responseJson = JSON.parse(trimGeminiJsonEnvelope(rawResponseText)) as unknown;
-    } catch {
-      responseJson = null;
-    }
-    const errorCode = extractErrorCode(responseJson);
-
-    return {
-      rawResponseText,
-      text: '',
-      thoughts: null,
-      metadata: input.chatMetadata ?? null,
-      images: [],
-      errorCode: typeof errorCode === 'number' ? errorCode : undefined,
-      errorMessage: error instanceof Error ? error.message : String(error ?? ''),
-    };
-  }
-}
-
-export async function runGeminiWebWithFallback(
-  input: Omit<GeminiWebRunInput, 'model'> & { model: GeminiWebModelId },
-): Promise<GeminiWebRunOutput & { effectiveModel: GeminiWebModelId }> {
-  const attempt = await runGeminiWebOnce(input);
-  if (isGeminiModelUnavailable(attempt.errorCode) && input.model !== 'gemini-2.5-flash') {
-    const fallback = await runGeminiWebOnce({ ...input, model: 'gemini-2.5-flash' });
-    return { ...fallback, effectiveModel: 'gemini-2.5-flash' };
-  }
-  return { ...attempt, effectiveModel: input.model };
-}
-
-export async function saveFirstGeminiImageFromOutput(
-  output: GeminiWebRunOutput,
-  cookieMap: Record<string, string>,
-  outputPath: string,
-  signal?: AbortSignal,
-): Promise<{ saved: boolean; imageCount: number }> {
-  const generatedOrWeb = output.images.find((img) => img.kind === 'generated') ?? output.images[0];
-  if (generatedOrWeb?.url) {
-    await downloadGeminiImage(generatedOrWeb.url, cookieMap, outputPath, signal);
-    return { saved: true, imageCount: output.images.length };
-  }
-
-  const ggdl = extractGgdlUrls(`${output.text}\n${output.rawResponseText}`);
-  const preferred = ggdl.length > 0 ? ggdl[ggdl.length - 1] : null;
-  if (preferred) {
-    await downloadGeminiImage(preferred, cookieMap, outputPath, signal);
-    return { saved: true, imageCount: ggdl.length };
-  }
-
-  const imageGen = extractImageGenerationContentUrls(`${output.text}\n${output.rawResponseText}`);
-  const imageGenPreferred = imageGen.length > 0 ? imageGen[imageGen.length - 1] : null;
-  if (imageGenPreferred) {
-    await downloadGeminiImage(imageGenPreferred, cookieMap, outputPath, signal);
-    return { saved: true, imageCount: imageGen.length };
-  }
-
-  return { saved: false, imageCount: 0 };
-}
@@ -1,140 +0,0 @@
-import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { resolveGeminiWebCookiePath } from './paths.js';
-
-export type GeminiWebLog = (message: string) => void;
-
-export const GEMINI_COOKIE_NAMES = [
-  '__Secure-1PSID',
-  '__Secure-1PSIDTS',
-  '__Secure-1PSIDCC',
-  '__Secure-1PAPISID',
-  'NID',
-  'AEC',
-  'SOCS',
-  '__Secure-BUCKET',
-  '__Secure-ENID',
-  'SID',
-  'HSID',
-  'SSID',
-  'APISID',
-  'SAPISID',
-  '__Secure-3PSID',
-  '__Secure-3PSIDTS',
-  '__Secure-3PAPISID',
-  'SIDCC',
-] as const;
-
-export const GEMINI_REQUIRED_COOKIES = ['__Secure-1PSID', '__Secure-1PSIDTS'] as const;
-
-export interface GeminiCookieFileV1 {
-  version: 1;
-  updatedAt: string;
-  cookieMap: Record<string, string>;
-}
-
-export function hasRequiredGeminiCookies(cookieMap: Record<string, string>): boolean {
-  return GEMINI_REQUIRED_COOKIES.every((name) => Boolean(cookieMap[name]));
-}
-
-function resolveCookieDomain(cookie: { domain?: string; url?: string }): string | null {
-  const rawDomain = cookie.domain?.trim();
-  if (rawDomain) {
-    return rawDomain.startsWith('.') ? rawDomain.slice(1) : rawDomain;
-  }
-  const rawUrl = cookie.url?.trim();
-  if (rawUrl) {
-    try {
-      return new URL(rawUrl).hostname;
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-
-function pickCookieValue<T extends { name?: string; value?: string; domain?: string; path?: string; url?: string }>(
-  cookies: T[],
-  name: string,
-): string | undefined {
-  const matches = cookies.filter((cookie) => cookie.name === name && typeof cookie.value === 'string');
-  if (matches.length === 0) return undefined;
-
-  const preferredDomain = matches.find((cookie) => {
-    const domain = resolveCookieDomain(cookie);
-    return domain === 'google.com' && (cookie.path ?? '/') === '/';
-  });
-  const googleDomain = matches.find((cookie) => (resolveCookieDomain(cookie) ?? '').endsWith('google.com'));
-  return (preferredDomain ?? googleDomain ?? matches[0])?.value;
-}
-
-export function buildGeminiCookieMap<
-  T extends { name?: string; value?: string; domain?: string; path?: string; url?: string },
->(cookies: T[]): Record<string, string> {
-  const cookieMap: Record<string, string> = {};
-  for (const name of GEMINI_COOKIE_NAMES) {
-    const value = pickCookieValue(cookies, name);
-    if (value) cookieMap[name] = value;
-  }
-  return cookieMap;
-}
-
-export async function readGeminiCookieMapFromDisk(options?: {
-  cookiePath?: string;
-  log?: GeminiWebLog;
-}): Promise<Record<string, string>> {
-  const cookiePath = options?.cookiePath ?? resolveGeminiWebCookiePath();
-
-  try {
-    const raw = await readFile(cookiePath, 'utf8');
-    const parsed = JSON.parse(raw) as Partial<GeminiCookieFileV1> | Record<string, unknown>;
-
-    const cookieMap =
-      (parsed as Partial<GeminiCookieFileV1>).version === 1
-        ? (parsed as Partial<GeminiCookieFileV1>).cookieMap
-        : (parsed as Record<string, unknown>);
-
-    if (!cookieMap || typeof cookieMap !== 'object') return {};
-    const normalized: Record<string, string> = {};
-    for (const [key, value] of Object.entries(cookieMap)) {
-      if (typeof value === 'string' && value.trim()) {
-        normalized[key] = value;
-      }
-    }
-
-    if (Object.keys(normalized).length > 0) {
-      options?.log?.(`[gemini-web] Loaded cookies from ${cookiePath}`);
-    }
-
-    return normalized;
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException | undefined)?.code;
-    if (code === 'ENOENT') return {};
-    options?.log?.(
-      `[gemini-web] Failed to read cookies from ${cookiePath}: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    return {};
-  }
-}
-
-export async function writeGeminiCookieMapToDisk(
-  cookieMap: Record<string, string>,
-  options?: { cookiePath?: string; log?: GeminiWebLog },
-): Promise<void> {
-  const cookiePath = options?.cookiePath ?? resolveGeminiWebCookiePath();
-  await mkdir(path.dirname(cookiePath), { recursive: true });
-
-  const payload: GeminiCookieFileV1 = {
-    version: 1,
-    updatedAt: new Date().toISOString(),
-    cookieMap,
-  };
-
-  await writeFile(cookiePath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
-  try {
-    await chmod(cookiePath, 0o600);
-  } catch {
-    // ignore chmod failures (e.g. on Windows)
-  }
-  options?.log?.(`[gemini-web] Saved cookies to ${cookiePath}`);
-}
@@ -1,445 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import type { BrowserRunOptions, BrowserRunResult, BrowserLogger, CookieParam } from '../browser/types.js';
-import { runGeminiWebWithFallback, saveFirstGeminiImageFromOutput } from './client.js';
-import type { GeminiWebModelId, GeminiWebRunOutput } from './client.js';
-import {
-  buildGeminiCookieMap,
-  hasRequiredGeminiCookies,
-  readGeminiCookieMapFromDisk,
-} from './cookie-store.js';
-import type { GeminiWebOptions, GeminiWebResponse } from './types.js';
-
-export { hasRequiredGeminiCookies } from './cookie-store.js';
-
-const USER_AGENT =
-  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
-
-function estimateTokenCount(text: string): number {
-  return Math.ceil(text.length / 4);
-}
-
-function resolveInvocationPath(value: string | undefined): string | undefined {
-  if (!value) return undefined;
-  const trimmed = value.trim();
-  if (!trimmed) return undefined;
-  return path.isAbsolute(trimmed) ? trimmed : path.resolve(process.cwd(), trimmed);
-}
-
-function normalizePathList(value: string | string[] | undefined): string[] {
-  if (!value) return [];
-  const raw = Array.isArray(value) ? value : [value];
-  const out: string[] = [];
-  for (const entry of raw) {
-    if (typeof entry !== 'string') continue;
-    const resolved = resolveInvocationPath(entry);
-    if (!resolved) continue;
-    out.push(resolved);
-  }
-  return out;
-}
-
-function dedupePaths(paths: string[]): string[] {
-  const seen = new Set<string>();
-  const out: string[] = [];
-  for (const item of paths) {
-    const trimmed = item.trim();
-    if (!trimmed || seen.has(trimmed)) continue;
-    seen.add(trimmed);
-    out.push(trimmed);
-  }
-  return out;
-}
-
-function buildCookieHeader(cookieMap: Record<string, string>): string {
-  return Object.entries(cookieMap)
-    .filter(([, value]) => typeof value === 'string' && value.length > 0)
-    .map(([name, value]) => `${name}=${value}`)
-    .join('; ');
-}
-
-async function fetchWithCookiePreservingRedirects(
-  url: string,
-  init: Omit<RequestInit, 'redirect'>,
-  signal?: AbortSignal,
-  maxRedirects = 10,
-): Promise<Response> {
-  let current = url;
-  for (let i = 0; i <= maxRedirects; i += 1) {
-    const res = await fetch(current, { ...init, redirect: 'manual', signal });
-    if (res.status >= 300 && res.status < 400) {
-      const location = res.headers.get('location');
-      if (!location) return res;
-      current = new URL(location, current).toString();
-      continue;
-    }
-    return res;
-  }
-  throw new Error(`Too many redirects while downloading media (>${maxRedirects}).`);
-}
-
-async function downloadGeminiMedia(
-  url: string,
-  cookieMap: Record<string, string>,
-  outputPath: string,
-  signal?: AbortSignal,
-): Promise<void> {
-  const cookieHeader = buildCookieHeader(cookieMap);
-  const res = await fetchWithCookiePreservingRedirects(
-    url,
-    {
-      headers: {
-        cookie: cookieHeader,
-        'user-agent': USER_AGENT,
-      },
-    },
-    signal,
-  );
-  if (!res.ok) {
-    throw new Error(`Failed to download media: ${res.status} ${res.statusText} (${res.url})`);
-  }
-
-  const data = new Uint8Array(await res.arrayBuffer());
-  await mkdir(path.dirname(outputPath), { recursive: true });
-  await writeFile(outputPath, data);
-}
-
-function extractGgdlUrls(rawText: string): string[] {
-  const matches =
-    rawText.match(/https?:\/\/[^/\s"']*googleusercontent\.com\/gg-dl\/[^\s"']+/g) ?? [];
-  const seen = new Set<string>();
-  const urls: string[] = [];
-  for (const match of matches) {
-    if (seen.has(match)) continue;
-    seen.add(match);
-    urls.push(match);
-  }
-  return urls;
-}
-
-async function saveFirstGeminiVideoFromOutput(
-  output: GeminiWebRunOutput,
-  cookieMap: Record<string, string>,
-  outputPath: string,
-  signal?: AbortSignal,
-): Promise<{ saved: boolean; videoCount: number }> {
-  const ggdl = extractGgdlUrls(output.rawResponseText);
-  if (!ggdl[0]) return { saved: false, videoCount: 0 };
-
-  const videoCandidates = ggdl.filter((url) => /\.(mp4|webm|mov)(?:$|[?#])/i.test(url));
-  const preferred =
-    (videoCandidates.length > 0 ? videoCandidates[videoCandidates.length - 1] : null) ??
-    ggdl.find((url) => /video/i.test(url)) ??
-    ggdl[ggdl.length - 1];
-  await downloadGeminiMedia(preferred, cookieMap, outputPath, signal);
-  return { saved: true, videoCount: ggdl.length };
-}
-
-function resolveGeminiWebModel(
-  desiredModel: string | null | undefined,
-  log?: BrowserLogger,
-): GeminiWebModelId {
-  const desired = typeof desiredModel === 'string' ? desiredModel.trim() : '';
-  if (!desired) return 'gemini-3-pro';
-
-  switch (desired) {
-    case 'gemini-3-pro':
-    case 'gemini-3.0-pro':
-      return 'gemini-3-pro';
-    case 'gemini-2.5-pro':
-      return 'gemini-2.5-pro';
-    case 'gemini-2.5-flash':
-      return 'gemini-2.5-flash';
-    default:
-      if (desired.startsWith('gemini-')) {
-        log?.(
-          `[gemini-web] Unsupported Gemini web model "${desired}". Falling back to gemini-3-pro.`,
-        );
-      }
-      return 'gemini-3-pro';
-  }
-}
-
-function buildInlineCookiesFromEnv(): CookieParam[] {
-  const cookies: CookieParam[] = [];
-  const psid = process.env.GEMINI_SECURE_1PSID?.trim();
-  const psidts = process.env.GEMINI_SECURE_1PSIDTS?.trim();
-
-  if (psid) {
-    cookies.push({ name: '__Secure-1PSID', value: psid, domain: 'google.com', path: '/' });
-  }
-  if (psidts) {
-    cookies.push({ name: '__Secure-1PSIDTS', value: psidts, domain: 'google.com', path: '/' });
-  }
-
-  return cookies;
-}
-
-async function loadGeminiCookiesFromInline(
-  browserConfig: BrowserRunOptions['config'],
-  log?: BrowserLogger,
-): Promise<Record<string, string>> {
-  const inline = browserConfig?.inlineCookies;
-  if (!inline || inline.length === 0) return {};
-
-  const cookieMap = buildGeminiCookieMap(
-    inline.filter((cookie): cookie is CookieParam => Boolean(cookie?.name && typeof cookie.value === 'string')),
-  );
-
-  if (Object.keys(cookieMap).length > 0) {
-    const source = browserConfig?.inlineCookiesSource ?? 'inline';
-    log?.(`[gemini-web] Loaded Gemini cookies from inline payload (${source}): ${Object.keys(cookieMap).length} cookie(s).`);
-  } else {
-    log?.('[gemini-web] Inline cookie payload provided but no Gemini cookies matched.');
-  }
-
-  return cookieMap;
-}
-
-export async function loadGeminiCookies(
-  browserConfig: BrowserRunOptions['config'],
-  log?: BrowserLogger,
-): Promise<Record<string, string>> {
-  const inlineMap = await loadGeminiCookiesFromInline(browserConfig, log);
-  if (hasRequiredGeminiCookies(inlineMap)) return inlineMap;
-
-  const diskMap = await readGeminiCookieMapFromDisk({ log });
-  const merged = { ...diskMap, ...inlineMap };
-  if (hasRequiredGeminiCookies(merged)) return merged;
-
-  if (browserConfig?.cookieSync === false) {
-    log?.('[gemini-web] Cookie sync disabled and inline cookies missing Gemini auth tokens.');
-    return merged;
-  }
-
-  log?.(
-    '[gemini-web] Missing Gemini auth cookies. Run `npx -y bun skills/baoyu-gemini-web/scripts/main.ts --login` to sign in and refresh cookies.',
-  );
-  return merged;
-}
-
-export async function loadGeminiCookieMap(log?: BrowserLogger): Promise<Record<string, string>> {
-  const diskMap = await readGeminiCookieMapFromDisk({ log });
-  const inlineCookies = buildInlineCookiesFromEnv();
-  const envMap = buildGeminiCookieMap(inlineCookies);
-  return { ...diskMap, ...envMap };
-}
-
-export function createGeminiWebExecutor(
-  geminiOptions: GeminiWebOptions,
-): (runOptions: BrowserRunOptions) => Promise<BrowserRunResult> {
-  let persistedChatMetadata: unknown | null = null;
-  let referenceImagesUploaded = false;
-
-  return async (runOptions: BrowserRunOptions): Promise<BrowserRunResult> => {
-    const startTime = Date.now();
-    const log = runOptions.log;
-
-    log?.('[gemini-web] Starting Gemini web executor (TypeScript)');
-
-    const cookieMap = await loadGeminiCookies(runOptions.config, log);
-    if (!hasRequiredGeminiCookies(cookieMap)) {
-      throw new Error(
-        'Gemini browser mode requires auth cookies (missing __Secure-1PSID/__Secure-1PSIDTS). Run `npx -y bun skills/baoyu-gemini-web/scripts/main.ts --login` to sign in and save cookies.',
-      );
-    }
-
-    const configTimeout =
-      typeof runOptions.config?.timeoutMs === 'number' && Number.isFinite(runOptions.config.timeoutMs)
-        ? Math.max(1_000, runOptions.config.timeoutMs)
-        : null;
-
-    const generateVideoPath = resolveInvocationPath(geminiOptions.generateVideo);
-
-    const defaultTimeoutMs = geminiOptions.youtube
-      ? 240_000
-      : generateVideoPath
-        ? 900_000
-        : geminiOptions.generateImage || geminiOptions.editImage
-        ? 300_000
-        : 120_000;
-
-    const timeoutCapMs = generateVideoPath ? 1_800_000 : 600_000;
-    const timeoutMs = Math.min(configTimeout ?? defaultTimeoutMs, timeoutCapMs);
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-
-    const keepSession = geminiOptions.keepSession === true;
-
-    const generateImagePath = resolveInvocationPath(geminiOptions.generateImage);
-    const editImagePath = resolveInvocationPath(geminiOptions.editImage);
-    const outputPath = resolveInvocationPath(geminiOptions.outputPath);
-    const attachmentPaths = (runOptions.attachments ?? []).map((attachment) => attachment.path);
-    const referenceImagePaths = normalizePathList(geminiOptions.referenceImages);
-    const requestFilePaths = dedupePaths(
-      keepSession ? attachmentPaths : [...referenceImagePaths, ...attachmentPaths],
-    );
-
-    if (generateVideoPath && (generateImagePath || editImagePath)) {
-      throw new Error('Gemini web executor: generateVideo cannot be combined with generateImage/editImage options.');
-    }
-
-    let prompt = runOptions.prompt;
-    if (geminiOptions.aspectRatio && (generateImagePath || editImagePath || generateVideoPath)) {
-      prompt = `${prompt} (aspect ratio: ${geminiOptions.aspectRatio})`;
-    }
-    if (geminiOptions.youtube) {
-      prompt = `${prompt}\n\nYouTube video: ${geminiOptions.youtube}`;
-    }
-    if (generateImagePath && !editImagePath) {
-      prompt = `Generate an image: ${prompt}`;
-    }
-    if (generateVideoPath) {
-      prompt = `Generate a video: ${prompt}`;
-    }
-
-    const model: GeminiWebModelId = resolveGeminiWebModel(runOptions.config?.desiredModel, log);
-    let response: GeminiWebResponse;
-    let videoSaveSummary: { saved: boolean; videoCount: number; outputPath: string } | null = null;
-
-    try {
-      let chatMetadata: unknown = keepSession ? persistedChatMetadata : null;
-
-      if (keepSession && referenceImagePaths.length > 0 && !referenceImagesUploaded) {
-        const intro = await runGeminiWebWithFallback({
-          prompt: 'Here are reference images for future messages.',
-          files: referenceImagePaths,
-          model,
-          cookieMap,
-          chatMetadata,
-          signal: controller.signal,
-        });
-        chatMetadata = intro.metadata;
-        persistedChatMetadata = intro.metadata;
-        referenceImagesUploaded = true;
-      }
-
-      if (editImagePath) {
-        const intro = await runGeminiWebWithFallback({
-          prompt: 'Here is an image to edit',
-          files: [editImagePath],
-          model,
-          cookieMap,
-          chatMetadata,
-          signal: controller.signal,
-        });
-        const editPrompt = `Use image generation tool to ${prompt}`;
-        const out = await runGeminiWebWithFallback({
-          prompt: editPrompt,
-          files: requestFilePaths,
-          model,
-          cookieMap,
-          chatMetadata: intro.metadata,
-          signal: controller.signal,
-        });
-        if (keepSession) persistedChatMetadata = out.metadata;
-        response = {
-          text: out.text ?? null,
-          thoughts: geminiOptions.showThoughts ? out.thoughts : null,
-          has_images: false,
-          image_count: 0,
-        };
-
-        const resolvedOutputPath = outputPath ?? generateImagePath ?? 'generated.png';
-        const imageSave = await saveFirstGeminiImageFromOutput(out, cookieMap, resolvedOutputPath, controller.signal);
-        response.has_images = imageSave.saved;
-        response.image_count = imageSave.imageCount;
-        if (!imageSave.saved) {
-          throw new Error(`No images generated. Response text:\n${out.text || '(empty response)'}`);
-        }
-      } else if (generateImagePath) {
-        const out = await runGeminiWebWithFallback({
-          prompt,
-          files: requestFilePaths,
-          model,
-          cookieMap,
-          chatMetadata,
-          signal: controller.signal,
-        });
-        if (keepSession) persistedChatMetadata = out.metadata;
-        response = {
-          text: out.text ?? null,
-          thoughts: geminiOptions.showThoughts ? out.thoughts : null,
-          has_images: false,
-          image_count: 0,
-        };
-        const imageSave = await saveFirstGeminiImageFromOutput(out, cookieMap, generateImagePath, controller.signal);
-        response.has_images = imageSave.saved;
-        response.image_count = imageSave.imageCount;
-        if (!imageSave.saved) {
-          throw new Error(`No images generated. Response text:\n${out.text || '(empty response)'}`);
-        }
-      } else if (generateVideoPath) {
-        const out = await runGeminiWebWithFallback({
-          prompt,
-          files: requestFilePaths,
-          model,
-          cookieMap,
-          chatMetadata,
-          signal: controller.signal,
-        });
-        if (keepSession) persistedChatMetadata = out.metadata;
-        response = {
-          text: out.text ?? null,
-          thoughts: geminiOptions.showThoughts ? out.thoughts : null,
-          has_images: false,
-          image_count: 0,
-        };
-
-        const resolvedOutputPath = generateVideoPath ?? outputPath ?? 'generated.mp4';
-        const save = await saveFirstGeminiVideoFromOutput(out, cookieMap, resolvedOutputPath, controller.signal);
-        videoSaveSummary = { ...save, outputPath: resolvedOutputPath };
-      } else {
-        const out = await runGeminiWebWithFallback({
-          prompt,
-          files: requestFilePaths,
-          model,
-          cookieMap,
-          chatMetadata,
-          signal: controller.signal,
-        });
-        if (keepSession) persistedChatMetadata = out.metadata;
-        response = {
-          text: out.text ?? null,
-          thoughts: geminiOptions.showThoughts ? out.thoughts : null,
-          has_images: out.images.length > 0,
-          image_count: out.images.length,
-        };
-      }
-    } finally {
-      clearTimeout(timeout);
-    }
-
-    const answerText = response.text ?? '';
-    let answerMarkdown = answerText;
-
-    if (geminiOptions.showThoughts && response.thoughts) {
-      answerMarkdown = `## Thinking\n\n${response.thoughts}\n\n## Response\n\n${answerText}`;
-    }
-
-    if (response.has_images && response.image_count > 0) {
-      const imagePath = generateImagePath || outputPath || 'generated.png';
-      answerMarkdown += `\n\n*Generated ${response.image_count} image(s). Saved to: ${imagePath}*`;
-    }
-    if (videoSaveSummary) {
-      if (videoSaveSummary.saved) {
-        answerMarkdown += `\n\n*Generated ${videoSaveSummary.videoCount || 1} video(s). Saved to: ${videoSaveSummary.outputPath}*`;
-      } else if (/video_gen_chip/.test(answerMarkdown) || /video_gen_chip/.test(response.text ?? '')) {
-        answerMarkdown += '\n\n*Video generation is asynchronous. Check Gemini web UI to download the result.*';
-      } else {
-        answerMarkdown += '\n\n*No downloadable video URL found in Gemini response.*';
-      }
-    }
-
-    const tookMs = Date.now() - startTime;
-    log?.(`[gemini-web] Completed in ${tookMs}ms`);
-
-    return {
-      answerText,
-      answerMarkdown,
-      tookMs,
-      answerTokens: estimateTokenCount(answerText),
-      answerChars: answerText.length,
-    };
-  };
-}
@@ -1,21 +0,0 @@
-#!/usr/bin/env -S npx -y bun
-
-import process from 'node:process';
-
-import { getGeminiCookieMapViaChrome } from './chrome-auth.js';
-import { writeGeminiCookieMapToDisk } from './cookie-store.js';
-import { resolveGeminiWebChromeProfileDir, resolveGeminiWebCookiePath } from './paths.js';
-
-async function main(): Promise<void> {
-  const cookiePath = resolveGeminiWebCookiePath();
-  const profileDir = resolveGeminiWebChromeProfileDir();
-
-  const log = (msg: string) => console.log(msg);
-  const cookieMap = await getGeminiCookieMapViaChrome({ userDataDir: profileDir, log });
-  await writeGeminiCookieMapToDisk(cookieMap, { cookiePath, log });
-}
-
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});
@@ -1,2 +0,0 @@
-export { createGeminiWebExecutor } from './executor.js';
-export type { GeminiWebOptions, GeminiWebResponse } from './types.js';
@@ -1,445 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-
-import { fetchGeminiAccessToken, runGeminiWebWithFallback, saveFirstGeminiImageFromOutput } from './client.js';
-import { getGeminiCookieMapViaChrome } from './chrome-auth.js';
-import {
-  hasRequiredGeminiCookies,
-  readGeminiCookieMapFromDisk,
-  writeGeminiCookieMapToDisk,
-} from './cookie-store.js';
-import { resolveGeminiWebChromeProfileDir, resolveGeminiWebCookiePath } from './paths.js';
-import { readSession, writeSession, listSessions } from './session-store.js';
-
-function printUsage(exitCode = 0): never {
-  const cookiePath = resolveGeminiWebCookiePath();
-  const profileDir = resolveGeminiWebChromeProfileDir();
-
-  console.log(`Usage:
-  npx -y bun skills/baoyu-gemini-web/scripts/main.ts --prompt "Hello"
-  npx -y bun skills/baoyu-gemini-web/scripts/main.ts "Hello"
-  npx -y bun skills/baoyu-gemini-web/scripts/main.ts --prompt "A cute cat" --image generated.png
-  npx -y bun skills/baoyu-gemini-web/scripts/main.ts --promptfiles system.md content.md --image out.png
-
-Multi-turn conversation (agent generates unique sessionId):
-  npx -y bun skills/baoyu-gemini-web/scripts/main.ts "Remember 42" --sessionId abc123
-  npx -y bun skills/baoyu-gemini-web/scripts/main.ts "What number?" --sessionId abc123
-
-Options:
-  -p, --prompt <text>       Prompt text
-  --promptfiles <files...>  Read prompt from one or more files (concatenated in order)
-  -m, --model <id>          gemini-3-pro | gemini-2.5-pro | gemini-2.5-flash (default: gemini-3-pro)
-  --json                    Output JSON
-  --image [path]            Generate an image and save it (default: ./generated.png)
-  --reference <files...>    Reference images for vision input
-  --sessionId <id>          Session ID for multi-turn conversation (agent should generate unique ID)
-  --list-sessions           List saved sessions (max 100, sorted by update time)
-  --login                   Only refresh cookies, then exit
-  --cookie-path <path>      Cookie file path (default: ${cookiePath})
-  --profile-dir <path>      Chrome profile dir (default: ${profileDir})
-  -h, --help                Show help
-
-Env overrides:
-  GEMINI_WEB_DATA_DIR, GEMINI_WEB_COOKIE_PATH, GEMINI_WEB_CHROME_PROFILE_DIR, GEMINI_WEB_CHROME_PATH
-`);
-
-  process.exit(exitCode);
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function readPromptFromStdin(): Promise<string | null> {
-  if (process.stdin.isTTY) return null;
-  const chunks: Buffer[] = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  }
-  const text = Buffer.concat(chunks).toString('utf8').trim();
-  return text ? text : null;
-}
-
-function readPromptFiles(filePaths: string[]): string {
-  const contents: string[] = [];
-  for (const filePath of filePaths) {
-    const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
-    if (!fs.existsSync(resolved)) {
-      throw new Error(`Prompt file not found: ${resolved}`);
-    }
-    const content = fs.readFileSync(resolved, 'utf8').trim();
-    contents.push(content);
-  }
-  return contents.join('\n\n');
-}
-
-function parseArgs(argv: string[]): {
-  prompt?: string;
-  promptFiles?: string[];
-  model?: string;
-  json?: boolean;
-  imagePath?: string;
-  loginOnly?: boolean;
-  cookiePath?: string;
-  profileDir?: string;
-  referenceImages?: string[];
-  sessionId?: string;
-  listSessions?: boolean;
-} {
-  const out: ReturnType<typeof parseArgs> = {};
-  const positional: string[] = [];
-
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i] ?? '';
-    if (arg === '--help' || arg === '-h') printUsage(0);
-    if (arg === '--json') {
-      out.json = true;
-      continue;
-    }
-    if (arg === '--image' || arg === '--generate-image') {
-      const next = argv[i + 1];
-      if (next && !next.startsWith('-')) {
-        out.imagePath = next;
-        i += 1;
-      } else {
-        out.imagePath = 'generated.png';
-      }
-      continue;
-    }
-    if (arg.startsWith('--image=')) {
-      out.imagePath = arg.slice('--image='.length);
-      continue;
-    }
-    if (arg.startsWith('--generate-image=')) {
-      out.imagePath = arg.slice('--generate-image='.length);
-      continue;
-    }
-    if (arg === '--login') {
-      out.loginOnly = true;
-      continue;
-    }
-    if (arg === '--prompt' || arg === '-p') {
-      out.prompt = argv[i + 1] ?? '';
-      i += 1;
-      continue;
-    }
-    if (arg.startsWith('--prompt=')) {
-      out.prompt = arg.slice('--prompt='.length);
-      continue;
-    }
-    if (arg === '--promptfiles') {
-      out.promptFiles = [];
-      while (i + 1 < argv.length) {
-        const next = argv[i + 1];
-        if (next && !next.startsWith('-')) {
-          out.promptFiles.push(next);
-          i += 1;
-        } else {
-          break;
-        }
-      }
-      continue;
-    }
-    if (arg === '--model' || arg === '-m') {
-      out.model = argv[i + 1] ?? '';
-      i += 1;
-      continue;
-    }
-    if (arg.startsWith('--model=')) {
-      out.model = arg.slice('--model='.length);
-      continue;
-    }
-    if (arg === '--cookie-path') {
-      out.cookiePath = argv[i + 1] ?? '';
-      i += 1;
-      continue;
-    }
-    if (arg.startsWith('--cookie-path=')) {
-      out.cookiePath = arg.slice('--cookie-path='.length);
-      continue;
-    }
-    if (arg === '--profile-dir') {
-      out.profileDir = argv[i + 1] ?? '';
-      i += 1;
-      continue;
-    }
-    if (arg.startsWith('--profile-dir=')) {
-      out.profileDir = arg.slice('--profile-dir='.length);
-      continue;
-    }
-    if (arg === '--reference' || arg === '--ref') {
-      out.referenceImages = [];
-      while (i + 1 < argv.length) {
-        const next = argv[i + 1];
-        if (next && !next.startsWith('-')) {
-          out.referenceImages.push(next);
-          i += 1;
-        } else {
-          break;
-        }
-      }
-      continue;
-    }
-    if (arg === '--sessionId' || arg === '--session-id') {
-      out.sessionId = argv[i + 1] ?? '';
-      i += 1;
-      continue;
-    }
-    if (arg.startsWith('--sessionId=') || arg.startsWith('--session-id=')) {
-      out.sessionId = arg.split('=')[1] ?? '';
-      continue;
-    }
-    if (arg === '--list-sessions') {
-      out.listSessions = true;
-      continue;
-    }
-
-    if (arg.startsWith('-')) {
-      throw new Error(`Unknown option: ${arg}`);
-    }
-    positional.push(arg);
-  }
-
-  if (!out.prompt && positional.length > 0) {
-    out.prompt = positional.join(' ').trim();
-  }
-
-  if (out.prompt != null) out.prompt = out.prompt.trim();
-  if (out.model != null) out.model = out.model.trim();
-  if (out.imagePath != null) out.imagePath = out.imagePath.trim();
-  if (out.cookiePath != null) out.cookiePath = out.cookiePath.trim();
-  if (out.profileDir != null) out.profileDir = out.profileDir.trim();
-
-  if (out.imagePath === '') delete out.imagePath;
-  if (out.cookiePath === '') delete out.cookiePath;
-  if (out.profileDir === '') delete out.profileDir;
-  if (out.promptFiles?.length === 0) delete out.promptFiles;
-  if (out.referenceImages?.length === 0) delete out.referenceImages;
-  if (out.sessionId != null) out.sessionId = out.sessionId.trim();
-  if (out.sessionId === '') delete out.sessionId;
-
-  return out;
-}
-
-async function isCookieMapValid(cookieMap: Record<string, string>): Promise<boolean> {
-  if (!hasRequiredGeminiCookies(cookieMap)) return false;
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 30_000);
-  try {
-    await fetchGeminiAccessToken(cookieMap, controller.signal);
-    return true;
-  } catch {
-    return false;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-async function ensureGeminiCookieMap(options: {
-  cookiePath: string;
-  profileDir: string;
-}): Promise<Record<string, string>> {
-  const log = (msg: string) => console.error(msg);
-
-  let cookieMap = await readGeminiCookieMapFromDisk({ cookiePath: options.cookiePath, log });
-  if (await isCookieMapValid(cookieMap)) return cookieMap;
-
-  log('[gemini-web] No valid cookies found. Opening browser to sync Gemini cookies...');
-  cookieMap = await getGeminiCookieMapViaChrome({ userDataDir: options.profileDir, log });
-  await writeGeminiCookieMapToDisk(cookieMap, { cookiePath: options.cookiePath, log });
-  return cookieMap;
-}
-
-function resolveModel(value: string): 'gemini-3-pro' | 'gemini-2.5-pro' | 'gemini-2.5-flash' {
-  const desired = value.trim();
-  if (!desired) return 'gemini-3-pro';
-  switch (desired) {
-    case 'gemini-3-pro':
-    case 'gemini-3.0-pro':
-      return 'gemini-3-pro';
-    case 'gemini-2.5-pro':
-      return 'gemini-2.5-pro';
-    case 'gemini-2.5-flash':
-      return 'gemini-2.5-flash';
-    default:
-      console.error(`[gemini-web] Unsupported model "${desired}", falling back to gemini-3-pro.`);
-      return 'gemini-3-pro';
-  }
-}
-
-function resolveImageOutputPath(value: string | undefined): string | null {
-  if (value == null) return null;
-  const trimmed = value.trim();
-  const raw = trimmed || 'generated.png';
-  const resolved = path.isAbsolute(raw) ? raw : path.resolve(process.cwd(), raw);
-
-  if (resolved.endsWith(path.sep)) return path.join(resolved, 'generated.png');
-  try {
-    if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
-      return path.join(resolved, 'generated.png');
-    }
-  } catch {
-    // ignore
-  }
-  return resolved;
-}
-
-async function main(): Promise<void> {
-  const args = parseArgs(process.argv.slice(2));
-  const cookiePath = args.cookiePath ?? resolveGeminiWebCookiePath();
-  const profileDir = args.profileDir ?? resolveGeminiWebChromeProfileDir();
-
-  if (args.listSessions) {
-    const sessions = await listSessions();
-    if (sessions.length === 0) {
-      console.log('No saved sessions.');
-    } else {
-      for (const { id, updatedAt } of sessions) {
-        console.log(`${id}\t${updatedAt}`);
-      }
-    }
-    return;
-  }
-
-  if (args.loginOnly) {
-    await ensureGeminiCookieMap({ cookiePath, profileDir });
-    return;
-  }
-
-  const promptFromFiles = args.promptFiles ? readPromptFiles(args.promptFiles) : null;
-  const promptFromArgs = promptFromFiles || args.prompt;
-  const prompt = promptFromArgs || (await readPromptFromStdin());
-  if (!prompt) printUsage(1);
-
-  const sessionData = args.sessionId ? await readSession(args.sessionId) : null;
-  const chatMetadata = sessionData?.metadata ?? null;
-
-  let cookieMap = await ensureGeminiCookieMap({ cookiePath, profileDir });
-
-  const desiredModel = resolveModel(args.model || 'gemini-3-pro');
-  const imagePath = resolveImageOutputPath(args.imagePath);
-  const referenceImages = (args.referenceImages ?? []).map((p) =>
-    path.isAbsolute(p) ? p : path.resolve(process.cwd(), p),
-  );
-
-  try {
-    const controller = new AbortController();
-    const timeoutMs = imagePath ? 300_000 : 120_000;
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-
-    try {
-      const effectivePrompt = imagePath ? `Generate an image: ${prompt}` : prompt;
-      const out = await runGeminiWebWithFallback({
-        prompt: effectivePrompt,
-        files: referenceImages,
-        model: desiredModel,
-        cookieMap,
-        chatMetadata,
-        signal: controller.signal,
-      });
-
-      if (args.sessionId && out.metadata) {
-        await writeSession(args.sessionId, out.metadata, prompt, out.text ?? '', out.errorMessage);
-      }
-
-      let imageSaved = false;
-      let imageCount = 0;
-      if (imagePath) {
-        const save = await saveFirstGeminiImageFromOutput(out, cookieMap, imagePath, controller.signal);
-        imageSaved = save.saved;
-        imageCount = save.imageCount;
-        if (!imageSaved) {
-          throw new Error(`No images generated. Response text:\n${out.text || '(empty response)'}`);
-        }
-      }
-
-      if (args.json) {
-        const jsonOut = { ...out, ...(imagePath && { imageSaved, imageCount, imagePath }), ...(args.sessionId && { sessionId: args.sessionId }) };
-        process.stdout.write(`${JSON.stringify(jsonOut, null, 2)}\n`);
-        if (out.errorMessage) process.exit(1);
-        return;
-      }
-
-      if (out.errorMessage) {
-        throw new Error(out.errorMessage);
-      }
-
-      process.stdout.write(out.text ?? '');
-      if (!out.text?.endsWith('\n')) process.stdout.write('\n');
-      if (imagePath) {
-        process.stdout.write(`Saved image (${imageCount || 1}) to: ${imagePath}\n`);
-      }
-      return;
-    } finally {
-      clearTimeout(timeout);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-
-    if (message.includes('Unable to locate Gemini access token')) {
-      console.error('[gemini-web] Cookies may be expired. Re-opening browser to refresh cookies...');
-      await sleep(500);
-      cookieMap = await getGeminiCookieMapViaChrome({ userDataDir: profileDir, log: (m) => console.error(m) });
-      await writeGeminiCookieMapToDisk(cookieMap, { cookiePath, log: (m) => console.error(m) });
-
-      const controller = new AbortController();
-      const timeoutMs = imagePath ? 300_000 : 120_000;
-      const timeout = setTimeout(() => controller.abort(), timeoutMs);
-
-      try {
-        const out = await runGeminiWebWithFallback({
-          prompt: imagePath ? `Generate an image: ${prompt}` : prompt,
-          files: referenceImages,
-          model: desiredModel,
-          cookieMap,
-          chatMetadata,
-          signal: controller.signal,
-        });
-
-        if (args.sessionId && out.metadata) {
-          await writeSession(args.sessionId, out.metadata, prompt, out.text ?? '', out.errorMessage);
-        }
-
-        let imageSaved = false;
-        let imageCount = 0;
-        if (imagePath) {
-          const save = await saveFirstGeminiImageFromOutput(out, cookieMap, imagePath, controller.signal);
-          imageSaved = save.saved;
-          imageCount = save.imageCount;
-          if (!imageSaved) {
-            throw new Error(`No images generated. Response text:\n${out.text || '(empty response)'}`);
-          }
-        }
-
-        if (args.json) {
-          const jsonOut = { ...out, ...(imagePath && { imageSaved, imageCount, imagePath }), ...(args.sessionId && { sessionId: args.sessionId }) };
-          process.stdout.write(`${JSON.stringify(jsonOut, null, 2)}\n`);
-          if (out.errorMessage) process.exit(1);
-          return;
-        }
-
-        if (out.errorMessage) {
-          throw new Error(out.errorMessage);
-        }
-
-        process.stdout.write(out.text ?? '');
-        if (!out.text?.endsWith('\n')) process.stdout.write('\n');
-        if (imagePath) {
-          process.stdout.write(`Saved image (${imageCount || 1}) to: ${imagePath}\n`);
-        }
-        return;
-      } finally {
-        clearTimeout(timeout);
-      }
-    }
-
-    throw error;
-  }
-}
-
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});
@@ -1,90 +0,0 @@
-import { mkdir, readFile, writeFile, readdir, stat } from 'node:fs/promises';
-import path from 'node:path';
-import { resolveGeminiWebSessionsDir, resolveGeminiWebSessionPath } from './paths.js';
-
-export interface SessionMessage {
-  role: 'user' | 'assistant';
-  content: string;
-  timestamp: string;
-  error?: string;
-}
-
-export interface SessionData {
-  id: string;
-  metadata: unknown;
-  messages: SessionMessage[];
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface SessionListItem {
-  id: string;
-  updatedAt: string;
-}
-
-export async function readSession(id: string): Promise<SessionData | null> {
-  const sessionPath = resolveGeminiWebSessionPath(id);
-  try {
-    const content = await readFile(sessionPath, 'utf8');
-    return JSON.parse(content) as SessionData;
-  } catch {
-    return null;
-  }
-}
-
-export async function writeSession(
-  id: string,
-  metadata: unknown,
-  userMessage: string,
-  assistantMessage: string,
-  error?: string,
-): Promise<void> {
-  const sessionPath = resolveGeminiWebSessionPath(id);
-  const sessionsDir = resolveGeminiWebSessionsDir();
-  await mkdir(sessionsDir, { recursive: true });
-
-  const existing = await readSession(id);
-  const now = new Date().toISOString();
-
-  const newMessages: SessionMessage[] = [
-    { role: 'user', content: userMessage, timestamp: now },
-    { role: 'assistant', content: assistantMessage, timestamp: now, ...(error && { error }) },
-  ];
-
-  const data: SessionData = {
-    id,
-    metadata,
-    messages: [...(existing?.messages ?? []), ...newMessages],
-    createdAt: existing?.createdAt ?? now,
-    updatedAt: now,
-  };
-  await writeFile(sessionPath, JSON.stringify(data, null, 2));
-}
-
-export async function listSessions(limit = 100): Promise<SessionListItem[]> {
-  const sessionsDir = resolveGeminiWebSessionsDir();
-  try {
-    const files = await readdir(sessionsDir);
-    const jsonFiles = files.filter((f) => f.endsWith('.json'));
-
-    const items: { id: string; updatedAt: string; mtime: number }[] = [];
-    for (const file of jsonFiles) {
-      const filePath = path.join(sessionsDir, file);
-      try {
-        const stats = await stat(filePath);
-        items.push({
-          id: file.slice(0, -5),
-          updatedAt: stats.mtime.toISOString(),
-          mtime: stats.mtime.getTime(),
-        });
-      } catch {
-        continue;
-      }
-    }
-
-    items.sort((a, b) => b.mtime - a.mtime);
-    return items.slice(0, limit).map(({ id, updatedAt }) => ({ id, updatedAt }));
-  } catch {
-    return [];
-  }
-}
@@ -1,25 +0,0 @@
-export interface GeminiWebOptions {
-  youtube?: string;
-  generateImage?: string;
-  editImage?: string;
-  generateVideo?: string;
-  outputPath?: string;
-  showThoughts?: boolean;
-  aspectRatio?: string;
-  /**
-   * One or more local image paths to upload as persistent reference images.
-   * - If `keepSession` is enabled, they are uploaded once per executor session.
-   * - Otherwise, they are attached to each request.
-   */
-  referenceImages?: string | string[];
-  /** Preserve Gemini chat metadata to continue multi-turn conversations within the same executor instance. */
-  keepSession?: boolean;
-}
-
-export interface GeminiWebResponse {
-  text: string | null;
-  thoughts: string | null;
-  has_images: boolean;
-  image_count: number;
-  error?: string;
-}
@@ -72,3 +72,13 @@ npx -y bun ${SKILL_DIR}/scripts/wechat-article.ts --markdown article.md --theme
 - **Not logged in**: First run opens browser - scan QR code to log in, session is preserved
 - **Chrome not found**: Set `WECHAT_BROWSER_CHROME_PATH` environment variable
 - **Paste fails**: Check system clipboard permissions
+
+## Extension Support
+
+Custom configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-post-to-wechat/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-post-to-wechat/EXTEND.md` (user)
+
+If found, load before workflow. Extension content overrides defaults.
@@ -101,3 +101,13 @@ cover_image: /path/to/cover.jpg
 - Always preview before using `--submit`
 - Browser closes automatically after operation
 - Supports macOS, Linux, and Windows
+
+## Extension Support
+
+Custom configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-post-to-x/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-post-to-x/EXTEND.md` (user)
+
+If found, load before workflow. Extension content overrides defaults.
@@ -48,16 +48,21 @@ Transform content into professional slide deck images with flexible style option

 | Style | Description | Best For |
 |-------|-------------|----------|
-| `sketch-notes` | Hand-drawn, warm & friendly | Educational, tutorials |
-| `blueprint` | Technical, precise & analytical | Architecture, system design |
-| `bold-editorial` | Magazine, high-impact & dynamic | Product launches, keynotes |
-| `vector-illustration` | Flat vector, retro & cute | Creative, children's content |
+| `blueprint` (Default) | Technical schematics, grid texture | Architecture, system design |
+| `notion` | SaaS dashboard, card-based layouts | Product demos, SaaS, B2B |
+| `bold-editorial` | Magazine cover, bold typography, dark | Product launches, keynotes |
+| `corporate` | Navy/gold, structured layouts | Investor decks, proposals |
+| `dark-atmospheric` | Cinematic dark mode, glowing accents | Entertainment, gaming |
+| `editorial-infographic` | Magazine explainers, flat illustrations | Tech explainers, research |
+| `fantasy-animation` | Ghibli/Disney style, hand-drawn | Educational, storytelling |
+| `intuition-machine` | Technical briefing, bilingual labels | Technical docs, academic |
 | `minimal` | Ultra-clean, maximum whitespace | Executive briefings, premium |
-| `storytelling` | Cinematic, full-bleed visuals | Narratives, case studies |
-| `warm` | Soft gradients, wellness aesthetic | Lifestyle, personal development |
-| `notion` (Default) | SaaS dashboard, clean data focus | Product demos, productivity |
-| `corporate` | Navy/gold, professional | Investor decks, proposals |
-| `playful` | Vibrant, dynamic shapes | Workshops, training |
+| `pixel-art` | Retro 8-bit, chunky pixels | Gaming, developer talks |
+| `scientific` | Academic diagrams, precise labeling | Biology, chemistry, medical |
+| `sketch-notes` | Hand-drawn, warm & friendly | Educational, tutorials |
+| `vector-illustration` | Flat vector, retro & cute | Creative, children's content |
+| `vintage` | Aged-paper, historical styling | Historical, heritage, biography |
+| `watercolor` | Hand-painted textures, natural warmth | Lifestyle, wellness, travel |

 ## Auto Style Selection

@@ -65,15 +70,20 @@ Transform content into professional slide deck images with flexible style option
 |-----------------|----------------|
 | tutorial, learn, education, guide, intro, beginner | `sketch-notes` |
 | architecture, system, data, analysis, technical | `blueprint` |
-| launch, marketing, brand, keynote, impact | `bold-editorial` |
 | creative, children, kids, cute, illustration | `vector-illustration` |
+| briefing, academic, research, bilingual, infographic, concept | `intuition-machine` |
 | executive, minimal, clean, simple, elegant | `minimal` |
-| story, journey, case study, narrative, emotional | `storytelling` |
-| wellness, lifestyle, personal, growth, mindfulness | `warm` |
 | saas, product, dashboard, metrics, productivity | `notion` |
 | investor, quarterly, business, corporate, proposal | `corporate` |
-| workshop, training, fun, playful, energetic | `playful` |
-| Default | `notion` |
+| launch, marketing, keynote, bold, impact, magazine | `bold-editorial` |
+| entertainment, music, gaming, creative, atmospheric | `dark-atmospheric` |
+| explainer, journalism, science communication | `editorial-infographic` |
+| story, fantasy, animation, magical, whimsical | `fantasy-animation` |
+| gaming, retro, pixel, developer, nostalgia | `pixel-art` |
+| biology, chemistry, medical, pathway, scientific | `scientific` |
+| history, heritage, vintage, expedition, historical | `vintage` |
+| lifestyle, wellness, travel, artistic, natural | `watercolor` |
+| Default | `blueprint` |

 ## Design Philosophy

@@ -89,18 +99,21 @@ This deck is designed for **reading and sharing**, not live presentation:
 ```
 content-dir/
 ├── source-content.md
-└── slide-deck/
-    ├── outline.md
-    ├── prompts/
-    │   └── 01-slide-cover.md, 02-slide-{slug}.md, ...
-    ├── 01-slide-cover.png, 02-slide-{slug}.png, ...
-    ├── {topic-slug}.pptx
-    └── {topic-slug}.pdf
+└── source-content/
+    └── slide-deck/
+        ├── outline.md
+        ├── prompts/
+        │   └── 01-slide-cover.md, 02-slide-{slug}.md, ...
+        ├── 01-slide-cover.png, 02-slide-{slug}.png, ...
+        ├── {topic-slug}.pptx
+        └── {topic-slug}.pdf
 ```

+Example: `/posts/ai-intro.md` → `/posts/ai-intro/slide-deck/`
+
 ### Without Content Path (Pasted Content)
 ```
-slide-outputs/YYYY-MM-DD/{topic-slug}/
+slide-deck/{topic-slug}/
 ├── source.md
 ├── outline.md
 ├── prompts/
@@ -109,6 +122,10 @@ slide-outputs/YYYY-MM-DD/{topic-slug}/
 └── {topic-slug}.pdf
 ```

+### Directory Backup
+
+If target directory exists, rename existing to `<dirname>-backup-YYYYMMDD-HHMMSS`
+
 ## Workflow

 ### Step 1: Analyze Content
@@ -207,3 +224,13 @@ See `references/modification-guide.md` for:
 - Auto-retry once on generation failure
 - Use stylized alternatives for sensitive public figures
 - Maintain style consistency via session ID
+
+## Extension Support
+
+Custom styles and configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-slide-deck/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-slide-deck/EXTEND.md` (user)
+
+If found, load before Step 1. Extension content overrides defaults.
@@ -67,3 +67,4 @@ Clean sans-serif such as Inter, SF Pro, or Helvetica Neue. Medium weight for bod
 ## Best For

 Product launches, marketing presentations, keynote speeches, brand showcases, investor pitches, high-stakes presentations
+
@@ -0,0 +1,69 @@
+# dark-atmospheric
+
+Dark moody aesthetic with deep colors and glowing accent elements
+
+## Design Aesthetic
+
+Cinematic dark mode aesthetic with atmospheric depth. Deep purples, blacks, and rich shadows with glowing accents creating dramatic visual contrast. Mysterious, sophisticated, and visually striking. Perfect for evening events, creative industries, and premium brand presentations.
+
+## Background
+
+- Color: Deep Purple-Black (#0D0D1A) or Rich Navy (#1A1A2E)
+- Texture: Subtle gradient from darker edges to slightly lighter center, atmospheric fog effect
+
+## Typography
+
+### Primary Font (Headlines)
+
+Elegant serif or refined sans-serif in light/white. High contrast against dark background. Medium to bold weight. Letterforms may have subtle glow effect.
+
+### Secondary Font (Body)
+
+Clean sans-serif in light gray or muted white. Readable against dark backgrounds. Regular weight with generous line height.
+
+## Color Palette
+
+| Role | Color | Hex | Usage |
+|------|-------|-----|-------|
+| Background | Deep Purple-Black | #0D0D1A | Primary background |
+| Alt Background | Rich Navy | #1A1A2E | Secondary areas |
+| Primary Text | Pure White | #FFFFFF | Headlines |
+| Secondary Text | Light Gray | #A0AEC0 | Body text |
+| Glow Accent 1 | Electric Purple | #8B5CF6 | Primary glow |
+| Glow Accent 2 | Cyan Blue | #06B6D4 | Secondary glow |
+| Glow Accent 3 | Magenta Pink | #EC4899 | Tertiary accent |
+| Glow Accent 4 | Amber | #F59E0B | Warm highlights |
+| Subtle | Dark Gray | #2D3748 | Dividers, borders |
+
+## Visual Elements
+
+- Glowing accent elements and borders
+- Subtle gradient backgrounds
+- Atmospheric fog or particle effects
+- Neon-style highlights on key elements
+- Silhouettes with backlit edges
+- Audio waveforms or sound visualizations
+- Radiating light circles and orbs
+- Cinematic letterboxing optional
+
+## Style Rules
+
+### Do
+
+- Maintain high contrast for readability
+- Use glowing effects sparingly for emphasis
+- Create atmospheric depth with gradients
+- Design dramatic visual focal points
+- Keep text crisp against dark backgrounds
+
+### Don't
+
+- Overuse neon effects (less is more)
+- Create low-contrast text combinations
+- Use bright backgrounds
+- Add cluttered busy elements
+- Add slide numbers, footers, or logos
+
+## Best For
+
+Entertainment presentations, music and audio content, creative agency pitches, evening events, premium brand reveals, gaming content, cinematic storytelling, tech product launches
@@ -0,0 +1,73 @@
+# editorial-infographic
+
+Modern magazine-style editorial infographic with clear visual storytelling
+
+## Design Aesthetic
+
+High-quality magazine explainer aesthetic. Clear visual storytelling that transforms complex information into digestible narratives. Clean illustrations, structured layouts, and professional typography. Think Wired, The Verge, or high-end science publications.
+
+## Background
+
+- Color: Pure White (#FFFFFF) or Light Gray (#F8F9FA)
+- Texture: None or subtle paper grain for print feel
+
+## Typography
+
+### Primary Font (Headlines)
+
+Bold display serif or modern sans-serif. Strong visual presence. Clean letterforms with editorial sophistication. Large scale for impact.
+
+### Secondary Font (Subheads)
+
+Semi-bold sans-serif for section headers. Clear hierarchy distinction from body text. Consistent styling throughout.
+
+### Body Font
+
+Humanist sans-serif optimized for reading. Clean, professional, accessible. Comfortable line height (1.6).
+
+## Color Palette
+
+| Role | Color | Hex | Usage |
+|------|-------|-----|-------|
+| Background | Pure White | #FFFFFF | Primary background |
+| Alt Background | Light Gray | #F8F9FA | Section backgrounds |
+| Primary Text | Near Black | #1A1A1A | Headlines, body |
+| Secondary Text | Dark Gray | #4A5568 | Captions, metadata |
+| Accent 1 | Editorial Blue | #2563EB | Primary accent |
+| Accent 2 | Coral | #F97316 | Secondary accent |
+| Accent 3 | Emerald | #10B981 | Positive elements |
+| Accent 4 | Amber | #F59E0B | Warning, attention |
+| Dividers | Medium Gray | #D1D5DB | Section dividers |
+
+## Visual Elements
+
+- Clean flat illustrations (not photos)
+- Structured multi-section layouts
+- Callout boxes for key insights
+- Icon-based data visualization
+- Visual metaphors for abstract concepts
+- Flow diagrams with clear directional hierarchy
+- Pull quotes and highlight boxes
+- Section dividers and visual breaks
+
+## Style Rules
+
+### Do
+
+- Create clear visual narrative flow
+- Use structured multi-section layouts
+- Include callout boxes for key insights
+- Design visual metaphors for complex ideas
+- Maintain magazine-quality polish
+
+### Don't
+
+- Use photographic imagery
+- Create cluttered dense layouts
+- Mix too many visual styles
+- Add decorative elements without purpose
+- Add slide numbers, footers, or logos
+
+## Best For
+
+Technology explainers, science communication, research summaries, policy briefings, investigative content, educational deep-dives, thought leadership pieces
@@ -0,0 +1,69 @@
+# fantasy-animation
+
+Whimsical hand-drawn animation style inspired by classic fantasy illustration
+
+## Design Aesthetic
+
+Charming hand-drawn animation aesthetic reminiscent of classic Disney, Studio Ghibli, or European storybook illustration. Soft, painterly textures with warm, inviting colors. Friendly characters, magical elements, and storybook layouts. Enchanting, nostalgic, and emotionally engaging.
+
+## Background
+
+- Color: Soft Sky Blue (#E8F4FC) or Warm Cream (#FFF8E7)
+- Texture: Subtle watercolor wash, soft brush strokes, gentle paper texture
+
+## Typography
+
+### Primary Font (Headlines)
+
+Whimsical serif or decorative hand-lettered style. Slight curvature and organic feel. Warm, friendly character. Think fairy tale book titles.
+
+### Secondary Font (Body)
+
+Rounded sans-serif or casual handwritten style. Friendly and readable. Maintains storybook aesthetic while staying legible.
+
+## Color Palette
+
+| Role | Color | Hex | Usage |
+|------|-------|-----|-------|
+| Background | Soft Sky Blue | #E8F4FC | Primary background |
+| Alt Background | Warm Cream | #FFF8E7 | Secondary areas |
+| Primary Text | Deep Forest | #2D5A3D | Headlines |
+| Body Text | Warm Brown | #5D4E37 | Body content |
+| Accent 1 | Golden Yellow | #F4D03F | Magic, highlights |
+| Accent 2 | Rose Pink | #E8A0BF | Warmth, charm |
+| Accent 3 | Sage Green | #87A96B | Nature elements |
+| Accent 4 | Sky Blue | #7EC8E3 | Air, water, dreams |
+| Accent 5 | Coral | #F08080 | Emphasis, life |
+
+## Visual Elements
+
+- Central illustrated character (friendly, expressive)
+- Small companion creatures (animals, magical beings)
+- Storybook-style environment backgrounds
+- Magical floating objects (books, bags, boxes, orbs)
+- Decorative elements: stars, sparkles, flowers, leaves
+- Soft shadows and gentle highlights
+- Layered depth with foreground/background elements
+- Themed content containers (trunks, satchels, scroll boxes)
+
+## Style Rules
+
+### Do
+
+- Create warm, inviting compositions
+- Use soft edges and painterly textures
+- Include charming character illustrations
+- Add magical decorative touches
+- Maintain storybook narrative feel
+
+### Don't
+
+- Use harsh geometric shapes
+- Create dark or intimidating imagery
+- Add photorealistic elements
+- Use cold color palettes
+- Add slide numbers, footers, or logos
+
+## Best For
+
+Educational content, children's presentations, storytelling, creative workshops, book presentations, fantasy/gaming content, inspirational talks, family-friendly events
@@ -0,0 +1,72 @@
+# intuition-machine
+
+Technical briefing infographic style with aged paper texture and bilingual explanatory text boxes
+
+## Design Aesthetic
+
+Academic/technical briefing presentation style, NOT artistic 3D renders. Clean 2D or isometric technical illustrations with multiple explanatory text boxes containing article content. Split layouts with visuals on left/center and text on right/bottom. Information-dense but organized with clear visual hierarchy. Vintage blueprint aesthetic with modern clarity.
+
+## Background
+
+- Color: Aged Cream (#F5F0E6)
+- Texture: Subtle paper texture with light creases, warm nostalgic feel reminiscent of vintage technical prints
+
+## Typography
+
+### Primary Font (Headlines)
+
+Bold display font in dark maroon, ALL CAPS in brackets for main titles. English subtitle below in smaller size. Technical, authoritative presence with vintage character.
+
+### Secondary Font (Labels)
+
+Clean sans-serif for bilingual callout labels. Format: "ENGLISH TERM 中文翻译". High contrast against background.
+
+### Body Font
+
+Clean geometric sans-serif for text box content. Readable at smaller sizes. Consistent weight throughout.
+
+## Color Palette
+
+| Role | Color | Hex | Usage |
+|------|-------|-----|-------|
+| Background | Aged Cream | #F5F0E6 | Primary background |
+| Paper Texture | Warm White | #F5F0E1 | Blueprint paper effect |
+| Primary Text | Dark Maroon | #5D3A3A | Headlines, titles |
+| Body Text | Near Black | #1A1A1A | Text box content |
+| Accent 1 | Teal | #2F7373 | Primary illustrations |
+| Accent 2 | Warm Brown | #8B7355 | Secondary elements |
+| Accent 3 | Maroon | #722F37 | Titles, emphasis |
+| Outline | Deep Charcoal | #2D2D2D | Element outlines |
+
+## Visual Elements
+
+- Isometric 3D technical illustrations OR flat 2D diagrams (choose based on concept)
+- 3-5 explanatory text boxes per slide with labeled content
+- Bilingual callout labels pointing to key parts
+- Faded thematic background patterns (circuits, gears, flowcharts related to topic)
+- Clean black outlines on all elements
+- Split or triptych layouts
+- "KEY QUOTE:" box at bottom with core insight
+- No title blocks, stamps, or watermarks in corners
+
+## Style Rules
+
+### Do
+
+- Include 3-5 text boxes with substantive content from source material
+- Use bilingual labels (English + Chinese) for key elements
+- Add faded thematic background patterns related to the topic
+- Maintain aged paper texture throughout
+- Create clear visual hierarchy with split layouts
+
+### Don't
+
+- Create photorealistic renders or artistic 3D scenes
+- Leave slides without explanatory text content
+- Add title blocks or stamps in corners
+- Use gradients or glossy effects
+- Add slide numbers, footers, or logos
+
+## Best For
+
+Technical explanations, concept breakdowns, academic presentations, knowledge documentation, research summaries, educational content with depth, bilingual audiences
@@ -0,0 +1,67 @@
+# pixel-art
+
+Retro 8-bit pixel art aesthetic with nostalgic gaming visual style
+
+## Design Aesthetic
+
+Pixelated retro aesthetic reminiscent of classic 8-bit and 16-bit era games. Chunky pixels, limited color palettes, and nostalgic gaming references. Simple geometric shapes rendered in blocky pixel form. Fun, playful, and immediately recognizable retro tech aesthetic.
+
+## Background
+
+- Color: Light Blue (#87CEEB) or Soft Lavender (#E6E6FA)
+- Texture: Subtle pixel grid pattern, CRT scanline effect optional
+
+## Typography
+
+### Primary Font (Headlines)
+
+Pixelated bitmap font style. Chunky, blocky letterforms with visible pixel structure. All caps for maximum readability. Render as actual pixel art, not smooth vectors.
+
+### Secondary Font (Body)
+
+Smaller pixel font with consistent 8x8 or 16x16 character grid. High contrast against background. Limited anti-aliasing to maintain retro feel.
+
+## Color Palette
+
+| Role | Color | Hex | Usage |
+|------|-------|-----|-------|
+| Background | Light Blue | #87CEEB | Primary background |
+| Alt Background | Soft Lavender | #E6E6FA | Secondary backgrounds |
+| Primary Text | Dark Navy | #1A1A2E | Headlines, body text |
+| Accent 1 | Pixel Green | #00FF00 | Success, highlights |
+| Accent 2 | Pixel Red | #FF0000 | Alerts, emphasis |
+| Accent 3 | Pixel Yellow | #FFFF00 | Warnings, energy |
+| Accent 4 | Pixel Cyan | #00FFFF | Info, tech elements |
+| Accent 5 | Pixel Magenta | #FF00FF | Special elements |
+
+## Visual Elements
+
+- All elements rendered with visible pixel structure
+- Simple iconography: notepad, checkboxes, gears, rockets, play buttons
+- Text bubbles and speech boxes with pixel borders
+- 8-bit style decorative elements: stars, hearts, arrows
+- Progress bars with chunky pixel segments
+- Dithering patterns for gradients and shadows
+- Limited to 16-32 color palette per slide
+
+## Style Rules
+
+### Do
+
+- Maintain consistent pixel grid throughout
+- Use limited color palette (16-32 colors max)
+- Create blocky, geometric shapes
+- Add nostalgic gaming references where appropriate
+- Use dithering for color transitions
+
+### Don't
+
+- Use smooth gradients or anti-aliasing
+- Create photorealistic elements
+- Use thin lines or fine details
+- Add modern glossy effects
+- Add slide numbers, footers, or logos
+
+## Best For
+
+Gaming presentations, tech tutorials, nostalgic content, developer talks, retro-themed events, educational content for younger audiences, creative tech presentations
@@ -1,69 +0,0 @@
-# playful
-
-Bold, energetic style with vibrant colors and dynamic shapes
-
-## Design Aesthetic
-
-Dynamic shapes, vibrant colors, and creative layouts that capture attention and spark joy. Approachable and fun without sacrificing clarity. Perfect for content that needs to educate while entertaining, making complex topics feel accessible and exciting.
-
-## Background
-
- Color: Warm White (#FFFDF7), soft and inviting
- Texture: Light subtle pattern or clean gradient
-
-## Typography
-
-### Primary Font (Headlines)
-
-Bold rounded sans-serif (Poppins, Nunito Bold, or similar). Friendly, modern, and highly readable. Conveys energy and approachability with geometric character.
-
-### Secondary Font (Body)
-
-Rounded sans-serif (Nunito style) for body text. Soft edges create warmth and readability, complementing the playful aesthetic.
-
-## Color Palette
-
-| Role | Color | Hex | Usage |
-|------|-------|-----|-------|
-| Background | Warm White | #FFFDF7 | Main slide background |
-| Primary Text | Deep Purple | #4A1D96 | Headlines, key text |
-| Secondary Text | Dark Purple | #6B3FA0 | Body text |
-| Primary Accent | Vibrant Coral | #FF6B6B | Primary highlights |
-| Secondary Accent | Electric Teal | #4ECDC4 | Secondary emphasis |
-| Tertiary | Sunshine Yellow | #FFE66D | Tertiary accent |
-| Success | Mint Green | #95E1C3 | Positive elements |
-| Energy | Hot Pink | #FF69B4 | High energy callouts |
-
-## Visual Elements
-
- Rounded shapes and soft corners everywhere
- Playful gradients (subtle, not overwhelming)
- Character illustrations and mascots
- Dynamic asymmetrical compositions
- Bright color pops and accents
- Confetti and celebration elements
- Emoji-style icons
- Bubble and cloud shapes
-
-## Style Rules
-
-### Do
-
- Use bold, contrasting colors
- Include rounded, friendly shapes
- Create dynamic, engaging layouts
- Add implied motion and energy
- Keep typography large and readable
-
-### Don't
-
- Use sharp, aggressive shapes
- Apply dark or somber colors
- Create static, boring layouts
- Overload with too many elements
- Make it look unprofessional
- Add slide numbers, footers, or logos
-
-## Best For
-
-Creative pitches, educational workshops, training materials, community presentations, product launches, children's content, team building, startup culture
@@ -0,0 +1,73 @@
+# scientific
+
+Educational scientific illustration style for pathways, processes, and technical diagrams
+
+## Design Aesthetic
+
+Academic scientific illustration aesthetic for biological pathways, chemical processes, and technical systems. Clean, precise diagrams with proper labeling and clear visual flow. Educational clarity with professional polish. Think textbook quality illustrations and academic journal figures.
+
+## Background
+
+- Color: Off-White (#FAFAFA) or Light Blue-Gray (#F0F4F8)
+- Texture: None or very subtle paper grain for print feel
+
+## Typography
+
+### Primary Font (Headlines)
+
+Clean serif font (Times New Roman style) for formal academic feel. Bold weight for main titles. Professional, authoritative presence.
+
+### Secondary Font (Labels)
+
+Sans-serif for diagram labels and annotations. Clear, readable at small sizes. Consistent sizing for hierarchy.
+
+### Body Font
+
+Serif for body paragraphs, sans-serif for bullet points and lists. Academic publication styling.
+
+## Color Palette
+
+| Role | Color | Hex | Usage |
+|------|-------|-----|-------|
+| Background | Off-White | #FAFAFA | Primary background |
+| Primary Text | Dark Slate | #1E293B | Headlines, body |
+| Label Text | Medium Gray | #475569 | Annotations |
+| Pathway 1 | Teal | #0D9488 | Primary pathway |
+| Pathway 2 | Blue | #3B82F6 | Secondary pathway |
+| Pathway 3 | Purple | #8B5CF6 | Tertiary pathway |
+| Membrane | Amber | #F59E0B | Biological membranes |
+| Alert | Red | #EF4444 | Key molecules, emphasis |
+| Positive | Green | #22C55E | Products, outputs |
+
+## Visual Elements
+
+- Horizontal membrane or structure bases
+- Labeled modular components with distinct colors
+- Flow arrows (electron, proton, molecule movement)
+- Chemical formulas and molecular notation
+- Cross-section and pathway diagrams
+- Numbered step sequences
+- Key molecule callouts
+- Process summary boxes
+
+## Style Rules
+
+### Do
+
+- Use precise, consistent line weights
+- Label all components clearly
+- Show directional flow with arrows
+- Include chemical/molecular notation where relevant
+- Create clear numbered sequences
+
+### Don't
+
+- Use decorative illustrations
+- Create imprecise or artistic diagrams
+- Omit important labels
+- Use inconsistent visual language
+- Add slide numbers, footers, or logos
+
+## Best For
+
+Biology lectures, chemistry presentations, medical education, research presentations, academic papers, scientific conferences, textbook illustrations, process documentation
@@ -1,67 +0,0 @@
-# storytelling
-
-Cinematic narrative style with full-bleed visuals and emotional impact
-
-## Design Aesthetic
-
-Cinematic, full-bleed imagery that creates emotional connection. Story-driven compositions that guide the viewer through a narrative arc. Each slide is a scene in a larger story. Photography and illustration work together to create atmosphere.
-
-## Background
-
- Color: Varies by mood - dark for drama (#0F0F0F), warm for comfort (#FDF8F3)
- Texture: Photographic or illustrated backgrounds, subtle vignetting
-
-## Typography
-
-### Primary Font (Headlines)
-
-Elegant serif like Playfair Display, Libre Baskerville, or editorial serif. Large, expressive headlines that complement imagery. Can use italic for emotional emphasis.
-
-### Secondary Font (Body)
-
-Clean sans-serif for contrast and readability. Light weight to not compete with imagery. White or dark depending on background.
-
-## Color Palette
-
-| Role | Color | Hex | Usage |
-|------|-------|-----|-------|
-| Background Dark | Near Black | #0F0F0F | Dramatic scenes |
-| Background Warm | Warm Cream | #FDF8F3 | Comfortable scenes |
-| Primary Text Light | Off-White | #FAFAFA | Text on dark |
-| Primary Text Dark | Deep Charcoal | #1F1F1F | Text on light |
-| Accent Warm | Golden | #D4A853 | Warm highlights |
-| Accent Cool | Teal | #2DD4BF | Cool accents |
-| Overlay | Black 40% | rgba(0,0,0,0.4) | Text legibility |
-
-## Visual Elements
-
- Full-bleed photographic or illustrated backgrounds
- Cinematic aspect compositions (rule of thirds)
- Text overlays with subtle background darkening
- Atmospheric lighting and mood
- People and human elements when possible
- Emotional color grading
- Subtle motion blur or depth of field effects
- Vignetting to draw focus
-
-## Style Rules
-
-### Do
-
- Create emotional connection through imagery
- Use photography or illustration as primary element
- Let visuals tell the story
- Create consistent mood throughout deck
- Use text sparingly - images speak
-
-### Don't
-
- Use stock photo aesthetic
- Crowd slides with text
- Mix conflicting visual moods
- Use clip art or basic shapes
- Add slide numbers, footers, or logos
-
-## Best For
-
-Case studies, brand stories, narrative presentations, emotional pitches, documentary-style content, origin stories, customer journeys
@@ -0,0 +1,73 @@
+# vintage
+
+Vintage aged-paper aesthetic for historical and expedition-style presentations
+
+## Design Aesthetic
+
+Nostalgic vintage aesthetic with aged paper textures and historical document styling. Think explorer's journals, antique maps, and museum exhibits. Rich warm tones with weathered textures. Evokes discovery, heritage, and timeless knowledge.
+
+## Background
+
+- Color: Aged Parchment (#F5E6D3) or Sepia Cream (#FFF8DC)
+- Texture: Heavy aged paper texture with subtle creases, coffee stains, and worn edges
+
+## Typography
+
+### Primary Font (Headlines)
+
+Classic serif with historical character (Garamond, Baskerville, or similar). Elegant, authoritative, timeless. May include decorative flourishes.
+
+### Secondary Font (Labels)
+
+Condensed serif or clean sans-serif for map labels and annotations. Period-appropriate styling. Consistent with vintage aesthetic.
+
+### Body Font
+
+Readable serif for longer text. Traditional book typography. Comfortable reading experience.
+
+## Color Palette
+
+| Role | Color | Hex | Usage |
+|------|-------|-----|-------|
+| Background | Aged Parchment | #F5E6D3 | Primary background |
+| Alt Background | Sepia Cream | #FFF8DC | Secondary areas |
+| Primary Text | Dark Brown | #3D2914 | Headlines, body |
+| Secondary Text | Medium Brown | #6B4423 | Annotations |
+| Accent 1 | Forest Green | #2D5A3D | Maps, nature |
+| Accent 2 | Navy Blue | #1E3A5F | Ocean, lines |
+| Accent 3 | Burgundy | #722F37 | Emphasis, borders |
+| Accent 4 | Gold | #C9A227 | Highlights, compass |
+| Ink | Sepia Black | #3D3D3D | Fine details |
+
+## Visual Elements
+
+- Antique maps with route lines and landmarks
+- Compass roses and nautical elements
+- Expedition ship or vehicle illustrations
+- Specimen drawings (flora, fauna, fossils)
+- Handwritten-style annotations
+- Rope, leather, and brass decorative motifs
+- Wave and terrain texture patterns
+- Vintage photograph-style image frames
+
+## Style Rules
+
+### Do
+
+- Apply consistent aged texture throughout
+- Use period-appropriate visual language
+- Include map and journey elements where relevant
+- Create layered collage compositions
+- Maintain warm sepia-toned palette
+
+### Don't
+
+- Use modern digital styling
+- Create crisp clean edges
+- Use cold or bright colors
+- Add contemporary elements
+- Add slide numbers, footers, or logos
+
+## Best For
+
+Historical presentations, travel and exploration content, museum exhibits, heritage brand storytelling, biography presentations, scientific discovery narratives, educational history content
@@ -1,68 +0,0 @@
-# warm
-
-Soft gradients and wellness aesthetic with approachable, friendly feeling
-
-## Design Aesthetic
-
-Soft, calming gradients with rounded shapes. Wellness and lifestyle aesthetic that feels approachable and nurturing. Organic flowing forms balanced with clean typography. Warmth and comfort in every element.
-
-## Background
-
- Color: Soft gradient from Warm Peach (#FDF4F0) to Soft Lavender (#F5F0FF)
- Texture: Subtle organic shapes, soft blurred elements
-
-## Typography
-
-### Primary Font (Headlines)
-
-Rounded sans-serif like Nunito, Poppins, or Quicksand. Medium to semi-bold weight. Friendly, approachable letterforms. Generous spacing.
-
-### Secondary Font (Body)
-
-Same family in regular weight, or complementary rounded sans-serif. Comfortable reading size. Warm, inviting tone.
-
-## Color Palette
-
-| Role | Color | Hex | Usage |
-|------|-------|-----|-------|
-| Background Start | Warm Peach | #FDF4F0 | Gradient start |
-| Background End | Soft Lavender | #F5F0FF | Gradient end |
-| Primary Text | Warm Charcoal | #3D3D3D | Headlines, body |
-| Secondary Text | Soft Gray | #6B6B6B | Supporting text |
-| Accent 1 | Coral | #FF8A80 | Primary highlights |
-| Accent 2 | Soft Teal | #80CBC4 | Balance, growth |
-| Accent 3 | Lavender | #B39DDB | Calm, premium |
-| Accent 4 | Soft Yellow | #FFE082 | Energy, joy |
-
-## Visual Elements
-
- Soft gradient backgrounds (avoid harsh transitions)
- Organic blob shapes with blurred edges
- Rounded rectangles and pill shapes
- Soft drop shadows (large blur, low opacity)
- Simple line illustrations with rounded endpoints
- Abstract organic patterns
- Floating elements with gentle motion implied
- Layered translucent shapes
-
-## Style Rules
-
-### Do
-
- Use soft, gentle color transitions
- Keep all corners rounded
- Create sense of calm and space
- Use organic, flowing shapes
- Layer elements with transparency
-
-### Don't
-
- Use sharp corners or harsh lines
- Create high-contrast jarring combinations
- Use dark or aggressive colors
- Add busy or complex illustrations
- Add slide numbers, footers, or logos
-
-## Best For
-
-Wellness content, personal development, lifestyle brands, health and fitness, mindfulness, self-care, coaching, therapy, HR presentations
@@ -0,0 +1,68 @@
+# watercolor
+
+Soft watercolor illustration style with hand-painted textures and natural warmth
+
+## Design Aesthetic
+
+Gentle watercolor aesthetic with visible brush strokes and natural color bleeding. Hand-painted feel with soft edges and organic shapes. Warm, approachable, and artistically refined. Combines artistic expression with clear information delivery.
+
+## Background
+
+- Color: Warm Off-White (#FAF8F0) or Soft Cream (#FFF9E6)
+- Texture: Subtle watercolor paper texture with visible grain
+
+## Typography
+
+### Primary Font (Headlines)
+
+Elegant handwritten or brush script for titles. Organic letterforms with natural variation. Warm, personal feeling. May appear as actual hand-painted lettering.
+
+### Secondary Font (Body)
+
+Clean rounded sans-serif or casual handwriting style. Readable at smaller sizes. Maintains artistic cohesion while staying functional.
+
+## Color Palette
+
+| Role | Color | Hex | Usage |
+|------|-------|-----|-------|
+| Background | Warm Off-White | #FAF8F0 | Primary background |
+| Primary Text | Warm Charcoal | #3D3D3D | Headlines, body |
+| Accent 1 | Soft Coral | #F4A261 | Primary warmth |
+| Accent 2 | Dusty Rose | #E8A0A0 | Secondary warmth |
+| Accent 3 | Sage Green | #87A96B | Nature, growth |
+| Accent 4 | Sky Blue | #7EC8E3 | Water, calm |
+| Accent 5 | Soft Lavender | #C5B4E3 | Accent, creativity |
+| Wash | Pale Yellow | #FFF3C4 | Background washes |
+
+## Visual Elements
+
+- Watercolor washes as section backgrounds
+- Illustrated icons with visible brush strokes
+- Natural elements: leaves, bubbles, flowers
+- Color bleeds and soft edges on all elements
+- Hand-drawn arrows and connection lines
+- Labeled diagrams with watercolor fills
+- Small expressive character illustrations
+- Decorative nature accents scattered thoughtfully
+
+## Style Rules
+
+### Do
+
+- Allow color to bleed beyond sharp edges
+- Use visible brush stroke textures
+- Create soft, organic shapes
+- Include hand-drawn quality in all elements
+- Maintain warm, inviting color palette
+
+### Don't
+
+- Use sharp geometric shapes
+- Create hard edges or digital precision
+- Use cold or stark colors
+- Add photographic elements
+- Add slide numbers, footers, or logos
+
+## Best For
+
+Lifestyle content, wellness presentations, travel guides, food and cooking content, personal stories, creative workshops, artistic portfolios, warm educational content
@@ -76,264 +76,150 @@ Detailed style definitions: `references/styles/<style>.md`

 Detailed layout definitions: `references/layouts/<layout>.md`

-## Auto Style Selection
+## Auto Selection

-When no `--style` is specified, analyze content to select:
+| Content Signals | Style | Layout |
+|-----------------|-------|--------|
+| Beauty, fashion, cute, girl, pink | `cute` | sparse/balanced |
+| Health, nature, clean, fresh, organic | `fresh` | balanced/flow |
+| Tech, AI, code, digital, app, tool | `tech` | dense/list |
+| Life, story, emotion, feeling, warm | `warm` | balanced |
+| Warning, important, must, critical | `bold` | list/comparison |
+| Professional, business, elegant, simple | `minimal` | sparse/balanced |
+| Classic, vintage, old, traditional | `retro` | balanced |
+| Fun, exciting, wow, amazing | `pop` | sparse/list |
+| Knowledge, concept, productivity, SaaS | `notion` | dense/list |

-| Content Signals | Selected Style |
-|----------------|----------------|
-| Beauty, fashion, cute, girl, pink | `cute` |
-| Health, nature, clean, fresh, organic | `fresh` |
-| Tech, AI, code, digital, app, tool | `tech` |
-| Life, story, emotion, feeling, warm | `warm` |
-| Warning, important, must, critical | `bold` |
-| Professional, business, elegant, simple | `minimal` |
-| Classic, vintage, old, traditional | `retro` |
-| Fun, exciting, wow, amazing | `pop` |
-| Knowledge, concept, productivity, SaaS, notion | `notion` |
-
-## Auto Layout Selection
-
-When no `--layout` is specified, analyze content structure to select:
-
-| Content Signals | Selected Layout |
-|----------------|-----------------|
-| Single quote, one key point, cover | `sparse` |
-| 3-4 points, explanation, tutorial | `balanced` |
-| 5+ points, summary, cheat sheet, 干货 | `dense` |
-| Numbered items, top N, checklist, steps | `list` |
-| vs, compare, before/after, pros/cons | `comparison` |
-| Process, flow, timeline, steps with order | `flow` |
-
-**Layout by Position**:
-| Position | Recommended Layout |
-|----------|-------------------|
-| Cover | `sparse` |
-| Content | `balanced` or content-appropriate |
-| Ending | `sparse` or `balanced` |
-
-## File Management
-
-### With Article Path
-
-Save to `xhs-images/` subdirectory in the same folder as the article:
+## File Structure

 ```
-posts/ai-future/
-├── article.md
-└── xhs-images/
-    ├── outline.md
-    ├── prompts/
-    │   ├── 01-cover.md
-    │   ├── 02-content-1.md
-    │   └── ...
-    ├── 01-cover.png
-    ├── 02-content-1.png
-    └── 03-ending.png
+[target]/
+├── source.md                       # Source content (if pasted)
+├── analysis.md                     # Deep analysis results
+├── outline-style-[slug].md         # Variant A (e.g., outline-style-tech.md)
+├── outline-style-[slug].md         # Variant B (e.g., outline-style-notion.md)
+├── outline-style-[slug].md         # Variant C (e.g., outline-style-minimal.md)
+├── outline.md                      # Final selected
+├── prompts/
+│   ├── 01-cover-[slug].md
+│   ├── 02-content-[slug].md
+│   └── ...
+├── 01-cover-[slug].png
+├── 02-content-[slug].png
+└── NN-ending-[slug].png
 ```

-### Without Article Path (Pasted Content)
+**Target directory**:
+- With source path: `[source-dir]/[source-name-no-ext]/xhs-images/`
+  - Example: `/tests-data/article.md` → `/tests-data/article/xhs-images/`
+- Without source: `./xhs-images/[topic-slug]/`

-Save to `xhs-outputs/YYYY-MM-DD/[topic-slug]/`:
-
-```
-xhs-outputs/
-└── 2026-01-13/
-    └── ai-agent-guide/
-        ├── source.md           # Saved pasted content
-        ├── outline.md
-        ├── prompts/
-        │   ├── 01-cover.md
-        │   └── ...
-        ├── 01-cover.png
-        └── 02-ending.png
-```
+**Directory backup**:
+- If target directory exists, rename existing to `<dirname>-backup-YYYYMMDD-HHMMSS`

 ## Workflow

-### Step 1: Analyze Content & Select Style/Layout
+### Step 1: Analyze Content → `analysis.md`

+Read source content, save it if needed, and perform deep analysis.
+
+**Actions**:
 1. **Save source content** (if not already a file):
   - If user provides a file path: use as-is
   - If user pastes content: save to `source.md` in target directory
-2. Read content
-3. If `--style` specified, use that style; otherwise auto-select 3 candidates
-4. If `--layout` specified, use that layout; otherwise auto-select per image
-5. **Language detection**:
-   - Detect **source language** from content
-   - Detect **user language** from conversation context
-   - Note if source_language ≠ user_language (will ask in Step 4)
-6. Determine image count based on content complexity:
+2. Read source content
+3. **Deep analysis** following `references/analysis-framework.md`:
+   - Content type classification (种草/干货/测评/教程/避坑...)
+   - Hook analysis (爆款标题潜力)
+   - Target audience identification
+   - Engagement potential (收藏/分享/评论)
+   - Visual opportunity mapping
+   - Swipe flow design
+4. Detect source language
+5. Determine recommended image count (2-10)
+6. Select 3 style+layout combinations
+7. **Save to `analysis.md`**

-| Content Type | Image Count |
-|-------------|-------------|
-| Simple opinion / single topic | 2-3 |
-| Medium complexity / tutorial | 4-6 |
-| Deep dive / multi-dimensional | 7-10 |
+### Step 2: Generate 3 Outline Variants

-**Note**: Layout can vary per image in a series. Cover typically uses `sparse`, content pages use `balanced`/`dense`/`list` as appropriate.
+Based on analysis, create three distinct style variants.

-### Step 2: Generate Outline
+**For each variant**:
+1. **Generate outline** (`outline-style-[slug].md`):
+   - YAML front matter with style, layout, image_count
+   - Cover design with hook
+   - Each image: layout, core message, text content, visual concept
+   - **Written in user's preferred language**
+   - Reference: `references/outline-template.md`

-Plan for each image with style and layout specifications:
+| Variant | Selection Logic | Example Filename |
+|---------|-----------------|------------------|
+| A | Primary recommendation | `outline-style-tech.md` |
+| B | Alternative style | `outline-style-notion.md` |
+| C | Different audience/mood | `outline-style-minimal.md` |

-```markdown
-# Xiaohongshu Infographic Series Outline
+**All variants are preserved after selection for reference.**

-**Topic**: [topic description]
-**Style**: [selected style]
-**Default Layout**: [selected layout or "varies"]
-**Image Count**: N
-**Generated**: YYYY-MM-DD HH:mm
-
---
-
-## Image 1 of N
-
-**Position**: Cover
-**Layout**: sparse
-**Core Message**: [one-liner]
-**Filename**: 01-cover.png
-
-**Text Content**:
- Title: xxx
- Subtitle: xxx
-
-**Visual Concept**: [style + layout appropriate description]
-
---
-
-## Image 2 of N
-
-**Position**: Content
-**Layout**: [balanced/dense/list/comparison/flow]
-**Core Message**: [one-liner]
-**Filename**: 02-xxx.png
-
-**Text Content**:
- Title: xxx
- Points: [list based on layout density]
-
-**Visual Concept**: [description matching style + layout]
-
---
-...
-```
-
-### Step 3: Save Outline
-
-Save outline as `outline.md`.
-
-### Step 4: Review & Confirm
-
-**Purpose**: Let user confirm all options in a single step before image generation.
+### Step 3: User Confirms All Options

 **IMPORTANT**: Present ALL options in a single confirmation step using AskUserQuestion. Do NOT interrupt workflow with multiple separate confirmations.

-1. **Generate 3 style variants** (if style not specified):
-   - Analyze content to select 3 most suitable styles
-   - Generate complete outline for each style variant
-   - Save as `outline-{style}.md` (e.g., `outline-cute.md`, `outline-notion.md`, `outline-tech.md`)
+**Determine which questions to ask**:

-2. **Determine which questions to ask**:
+| Question | When to Ask |
+|----------|-------------|
+| Style variant | Always (required) |
+| Default layout | Only if user might want to override |
+| Language | Only if `source_language ≠ user_language` |

-   | Question | When to Ask |
-   |----------|-------------|
-   | Style variant | Always (required) |
-   | Default layout | Always (offer common options) |
-   | Language | Only if `source_language ≠ user_language` |
+**Language handling**:
+- If source language = user language: Just inform user (e.g., "Images will be in Chinese")
+- If different: Ask which language to use

-3. **Present options** (use AskUserQuestion with all applicable questions):
+**AskUserQuestion format**:

-   **Question 1 (Style)** - always:
-   - Style A (recommended): [style name] - [brief description]
-   - Style B: [style name] - [brief description]
-   - Style C: [style name] - [brief description]
-   - Custom: Provide custom style reference
+```
+Question 1 (Style): Which style variant?
+- A: tech + dense (Recommended) - 专业科技感，适合干货
+- B: notion + list - 清爽知识卡片
+- C: minimal + balanced - 简约高端风格
+- Custom: 自定义风格描述

-   **Question 2 (Layout)** - always:
-   - sparse (Recommended for cover) - minimal info, maximum impact
-   - balanced - standard 3-4 points
-   - dense - high info density, knowledge cards
-   - list / comparison / flow - special formats
+Question 2 (Layout) - only if relevant:
+- Keep variant default (Recommended)
+- sparse / balanced / dense / list / comparison / flow

-   **Question 3 (Language)** - only if source ≠ user language:
-   - [Source language] (matches content)
-   - [User language] (your preference)
-
-   **Language handling**:
-   - If source language = user language: Just inform user (e.g., "Images will be in Chinese")
-   - If different: Ask which language to use
-
-4. **Apply selection**:
-   - Copy selected `outline-{style}.md` to `outline.md`
-   - If custom style provided, generate new outline with that style
-   - If different language selected, regenerate outline in that language
-   - User may edit `outline.md` directly for fine-tuning
-   - If modified, reload outline before proceeding
-
-5. **Proceed only after explicit user confirmation**
-
-### Step 5: Generate Images One by One
-
-For each image, create a prompt file with style and layout specifications.
-
-**Prompt Format**:
-
-```markdown
-Infographic theme: [topic]
-Style: [style name]
-Layout: [layout name]
-Position: [cover/content/ending]
-
-Visual composition:
- Main visual: [style-appropriate description]
- Arrangement: [layout-specific structure]
- Decorative elements: [style-specific decorations]
-
-Color scheme:
- Primary: [style primary color]
- Background: [style background color]
- Accent: [style accent color]
-
-Text content:
- Title: 「xxx」(large, prominent)
- Key points: [based on layout density]
-
-Layout instructions: [layout-specific guidance]
-Style notes: [style-specific characteristics]
+Question 3 (Language) - only if mismatch:
+- 中文 (匹配原文)
+- English (your preference)
 ```

-**Layout-Specific Instructions**:
+**After confirmation**:
+1. Copy selected `outline-style-[slug].md` → `outline.md`
+2. Update YAML front matter with confirmed options
+3. If custom style: regenerate outline with that style
+4. User may edit `outline.md` directly for fine-tuning

-| Layout | Arrangement Instructions |
-|--------|-------------------------|
-| `sparse` | Single focal point centered, 1-2 text elements, maximum breathing room |
-| `balanced` | Title at top, 3-4 points in clear sections, moderate spacing |
-| `dense` | Grid or multi-section layout, 5-8 points, compact but organized |
-| `list` | Vertical numbered/bulleted list, consistent item spacing, clear hierarchy |
-| `comparison` | Two-column split, clear divider, mirrored structure left/right |
-| `flow` | Horizontal or vertical flow with arrows, connected nodes/steps |
+### Step 4: Generate Images
+
+With confirmed outline + style + layout:
+
+**For each image (cover + content + ending)**:
+1. Save prompt to `prompts/NN-{type}-[slug].md` (in user's preferred language)
+2. Generate image using confirmed style and layout
+3. Report progress after each generation

 **Image Generation Skill Selection**:
-1. Check available image generation skills
-2. If multiple skills available, ask user to choose
+- Check available image generation skills
+- If multiple skills available, ask user preference

 **Session Management**:
-If the image generation skill supports `--sessionId`:
-1. Generate a unique session ID at the start (e.g., `xhs-{topic-slug}-{timestamp}`)
-2. Use the same session ID for all images in the series
-3. This ensures style consistency across all generated images
+If image generation skill supports `--sessionId`:
+1. Generate unique session ID: `xhs-{topic-slug}-{timestamp}`
+2. Use same session ID for all images
+3. Ensures visual consistency across generated images

-**Generation Flow**:
-1. Call selected image generation skill with prompt file, output path, and session ID
-2. Confirm generation success
-3. Report progress: "Generated X/N"
-4. Continue to next
-
-**All prompts are written in the user's confirmed language preference.**
-
-### Step 6: Completion Report
+### Step 5: Completion Report

 ```
 Xiaohongshu Infographic Series Complete!
@@ -344,21 +230,48 @@ Layout: [layout name or "varies"]
 Location: [directory path]
 Images: N total

- 01-cover.png ✓ Cover (sparse)
- 02-content-1.png ✓ Content (balanced)
- 03-content-2.png ✓ Content (dense)
- 04-ending.png ✓ Ending (sparse)
+✓ analysis.md
+✓ outline-style-tech.md
+✓ outline-style-notion.md
+✓ outline-style-minimal.md
+✓ outline.md (selected: tech + dense)

-Outline: outline.md
+Files:
+- 01-cover-[slug].png ✓ Cover (sparse)
+- 02-content-[slug].png ✓ Content (balanced)
+- 03-content-[slug].png ✓ Content (dense)
+- 04-ending-[slug].png ✓ Ending (sparse)
 ```

+## Image Modification
+
+### Edit Single Image
+
+1. Identify image to edit (e.g., `03-content-chatgpt.png`)
+2. Update prompt in `prompts/03-content-chatgpt.md` if needed
+3. Regenerate image using same session ID
+
+### Add New Image
+
+1. Specify insertion position (e.g., after image 3)
+2. Create new prompt with appropriate slug
+3. Generate new image
+4. **Renumber files**: All subsequent images increment NN by 1
+5. Update `outline.md` with new image entry
+
+### Delete Image
+
+1. Remove image file and prompt file
+2. **Renumber files**: All subsequent images decrement NN by 1
+3. Update `outline.md` to remove image entry
+
 ## Content Breakdown Principles

-1. **Cover (Image 1)**: Strong visual impact, core title, attention hook → `sparse` layout
-2. **Content (Middle)**: Core points per image, density varies by content → `balanced`/`dense`/`list`/`comparison`/`flow`
-3. **Ending (Last)**: Summary / call-to-action / memorable quote → `sparse` or `balanced`
+1. **Cover (Image 1)**: Hook + visual impact → `sparse` layout
+2. **Content (Middle)**: Core value per image → `balanced`/`dense`/`list`/`comparison`/`flow`
+3. **Ending (Last)**: CTA / summary → `sparse` or `balanced`

-**Style × Layout Matrix** (recommended combinations):
+**Style × Layout Matrix** (✓✓ = highly recommended, ✓ = works well):

 | | sparse | balanced | dense | list | comparison | flow |
 |---|:---:|:---:|:---:|:---:|:---:|:---:|
@@ -372,13 +285,29 @@ Outline: outline.md
 | pop | ✓✓ | ✓✓ | ✓ | ✓✓ | ✓✓ | ✓ |
 | notion | ✓✓ | ✓✓ | ✓✓ | ✓✓ | ✓✓ | ✓✓ |

-✓✓ = highly recommended, ✓ = works well
+## References
+
+Detailed templates and guidelines in `references/` directory:
+- `analysis-framework.md` - XHS-specific content analysis
+- `outline-template.md` - Outline format and examples
+- `styles/<style>.md` - Detailed style definitions
+- `layouts/<layout>.md` - Detailed layout definitions
+- `base-prompt.md` - Base prompt template

 ## Notes

 - Image generation typically takes 10-30 seconds per image
 - Auto-retry once on generation failure
 - Use cartoon alternatives for sensitive public figures
- Prompts written in user's confirmed language preference
- Text on images uses confirmed language
- Maintain selected style consistency across all images in series
+- All prompts and text use confirmed language preference
+- Maintain style consistency across all images in series
+
+## Extension Support
+
+Custom styles and configurations via EXTEND.md.
+
+**Check paths** (priority order):
+1. `.baoyu-skills/baoyu-xhs-images/EXTEND.md` (project)
+2. `~/.baoyu-skills/baoyu-xhs-images/EXTEND.md` (user)
+
+If found, load before Step 1. Extension content overrides defaults.
@@ -0,0 +1,198 @@
+# Xiaohongshu Content Analysis Framework
+
+Deep analysis framework tailored for Xiaohongshu's unique engagement patterns.
+
+## Purpose
+
+Before creating infographics, thoroughly analyze the source material to:
+- Maximize hook power and swipe motivation
+- Identify save-worthy and share-worthy elements
+- Plan the visual narrative arc
+- Match content to optimal style/layout
+
+## Platform Characteristics
+
+Unlike other platforms, Xiaohongshu content must prioritize:
+- **Hook Power**: First image decides 90% of engagement
+- **Swipe Motivation**: Each image must compel users to continue
+- **Save Value**: Content worth bookmarking for later
+- **Share Triggers**: Emotional resonance that drives sharing
+
+## Analysis Dimensions
+
+### 1. Content Type Classification
+
+| Type | Characteristics | Best Style | Best Layout |
+|------|----------------|------------|-------------|
+| 种草/安利 | Product recommendation, benefits focus | cute/fresh | balanced/list |
+| 干货分享 | Knowledge, tips, how-to | notion/tech | dense/list |
+| 个人故事 | Personal experience, emotional | warm | balanced |
+| 测评对比 | Review, comparison, pros/cons | tech/bold | comparison |
+| 教程步骤 | Step-by-step guide | fresh/notion | flow/list |
+| 避坑指南 | Warnings, mistakes to avoid | bold | list/comparison |
+| 清单合集 | Collections, recommendations | cute/minimal | list/dense |
+
+### 2. Hook Analysis (爆款标题潜力)
+
+Evaluate title/hook potential using these patterns:
+
+**Hook Types**:
+- **数字钩子**: "5个方法", "3分钟学会", "99%的人不知道"
+- **痛点钩子**: "踩过的坑", "后悔没早知道", "别再..."
+- **好奇钩子**: "原来...", "竟然...", "没想到..."
+- **利益钩子**: "省钱", "变美", "效率翻倍"
+- **身份钩子**: "打工人必看", "学生党", "新手妈妈"
+
+**Rating Scale**:
+- ⭐⭐⭐⭐⭐ (5/5): Multiple strong hooks combined
+- ⭐⭐⭐⭐ (4/5): Clear hook with room for enhancement
+- ⭐⭐⭐ (3/5): Basic hook, needs strengthening
+- ⭐⭐ (2/5): Weak hook, requires significant improvement
+- ⭐ (1/5): No clear hook
+
+### 3. Target Audience (用户画像)
+
+| Audience | Interests | Preferred Style | Content Focus |
+|----------|-----------|-----------------|---------------|
+| 学生党 | 省钱、学习、校园 | cute/fresh | 平价、教程、学习方法 |
+| 打工人 | 效率、职场、减压 | minimal/tech | 工具、技巧、摸鱼 |
+| 宝妈 | 育儿、家居、省心 | warm/fresh | 实用、安全、经验 |
+| 精致女孩 | 美妆、穿搭、仪式感 | cute/retro | 好看、氛围、品质 |
+| 技术宅 | 工具、效率、极客 | tech/notion | 深度、专业、新奇 |
+| 美食爱好者 | 探店、食谱、测评 | warm/pop | 好吃、简单、颜值 |
+| 旅行达人 | 攻略、打卡、小众 | fresh/retro | 省钱、避坑、拍照 |
+
+### 4. Engagement Potential
+
+**Save Value (收藏价值)**:
+- Is it reference material? ✓ High save potential
+- Is it a checklist or list? ✓ High save potential
+- Is it a tutorial? ✓ High save potential
+- Is it time-sensitive news? ✗ Low save potential
+
+**Share Triggers (分享冲动)**:
+- "我朋友也需要看这个" → High share potential
+- "这说的就是我" → Identity resonance
+- "太有用了必须分享" → Utility sharing
+- "笑死，给朋友看看" → Entertainment sharing
+
+**Comment Inducement (评论诱导)**:
+- Open-ended questions: "你是哪种类型？"
+- Experience sharing: "评论区说说你的经历"
+- Debate triggers: "你觉得呢？"
+- Help requests: "有更好的推荐吗？"
+
+**Interaction Design (互动设计)**:
+- Polls: "A还是B？"
+- Challenges: "你能做到几个？"
+- Tags: "@你那个需要的朋友"
+
+### 5. Visual Opportunity Map
+
+| Content Element | Visual Treatment | Example |
+|-----------------|------------------|---------|
+| 数据/统计 | Highlighted numbers, simple charts | "节省80%时间" 大字突出 |
+| 对比 | Before/after, side-by-side | 左右分屏对比图 |
+| 步骤 | Numbered flow, arrows | 1→2→3 流程图 |
+| 清单 | Checklist with icons | ✓/✗ 列表配图标 |
+| 情感 | Character expressions, scenes | 卡通人物表情包 |
+| 产品 | Product showcase, lifestyle | 产品实拍+使用场景 |
+| 引用 | Quote cards, speech bubbles | 金句卡片设计 |
+
+### 6. Swipe Flow Design
+
+Plan the narrative arc across images:
+
+| Position | Purpose | Hook Strategy |
+|----------|---------|---------------|
+| **Cover (封面)** | Stop scrolling | 最强视觉冲击 + 核心标题 |
+| **Setup (铺垫)** | Build context | 痛点共鸣 / 好奇心 |
+| **Core (核心)** | Deliver value | 干货内容，每页1-2个要点 |
+| **Payoff (收获)** | Practical takeaway | 可执行的行动建议 |
+| **Ending (结尾)** | Drive action | CTA + 互动引导 |
+
+**Swipe Motivation Between Images**:
+- End each image with a hook for the next
+- Use "下一页更精彩" type transitions
+- Create information gaps that require swiping
+- Build anticipation through numbering ("第3个最重要")
+
+## Output Format
+
+Analysis results should be saved to `analysis.md` with:
+
+```yaml
+---
+title: "5个让你效率翻倍的AI工具"
+topic: 干货分享
+content_type: 工具推荐
+source_language: zh
+user_language: zh
+recommended_image_count: 6
+---
+
+## Target Audience
+
+- **Primary**: 打工人、自由职业者 - 追求效率提升
+- **Secondary**: 学生党 - 写论文、做作业需要
+- **Tertiary**: 内容创作者 - 需要AI辅助
+
+## Hook Analysis
+
+**标题钩子评分**: ⭐⭐⭐⭐ (4/5)
+- ✓ 数字钩子: "5个"
+- ✓ 利益钩子: "效率翻倍"
+- △ 可增强: 加入身份标签 "打工人必看"
+
+**建议优化**:
+- 原标题: "5个让你效率翻倍的AI工具"
+- 优化: "打工人必看！5个让我效率翻倍的AI神器"
+
+## Value Proposition
+
+**为什么用户要看？**
+1. **实用价值**: 直接可用的工具推荐
+2. **省时省力**: 不用自己筛选，直接抄作业
+3. **FOMO**: 别人都在用，我不能落后
+
+**收藏理由**: 工具清单，需要时可以回来查
+
+## Engagement Design
+
+- **互动点**: 结尾问"你最常用哪个？"
+- **评论诱导**: "还有什么好用的工具评论区分享"
+- **分享触发**: 打工人会转发给同事
+
+## Content Signals
+
+- "AI工具" → tech + dense
+- "效率" → notion + list
+- "干货" → minimal + dense
+
+## Swipe Flow
+
+| Image | Position | Purpose | Hook |
+|-------|----------|---------|------|
+| 1 | Cover | 吸引停留 | 标题+视觉冲击 |
+| 2 | Setup | 建立共鸣 | 为什么需要AI工具 |
+| 3-5 | Core | 核心价值 | 每页1-2个工具详解 |
+| 6 | Ending | 行动引导 | 总结+互动引导 |
+
+## Recommended Approaches
+
+1. **Tech + Dense** - 专业科技感，适合干货分享 (recommended)
+2. **Notion + List** - 清爽知识卡片风格
+3. **Minimal + Balanced** - 简约高端，适合职场人群
+```
+
+## Analysis Checklist
+
+Before proceeding to outline generation:
+
+- [ ] Can I identify the content type?
+- [ ] Is the hook strong enough? (≥3 stars)
+- [ ] Do I know the primary audience?
+- [ ] Have I identified save/share triggers?
+- [ ] Are there clear visual opportunities?
+- [ ] Is the swipe flow planned?
+- [ ] Have I selected 3 style+layout combinations?
@@ -0,0 +1,228 @@
+# Xiaohongshu Outline Template
+
+Template for generating infographic series outlines.
+
+## File Naming
+
+Outline files use style slug in the name:
+- `outline-style-tech.md` - Tech style variant
+- `outline-style-notion.md` - Notion style variant
+- `outline-style-minimal.md` - Minimal style variant
+- `outline.md` - Final selected (copied from chosen variant)
+
+## Image File Naming
+
+Images use meaningful slugs for readability:
+```
+NN-{type}-[slug].png
+NN-{type}-[slug].md (in prompts/)
+```
+
+| Type | Usage |
+|------|-------|
+| `cover` | First image (cover) |
+| `content` | Middle content images |
+| `ending` | Last image |
+
+**Examples**:
+- `01-cover-ai-tools.png`
+- `02-content-why-ai.png`
+- `03-content-chatgpt.png`
+- `04-content-midjourney.png`
+- `05-content-notion-ai.png`
+- `06-ending-summary.png`
+
+**Slug rules**:
+- Derived from image content (kebab-case)
+- Must be unique within the series
+- Keep short but descriptive (2-4 words)
+
+## Outline Format
+
+```markdown
+# Xiaohongshu Infographic Series Outline
+
+---
+style: tech
+default_layout: dense
+image_count: 6
+generated: YYYY-MM-DD HH:mm
+---
+
+## Image 1 of 6
+
+**Position**: Cover
+**Layout**: sparse
+**Hook**: 打工人必看！
+**Slug**: ai-tools
+**Filename**: 01-cover-ai-tools.png
+
+**Text Content**:
+- Title: 「5个AI神器让你效率翻倍」
+- Subtitle: 亲测好用，建议收藏
+
+**Visual Concept**:
+科技感背景，多个AI工具图标环绕，中心大标题，
+霓虹蓝+深色背景，未来感十足
+
+**Swipe Hook**: 第一个就很强大👇
+
+---
+
+## Image 2 of 6
+
+**Position**: Content
+**Layout**: balanced
+**Core Message**: 为什么你需要AI工具
+**Slug**: why-ai
+**Filename**: 02-content-why-ai.png
+
+**Text Content**:
+- Title: 「为什么要用AI？」
+- Points:
+  - 重复工作自动化
+  - 创意辅助不卡壳
+  - 效率提升10倍
+
+**Visual Concept**:
+对比图：左边疲惫打工人，右边轻松使用AI的人
+科技线条装饰，简洁有力
+
+**Swipe Hook**: 接下来是具体工具推荐👇
+
+---
+
+## Image 3 of 6
+
+**Position**: Content
+**Layout**: dense
+**Core Message**: ChatGPT使用技巧
+**Slug**: chatgpt
+**Filename**: 03-content-chatgpt.png
+
+**Text Content**:
+- Title: 「ChatGPT」
+- Subtitle: 最强AI助手
+- Points:
+  - 写文案：给出框架，秒出初稿
+  - 改文章：润色、翻译、总结
+  - 编程：写代码、找bug
+  - 学习：解释概念、出题练习
+
+**Visual Concept**:
+ChatGPT logo居中，四周放射状展示功能点
+深色科技背景，霓虹绿点缀
+
+**Swipe Hook**: 下一个更适合创意工作者👇
+
+---
+
+## Image 4 of 6
+
+**Position**: Content
+**Layout**: dense
+**Core Message**: Midjourney绘图
+**Slug**: midjourney
+**Filename**: 04-content-midjourney.png
+
+**Text Content**:
+- Title: 「Midjourney」
+- Subtitle: AI绘画神器
+- Points:
+  - 输入描述，秒出图片
+  - 风格多样：写实/插画/3D
+  - 做封面、做头像、做素材
+  - 不会画画也能当设计师
+
+**Visual Concept**:
+展示几张MJ生成的不同风格图片
+画框/画布元素装饰
+
+**Swipe Hook**: 还有一个效率神器👇
+
+---
+
+## Image 5 of 6
+
+**Position**: Content
+**Layout**: balanced
+**Core Message**: Notion AI笔记
+**Slug**: notion-ai
+**Filename**: 05-content-notion-ai.png
+
+**Text Content**:
+- Title: 「Notion AI」
+- Subtitle: 智能笔记助手
+- Points:
+  - 自动总结长文
+  - 头脑风暴出点子
+  - 整理会议记录
+
+**Visual Concept**:
+Notion界面风格，简洁黑白配色
+展示笔记整理前后对比
+
+**Swipe Hook**: 最后总结一下👇
+
+---
+
+## Image 6 of 6
+
+**Position**: Ending
+**Layout**: sparse
+**Core Message**: 总结与互动
+**Slug**: summary
+**Filename**: 06-ending-summary.png
+
+**Text Content**:
+- Title: 「工具只是工具」
+- Subtitle: 关键是用起来！
+- CTA: 收藏备用 | 转发给需要的朋友
+- Interaction: 你最常用哪个？评论区见👇
+
+**Visual Concept**:
+简洁背景，大字标题
+底部互动引导文字
+收藏/分享图标
+
+---
+```
+
+## Layout Guidelines by Position
+
+| Position | Recommended Layout | Why |
+|----------|-------------------|-----|
+| Cover | `sparse` | Maximum visual impact, clear title |
+| Setup | `balanced` | Context without overwhelming |
+| Core | `balanced`/`dense`/`list` | Based on content density |
+| Payoff | `balanced`/`list` | Clear takeaways |
+| Ending | `sparse` | Clean CTA, memorable close |
+
+## Swipe Hook Strategies
+
+Each image should end with a hook for the next:
+
+| Strategy | Example |
+|----------|---------|
+| Teaser | "第一个就很强大👇" |
+| Numbering | "接下来是第2个👇" |
+| Superlative | "下一个更厉害👇" |
+| Question | "猜猜下一个是什么？👇" |
+| Promise | "最后一个最实用👇" |
+| Urgency | "最重要的来了👇" |
+
+## Variant Differentiation
+
+Three variants should differ meaningfully:
+
+| Aspect | Variant A | Variant B | Variant C |
+|--------|-----------|-----------|-----------|
+| Style | Primary match | Alternative | Different mood |
+| Layout | Content-optimized | Different density | Different structure |
+| Tone | Professional | Casual | Playful |
+| Audience | Primary target | Secondary target | Broader appeal |
+
+**Example for "AI工具推荐"**:
+- `outline-style-tech.md`: Tech + Dense - 专业极客风
+- `outline-style-notion.md`: Notion + List - 清爽知识卡片
+- `outline-style-cute.md`: Cute + Balanced - 可爱易读风
Author	SHA1	Message	Date
Jim Liu 宝玉	97bc68efd8	chore: release v1.1.0	2026-01-18 20:11:49 -06:00
Jim Liu 宝玉	464edf0656	chore: release v1.0.1	2026-01-18 19:15:34 -06:00
Jim Liu 宝玉	43c2589a38	Refactor code structure for improved readability and maintainability	2026-01-18 18:18:54 -06:00
Jim Liu 宝玉	4c82884722	chore: release v1.0.0 - Add baoyu-danger-x-to-markdown skill to marketplace - Update README files with new skill documentation - Bump version to 1.0.0 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-18 18:00:58 -06:00
Jim Liu 宝玉	56d0485412	chore: rename baoyu-gemini-web to baoyu-danger-gemini-web	2026-01-18 17:58:12 -06:00
Jim Liu 宝玉	4998eaf8c2	feat: add baoyu-danger-x-to-markdown skill Ignore generated x-to-markdown output directory.	2026-01-18 17:42:25 -06:00
Jim Liu 宝玉	5993b6969d	chore: release v0.11.0	2026-01-18 09:53:48 -06:00
Jim Liu 宝玉	dc0201b63f	chore: release v0.10.0	2026-01-18 00:01:06 -06:00
Jim Liu 宝玉	3811512750	docs: add Customization section to README files	2026-01-17 22:12:01 -06:00
Jim Liu 宝玉	9a9f6a42cd	chore: release v0.9.0	2026-01-17 22:02:40 -06:00
Jim Liu 宝玉	3b13b25f1a	chore: release v0.8.2	2026-01-17 19:00:27 -06:00
Jim Liu 宝玉	688d1760ed	chore: release v0.8.0 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-17 16:44:50 -06:00
Jim Liu 宝玉	a701be873b	update Image Generation Guidelines	2026-01-17 16:24:23 -06:00
Jim Liu 宝玉	1df5e4974d	feat: add analysis framework for Xiaohongshu content	2026-01-17 15:52:00 -06:00
Jim Liu 宝玉	2677e730b9	Update release-skills to update readme	2026-01-17 15:11:50 -06:00
				`@@ -0,0 +1,2 @@`
				`export { GemMixin } from './gem-mixin.js';`