ethan-agent-skills 0.1.1 → 0.2.0

package/README.md

@@ -25,8 +25,8 @@ npx -y ethan-agent-skills@latest update --target /tmp/test-skills
 npx -y ethan-agent-skills@latest list
 ```
 
-Current common bundled skills include `pdf-extract`, `skill-evolution`, and
-`fix-my-life`, plus the client-specific OpenSpec OPSX skills.
+Current common bundled skills include `pdf-extract`, `skill-evolution`,
+`fix-my-life`, and `smzdm-picks`, plus the client-specific OpenSpec OPSX skills.
 
 The updater writes `.skills-lock.json` in each target skill root and only
 rewrites skills managed by this package. If a destination skill directory exists
@@ -169,6 +169,98 @@ The workflow can also be started manually from the GitHub Actions tab, but tag
 pushes are the preferred release path because they tie npm versions to Git
 history.
 
+### Importing Existing Local Skills
+
+Use this flow when a useful skill already exists under a local agent directory
+such as `~/.claude/skills/<skill-dir>` and should become part of this package.
+
+1. Choose the package destination:
+   - Put cross-client skills in `skills/<skill-dir>`.
+   - Put Claude-only skills in `claude/skills/<skill-dir>`.
+   - Put Codex-only skills in `codex/skills/<skill-dir>`.
+   - Put source-command or agent-only skills in `agents/skills/<skill-dir>`.
+2. Inspect the source before copying:
+
+```bash
+SOURCE="$HOME/.claude/skills/<skill-dir>"
+rg --files -uu "$SOURCE"
+rg -n "(secret|password|token|api[_-]?key|PRIVATE|sk-[A-Za-z0-9])" "$SOURCE"
+```
+
+Do not copy real `.env` files, private keys, generated caches, or unrelated
+local state. Placeholder files such as `.env.example` are fine.
+
+3. Copy the skill into the package:
+
+```bash
+DEST="skills/<skill-dir>"
+rm -rf "$DEST"
+cp -R "$SOURCE" "$DEST"
+find "$DEST" -type d -name "__pycache__" -prune -exec rm -rf {} +
+find "$DEST" -name "*.pyc" -delete
+```
+
+4. Add or update `skill.json` beside `SKILL.md`:
+
+```json
+{
+  "name": "<trigger-or-display-name>",
+  "version": "0.1.0",
+  "description": "Short description used by the package list command."
+}
+```
+
+Keep the `SKILL.md` frontmatter name unchanged when the existing trigger name
+should remain stable. For example, a directory can be `skill-evolution` while
+the skill frontmatter name remains `skill-dev`.
+
+5. Verify local discovery and install behavior:
+
+```bash
+node bin/skills.mjs list
+node bin/skills.mjs update --dry-run --target /tmp/test-skills --client claude
+npm run test:local
+npm run pack:check
+```
+
+`npm run pack:check` should show the new `SKILL.md`, `skill.json`, references,
+and scripts in the tarball contents.
+
+6. Commit and push the imported skill:
+
+```bash
+git status --short
+git add README.md skills/<skill-dir>
+git commit -m "Add <skill-dir> skill"
+```
+
+Adjust the `git add` path if the skill was copied into `claude/`, `codex/`, or
+`agents/` instead of `skills/`.
+
+7. Publish a new npm version:
+
+```bash
+npm version minor
+git push --follow-tags
+```
+
+Use `minor` for adding a new skill. Use `patch` if the skill was already
+published and only its content changed.
+
+8. Confirm the automated release:
+
+```bash
+npm view ethan-agent-skills version --json
+npx -y ethan-agent-skills@latest list
+npx -y ethan-agent-skills@latest update --dry-run --target /tmp/test-skills --client claude
+```
+
+After the new version appears on npm, users can refresh with:
+
+```bash
+npx -y ethan-agent-skills@latest update
+```
+
 ## OpenSpec OPSX Usage
 
 Codex App can invoke the global custom prompts directly:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ethan-agent-skills",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Agent skills published from my_agent_skill",
   "type": "module",
   "bin": {

package/skills/pdf-extract/SKILL.md

@@ -5,156 +5,55 @@ description: Extract text from PDF files and save as clean markdown documents. U
 
 # PDF Extract Skill
 
-Extract complete text from PDF files and save as clean markdown. Handles text-based PDFs, scanned/image pages, and mixed documents — all using macOS native frameworks (no external dependencies beyond pyobjc, which comes with the system Python on macOS).
+Extract complete text from PDF files and save as clean markdown. Handles text-based PDFs, scanned/image pages, and mixed documents using macOS-native frameworks (pyobjc + Quartz/PDFKit).
 
 ## When to Use
 
 - A user uploads a PDF and wants its content extracted to text or markdown
-- The PDF contains a mix of text and scanned pages (e.g., insurance policy booklets)
-- Scanned pages are embedded within otherwise text-based PDFs
-- Large PDFs where the extracted text exceeds normal read limits
+- The PDF mixes text and scanned pages (e.g., insurance policy booklets)
+- Large PDFs whose extracted text exceeds normal read limits
 - Financial documents, insurance policies, contracts, or reports that need structured extraction
 
-## Workflow Overview
+## Recommended Workflow
 
-1. **Try text extraction first** — use PDFKit to get native text
-2. **Detect scanned pages** — pages with little or no extracted text are likely scans
-3. **Render scanned pages as images** — convert them to PNGs at high resolution
-4. **Extract text from images** — use multimodal vision to OCR the rendered pages
-5. **Crop if needed** — isolate specific regions (tables, signatures) from page images
-6. **Assemble and save** — combine all extracted text into a clean markdown document
+Run the bundled script. It handles text extraction + section keyword scan + optional rendering in one call:
 
-## Step-by-Step Instructions
-
-### Step 1: Inspect the PDF
-
-First, check the PDF file path and try basic text extraction on the first page to gauge quality:
-
-```python
-import sys, Quartz, os
-sys.path.insert(0, '/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/PyObjC')
-import objc
-
-pdf_path = "/path/to/file.pdf"
-url = Quartz.NSURL.fileURLWithPath_(pdf_path)
-doc = Quartz.PDFDocument.alloc().initWithURL_(doc)
-
-if doc is None:
-    # Cannot read PDF
-    exit()
-
-page_count = doc.pageCount()
-print(f"Pages: {page_count}")
-
-# Quick quality check on first page
-p1 = doc.pageAtIndex_(0)
-text = p1.string() if p1 else ""
-print(f"First page text length: {len(text)}")
-if len(text) < 50:
-    print("WARNING: Low text extraction — likely a scanned PDF")
+```bash
+python3 ~/.claude/skills/pdf-extract/scripts/pdf_extract.py <pdf_path> \
+  > /tmp/extracted.txt 2> /tmp/summary.txt
 ```
 
-### Step 2: Extract All Text-Based Pages
+Then:
 
-Attempt to extract text from every page. Pages with meaningful text (>50 chars) are text-based; pages with very little text (<10 chars, often just whitespace or decorative elements) are scanned images.
+1. **Read `/tmp/summary.txt` first.** It contains the `section_index` (page numbers of key financial sections like cash value table, benefit illustration, surrender value, non-guaranteed projections) and any `warnings`. **Inspect every section_index entry before declaring extraction complete** — do not stop at the first value table found.
+2. **Heed all warnings.** They flag missing documents or coverage gaps (e.g., "participating policy without illustration").
+3. **Deep-read the pages** the section_index points to. For long documents, use offset/limit on `/tmp/extracted.txt`.
+4. **For scanned pages**, rerun with `--render-scanned` to write PNGs to `/tmp/pdf_rendered/`, then use the Read tool on the PNGs for vision-based OCR.
+5. **Assemble** the extracted content into structured markdown.
 
-```python
-import sys, Quartz
+For the underlying pyobjc/Quartz Python code (when modifying the script or running inline), see `references/manual-implementation.md`.
 
-pdf_path = "/path/to/file.pdf"
-url = Quartz.NSURL.fileURLWithPath_(pdf_path)
-doc = Quartz.PDFDocument.alloc().initWithURL_(url)
+## Policy / Financial PDF Workflow
 
-pages_text = []
-scanned_pages = []
+Insurance policies (especially participating/with-profits plans), annuity contracts, and savings plans contain **multiple value tables** that look similar but represent very different things. Missing one leads to wildly wrong conclusions.
 
-for i in range(doc.pageCount()):
-    page = doc.pageAtIndex_(i)
-    text = page.string() if page else ""
-    if len(text.strip()) < 10:
-        scanned_pages.append(i)
-    else:
-        pages_text.append({"page": i + 1, "text": text})
+**Key distinction for participating policies**:
+- **Guaranteed Cash Value Table** (保證現金價值表) — contractually guaranteed, usually printed in the policy contract
+- **Benefit Illustration / 建議書摘要** — projected values including **non-guaranteed dividends** (特別紅利, reversionary/terminal bonus). For a分紅 / participating policy, **the illustration is the central financial document, not the guaranteed table.**
 
-print(f"Text pages: {len(pages_text)}, Scanned pages: {scanned_pages}")
-```
-
-### Step 3: Render Scanned Pages as PNG Images
-
-For each scanned page, render it to a PNG image at 6x scale (300+ DPI equivalent) for clarity. Lower scales (3x-4x) may not be readable for dense financial tables.
-
-```python
-import sys, Quartz
-
-pdf_path = "/path/to/file.pdf"
-url = Quartz.NSURL.fileURLWithPath_(pdf_path)
-doc = Quartz.PDFDocument.alloc().initWithURL_(url)
-output_dir = "/tmp/pdf_rendered/"
-os.makedirs(output_dir, exist_ok=True)
-
-scale = 6.0  # 6x scale for dense tables
-
-for page_idx in scanned_pages:
-    page = doc.pageAtIndex_(page_idx)
-    media_box = page.boundsForBox_(Quartz.kCGPDFMediaBox)
-    
-    pw = int(media_box.size.width * scale)
-    ph = int(media_box.size.height * scale)
-    
-    cs = Quartz.CGColorSpaceCreateDeviceRGB()
-    ctx = Quartz.CGBitmapContextCreate(
-        None, pw, ph, 8, pw * 4, cs,
-        Quartz.kCGImageAlphaPremultipliedLast
-    )
-    
-    # White background
-    Quartz.CGContextSetRGBFillColor(ctx, 1.0, 1.0, 1.0, 1.0)
-    Quartz.CGContextFillRect(ctx, Quartz.CGRectMake(0, 0, pw, ph))
-    Quartz.CGContextScaleCTM(ctx, scale, scale)
-    page.drawWithBox_toContext_(Quartz.kCGPDFMediaBox, ctx)
-    
-    cg_img = Quartz.CGBitmapContextCreateImage(ctx)
-    Quartz.CGImageDestinationAddImage(
-        Quartz.CGImageDestinationCreateWithURL(
-            Quartz.NSURL.fileURLWithPath_(f"{output_dir}page_{page_idx+1}.png"),
-            Quartz.kUTTypePNG, 1, None
-        ),
-        cg_img, None
-    )
-    # Finalize the destination
-    dest = Quartz.CGImageDestinationCreateWithURL(
-        Quartz.NSURL.fileURLWithPath_(f"{output_dir}page_{page_idx+1}.png"),
-        Quartz.kUTTypePNG, 1, None
-    )
-    Quartz.CGImageDestinationAddImage(dest, cg_img, None)
-    Quartz.CGImageDestinationFinalize(dest)
-    
-    print(f"Rendered page {page_idx+1} to {output_dir}page_{page_idx+1}.png ({pw}x{ph})")
-```
+For a typical participating policy, expected surrender value ≈ guaranteed cash value + projected non-guaranteed bonus. Using only the guaranteed table can understate expected returns by 2-5x.
 
-> **Scale reference:** 3x works for simple text, 4x for most documents, 5x for dense forms, 6x for financial tables with small fonts. Start at 4x and go up if text isn't legible.
+**Rules**:
+1. If `section_index["participating_plan"]` is non-empty, **you must locate and extract** `benefit_illustration`. Don't summarize without it.
+2. If `section_index["benefit_illustration"]` is empty for a participating policy, **tell the user the illustration is missing** and recommend requesting it from the agent — do not compute IRR or surrender returns from the guaranteed table alone.
+3. When building the summary markdown, present **guaranteed (A) + non-guaranteed (B) + total (A+B)** as separate columns. Note that non-guaranteed values can be downgraded at the insurer's discretion.
+4. Look for pessimistic/optimistic scenario tables (悲觀情景 / 樂觀情景) — they bracket the range of plausible returns; include them when present.
 
-### Step 4: Crop Specific Regions (Optional)
+**Example**: If the script reports `participating_plan: [55, 68]` and `benefit_illustration: [51, 52, 53, 54, 55]`, deep-read pages 51-55 — that's where the projection tables live. A cash value table elsewhere (e.g., page 48) is necessary but not sufficient.
 
-When only part of a page is relevant (e.g., a specific table), crop the rendered image to that region. Coordinates use the Quartz coordinate system where the origin (0,0) is at the **top-left** of the page.
-
-```python
-import sys, Quartz
-
-# After rendering to cg_img (before saving), crop a region:
-# crop_rect = Quartz.CGRectMake(x * scale, y * scale, width * scale, height * scale)
-# cg_img = Quartz.CGImageCreateWithImageInRect(cg_img, crop_rect)
-```
+## Assembled Markdown Template
 
-> **Finding coordinates:** Render the full page first, view the image, then estimate the crop rectangle. The page bounds are in PDF points (1 point = 1/72 inch). A standard A4 page is roughly 595x842 points. Multiply by `scale` for the pixel-space crop rectangle.
-
-### Step 5: Extract Text from Rendered Images
-
-Use multimodal vision to extract text from the rendered PNG images. This works best with the Read tool on the image files.
-
-### Step 6: Assemble and Save as Markdown
-
-Combine all extracted content into a structured markdown document. Follow the Obsidian wiki schema if the target vault uses it:
+When saving the result to an Obsidian wiki, use this frontmatter pattern:
 
 ```markdown
 ---
@@ -168,47 +67,30 @@ status: active
 
 # Document Title
 
-> Brief description of the document
+> Brief description
 
 ## Key Data
-
 [Extracted tables as markdown tables]
 
 ## Main Content
-
-[Extracted body text, organized by sections]
+[Body text, organized by sections]
 
 ## Important Notes
-
-[Any specific details, warnings, or risks mentioned]
-```
-
-## Handling Large PDFs
-
-When the extracted text is very long and would exceed output limits:
-
-- Process pages in batches of 5-10
-- Save intermediate results to a temporary file
-- For text-based extraction, use chunked reading with offset/limit if reading from a file:
-
-```python
-# Write extracted text to a file first, then read in chunks
-with open("/tmp/extracted.txt", "w") as f:
-    for page_data in pages_text:
-        f.write(f"\n--- Page {page_data['page']} ---\n")
-        f.write(page_data["text"])
+[Specific details, warnings, risks]
 ```
 
 ## Common Pitfalls
 
-- **Low resolution renders:** If OCR quality is poor, increase the scale from 4x to 6x. Dense tables with small fonts almost always need 6x.
-- **Page orientation:** Some PDFs have rotated pages. Check `media_box` dimensions to detect landscape pages.
-- **Watermarks/overlays:** Background watermarks can interfere with OCR. If pages have heavy watermarks, try cropping to the content region.
-- **Mixed content pages:** A page might have both text and scanned elements. The `< 10 chars` threshold detects pure scans, but pages with partial text need manual review.
-- **pyobjc availability:** On macOS, pyobjc is pre-installed with the system Python. Use `python3` from the system, not a Homebrew Python that may lack the Quartz bindings.
+- **Stopping at the first value table.** Especially in policy PDFs, finding a "Cash Value Table" does NOT mean you're done. Always check the `section_index` for other value-related sections (benefit illustration, surrender value, non-guaranteed) before concluding.
+- **Garbled CJK text from font subsetting.** Some PDFs (esp. Traditional Chinese insurance policies) embed subset fonts with custom glyph encodings — `page.string()` returns broken codepoints. Render those pages as PNG at 6x scale and OCR via vision. Often only the boilerplate provisions pages are affected; the data tables remain readable.
+- **Low-resolution renders.** If OCR quality is poor, raise `--scale` from 4 to 6. Dense tables with small fonts need 6x.
+- **Page orientation.** Some PDFs have rotated pages. Check `media_box` dimensions to detect landscape.
+- **Watermarks/overlays.** Heavy background watermarks interfere with OCR — crop to the content region.
+- **Mixed content pages.** A page may have both text and scanned elements. The `< 10 chars` threshold detects pure scans only; partial-text pages need manual review.
+- **pyobjc availability.** On macOS, pyobjc is pre-installed with system Python. Use `python3` from the system, not a Homebrew Python that may lack Quartz bindings.
 
 ## Dependencies
 
-- macOS (required — uses Quartz/PDFKit frameworks)
-- pyobjc (pre-installed on macOS with system Python)
-- No additional packages needed (no poppler, no tesseract, no PIL)
+- macOS (uses Quartz / PDFKit)
+- pyobjc (pre-installed with system Python)
+- No additional packages (no poppler, no tesseract, no PIL)

package/skills/pdf-extract/references/manual-implementation.md

@@ -0,0 +1,141 @@
+# Manual Implementation — pyobjc / Quartz PDF Extraction
+
+The bundled `scripts/pdf_extract.py` handles all of this end-to-end. Read this reference only when:
+- Modifying the script itself
+- The script is unavailable and you need to inline the logic
+- Doing a custom one-off (e.g., a different page-level filter)
+
+The script source at `scripts/pdf_extract.py` is the authoritative implementation.
+
+## Step 1: Inspect the PDF
+
+Check the PDF file path and try basic text extraction on the first page to gauge quality.
+
+```python
+import Quartz
+
+pdf_path = "/path/to/file.pdf"
+url = Quartz.NSURL.fileURLWithPath_(pdf_path)
+doc = Quartz.PDFDocument.alloc().initWithURL_(url)
+
+if doc is None:
+    raise SystemExit("Cannot open PDF")
+
+page_count = doc.pageCount()
+print(f"Pages: {page_count}")
+
+p1 = doc.pageAtIndex_(0)
+text = p1.string() if p1 else ""
+print(f"First page text length: {len(text)}")
+if len(text) < 50:
+    print("WARNING: Low text extraction — likely a scanned PDF")
+```
+
+## Step 2: Extract All Text-Based Pages
+
+Pages with `len(text.strip()) < 10` are treated as pure scans. Pages with partial text need manual review.
+
+```python
+import Quartz
+
+pdf_path = "/path/to/file.pdf"
+url = Quartz.NSURL.fileURLWithPath_(pdf_path)
+doc = Quartz.PDFDocument.alloc().initWithURL_(url)
+
+pages_text = []
+scanned_pages = []
+
+for i in range(doc.pageCount()):
+    page = doc.pageAtIndex_(i)
+    text = page.string() if page else ""
+    if len(text.strip()) < 10:
+        scanned_pages.append(i)
+    else:
+        pages_text.append({"page": i + 1, "text": text})
+
+print(f"Text pages: {len(pages_text)}, Scanned pages: {scanned_pages}")
+```
+
+## Step 3: Render Scanned Pages as PNG
+
+For dense financial tables, use **6x scale** (≈300 DPI equivalent). Lower scales:
+- 3x — simple text
+- 4x — most documents
+- 5x — dense forms
+- 6x — financial tables with small fonts
+
+```python
+import os
+import Quartz
+
+output_dir = "/tmp/pdf_rendered/"
+os.makedirs(output_dir, exist_ok=True)
+scale = 6.0
+
+for page_idx in scanned_pages:
+    page = doc.pageAtIndex_(page_idx)
+    media_box = page.boundsForBox_(Quartz.kCGPDFMediaBox)
+    pw = int(media_box.size.width * scale)
+    ph = int(media_box.size.height * scale)
+
+    cs = Quartz.CGColorSpaceCreateDeviceRGB()
+    ctx = Quartz.CGBitmapContextCreate(
+        None, pw, ph, 8, pw * 4, cs,
+        Quartz.kCGImageAlphaPremultipliedLast
+    )
+
+    Quartz.CGContextSetRGBFillColor(ctx, 1.0, 1.0, 1.0, 1.0)
+    Quartz.CGContextFillRect(ctx, Quartz.CGRectMake(0, 0, pw, ph))
+    Quartz.CGContextScaleCTM(ctx, scale, scale)
+    page.drawWithBox_toContext_(Quartz.kCGPDFMediaBox, ctx)
+
+    cg_img = Quartz.CGBitmapContextCreateImage(ctx)
+    out_path = os.path.join(output_dir, f"page_{page_idx+1}.png")
+    dest = Quartz.CGImageDestinationCreateWithURL(
+        Quartz.NSURL.fileURLWithPath_(out_path),
+        Quartz.kUTTypePNG, 1, None
+    )
+    Quartz.CGImageDestinationAddImage(dest, cg_img, None)
+    Quartz.CGImageDestinationFinalize(dest)
+    print(f"Rendered page {page_idx+1} -> {out_path} ({pw}x{ph})")
+```
+
+## Step 4: Crop a Region (Optional)
+
+When only part of a page is relevant (e.g., one table), crop the rendered image. Quartz's coordinate origin (0,0) is at the **top-left** of the page.
+
+```python
+# After rendering to cg_img (before saving):
+# crop_rect uses pixel-space coordinates (PDF points × scale)
+crop_rect = Quartz.CGRectMake(x * scale, y * scale, width * scale, height * scale)
+cg_img = Quartz.CGImageCreateWithImageInRect(cg_img, crop_rect)
+```
+
+**Finding coordinates**: render the full page first, view the image, estimate the crop rectangle in PDF points (1 point = 1/72 inch; A4 ≈ 595×842 points), then multiply by `scale`.
+
+## Section Keyword Patterns
+
+The script's auto section scan uses these regex patterns. Extend them when encountering new document genres (e.g., loan agreements, trust deeds):
+
+| section_key             | Pattern (case-insensitive)                                                                      |
+|-------------------------|-------------------------------------------------------------------------------------------------|
+| cash_value_table        | `保[證证]現?金價值表` / `Guaranteed Cash Value` / `Cash Value Table`                              |
+| benefit_illustration    | `建[議议]書摘要` / `Benefit Illustration` / `Illustration Summary` / `利益[說说]明`              |
+| surrender_value         | `退保價值` / `退保价值` / `Surrender Value`                                                     |
+| non_guaranteed          | `非保[證证]` / `Non-Guaranteed`                                                                  |
+| projected_values        | `預計` / `预计` / `Projected` / `Estimated`                                                     |
+| special_bonus           | `特別紅利` / `特别红利` / `Special Bonus` / `Reversionary Bonus` / `Terminal Bonus`              |
+| participating_plan      | `分紅(計劃|保單)?` / `分红(计划|保单)?` / `Participating` / `With-Profits`                       |
+| death_benefit           | `身故保[障賠]` / `Death Benefit`                                                                |
+| critical_illness        | `嚴重疾病` / `严重疾病` / `危疾` / `Critical Illness`                                            |
+| premium_payment         | `繳[費付]` / `缴[费付]` / `Premium Payment` / `Payment Schedule`                                |
+| policy_terms            | `保單條款` / `保单条款` / `Policy Provisions` / `Terms and Conditions`                          |
+| endorsement             | `批[註注]` / `Endorsement` / `Rider`                                                            |
+
+## Warning Triggers
+
+The script emits warnings when the detected section pattern suggests missing documentation:
+
+1. **`participating_plan` present + `benefit_illustration` absent** → the illustration is often a separate document. Ask the user / agent to provide it.
+2. **`cash_value_table` present + `participating_plan` present + `surrender_value` absent** → guaranteed cash value alone understates expected return for a participating policy.
+3. **`non_guaranteed` referenced + `benefit_illustration` absent** → projection data likely in a separate proposal/illustration document.

package/skills/pdf-extract/scripts/pdf_extract.py

@@ -9,22 +9,44 @@ Options:
     --render-scanned    Render scanned/blank pages as PNG images for OCR
     --output-dir DIR    Directory for rendered page images (default: /tmp/pdf_rendered/)
     --scale N           Render scale multiplier (default: 6.0)
+    --no-section-scan   Disable section keyword scan (on by default)
 
 Output:
     - Prints extracted text to stdout, page by page
     - If --render-scanned is set, saves scanned pages as PNGs to output_dir
-    - Prints a JSON summary to stderr with page counts and scanned page indices
+    - Prints a JSON summary to stderr with page counts, scanned pages,
+      section_index (page locations of key financial sections), and warnings.
 """
 
 import sys
 import os
+import re
 import json
 import argparse
 
 import Quartz
 
 
-def extract_text(pdf_path, render_scanned=False, output_dir=None, scale=6.0):
+# Section keyword patterns for policy / financial document detection.
+# Each entry: (section_key, regex_pattern). Patterns are case-insensitive
+# and cover both Traditional / Simplified Chinese and English variants.
+SECTION_PATTERNS = [
+    ("cash_value_table",     r"保[證证]現?金價值表|保证现金价值表|Guaranteed\s+Cash\s+Value|Cash\s+Value\s+Table"),
+    ("benefit_illustration", r"建[議议]書摘要|建议书摘要|建[議议]書|建议书|Benefit\s+Illustration|Illustration\s+Summary|Sales\s+Illustration|利益[說说]明"),
+    ("surrender_value",      r"退保價值|退保价值|Surrender\s+Value"),
+    ("non_guaranteed",       r"非保[證证]|Non[-\s]?Guaranteed"),
+    ("projected_values",     r"預計|预计|Projected|Estimated"),
+    ("special_bonus",        r"特別紅利|特别红利|Special\s+Bonus|Reversionary\s+Bonus|Terminal\s+Bonus"),
+    ("participating_plan",   r"分紅(?:計劃|保[單单])?|分红(?:计划|保[單单])?|Participating|With[-\s]?Profits"),
+    ("death_benefit",        r"身故保[障賠]|Death\s+Benefit"),
+    ("critical_illness",     r"嚴重疾病|严重疾病|危疾|Critical\s+Illness"),
+    ("premium_payment",      r"繳[費付]|缴[费付]|Premium\s+Payment|Payment\s+Schedule"),
+    ("policy_terms",         r"保[單单]條款|保[單单]条款|Policy\s+Provisions|Terms\s+and\s+Conditions"),
+    ("endorsement",          r"批[註注]|Endorsement|Rider"),
+]
+
+
+def extract_text(pdf_path, render_scanned=False, output_dir=None, scale=6.0, section_scan=True):
     url = Quartz.NSURL.fileURLWithPath_(pdf_path)
     doc = Quartz.PDFDocument.alloc().initWithURL_(url)
 
@@ -35,10 +57,12 @@ def extract_text(pdf_path, render_scanned=False, output_dir=None, scale=6.0):
     page_count = doc.pageCount()
     pages_text = []
     scanned_pages = []
+    all_page_texts = {}  # page_idx -> text, for section scan
 
     for i in range(page_count):
         page = doc.pageAtIndex_(i)
         text = page.string() if page else ""
+        all_page_texts[i] = text
 
         if len(text.strip()) < 10:
             scanned_pages.append(i)
@@ -62,13 +86,78 @@ def extract_text(pdf_path, render_scanned=False, output_dir=None, scale=6.0):
         "scanned_pages": scanned_pages,
         "scanned_count": len(scanned_pages),
     }
-    print(f"\n[Summary] {summary['text_pages']} text pages, {summary['scanned_count']} scanned pages: {scanned_pages}", file=sys.stderr)
-    json.dump(summary, sys.stderr)
+
+    if section_scan:
+        section_index, warnings = _scan_sections(all_page_texts)
+        summary["section_index"] = section_index
+        summary["warnings"] = warnings
+
+        print(f"\n[Summary] {summary['text_pages']} text pages, {summary['scanned_count']} scanned pages: {scanned_pages}", file=sys.stderr)
+        print("[Section Index] (1-indexed page numbers)", file=sys.stderr)
+        for key, pages in section_index.items():
+            if pages:
+                print(f"  {key}: {pages}", file=sys.stderr)
+        if warnings:
+            print("[WARNINGS]", file=sys.stderr)
+            for w in warnings:
+                print(f"  ! {w}", file=sys.stderr)
+    else:
+        print(f"\n[Summary] {summary['text_pages']} text pages, {summary['scanned_count']} scanned pages: {scanned_pages}", file=sys.stderr)
+
+    json.dump(summary, sys.stderr, ensure_ascii=False)
     print("", file=sys.stderr)
 
     return summary
 
 
+def _scan_sections(all_page_texts):
+    """Scan all pages for known financial document section keywords.
+
+    Returns (section_index, warnings):
+      section_index: {section_key: [1-indexed page numbers where matched]}
+      warnings: list of human-readable warnings about coverage gaps
+    """
+    section_index = {key: [] for key, _ in SECTION_PATTERNS}
+
+    for page_idx, text in all_page_texts.items():
+        if not text:
+            continue
+        for key, pattern in SECTION_PATTERNS:
+            if re.search(pattern, text, re.IGNORECASE):
+                section_index[key].append(page_idx + 1)
+
+    warnings = []
+
+    # Participating policy without Benefit Illustration → likely missing the key document
+    if section_index["participating_plan"] and not section_index["benefit_illustration"]:
+        warnings.append(
+            "Participating/with-profits policy detected, but no Benefit Illustration "
+            "section found. The illustration (with non-guaranteed projections) is often "
+            "a separate document — ask the user / agent to provide it before drawing "
+            "conclusions about surrender/maturity values."
+        )
+
+    # Cash value table present but no surrender value section → for participating plans,
+    # guaranteed cash value alone understates the true expected return.
+    if (section_index["cash_value_table"]
+            and section_index["participating_plan"]
+            and not section_index["surrender_value"]):
+        warnings.append(
+            "Cash Value Table found but no 'Surrender Value' / 退保價值 section. "
+            "For a participating policy, 'Guaranteed Cash Value' ≠ 'Expected Surrender Value' "
+            "(the latter includes non-guaranteed dividends). Verify all value tables were located."
+        )
+
+    # Non-guaranteed mentioned but no Benefit Illustration → projection data probably elsewhere
+    if section_index["non_guaranteed"] and not section_index["benefit_illustration"]:
+        warnings.append(
+            "Non-guaranteed amounts referenced but no Benefit Illustration found — "
+            "projected values may be in a separate proposal/illustration document."
+        )
+
+    return section_index, warnings
+
+
 def _render_page(page, page_idx, output_dir, scale):
     media_box = page.boundsForBox_(Quartz.kCGPDFMediaBox)
     pw = int(media_box.size.width * scale)
@@ -107,6 +196,9 @@ if __name__ == "__main__":
                         help="Output directory for rendered images")
     parser.add_argument("--scale", type=float, default=6.0,
                         help="Scale multiplier for rendering (default: 6.0)")
+    parser.add_argument("--no-section-scan", action="store_true",
+                        help="Disable section keyword scan (on by default)")
     args = parser.parse_args()
 
-    extract_text(args.pdf_path, args.render_scanned, args.output_dir, args.scale)
+    extract_text(args.pdf_path, args.render_scanned, args.output_dir, args.scale,
+                 section_scan=not args.no_section_scan)

package/skills/pdf-extract/skill.json

@@ -1,5 +1,5 @@
 {
   "name": "pdf-extract",
-  "version": "0.1.0",
-  "description": ""
+  "version": "0.2.0",
+  "description": "Extract text from PDFs and save as clean markdown on macOS via PDFKit + Quartz. Auto-detects scanned pages, renders them for vision OCR, and scans for financial-document sections (cash value, benefit illustration, surrender value, non-guaranteed) so participating-policy data isn't missed."
 }

package/skills/smzdm-picks/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: smzdm-picks
+description: Fetch personalized 什么值得买 (smzdm.com) deal picks from the user's already-logged-in Chrome session. Trigger when the user says "smzdm", "什么值得买", "今日好价", "smzdm 精选", "查一下值得买", "好价推荐", "smzdm picks", "zdm", "今天有什么好价", "值得买推荐", "smzdm 推荐", or asks to see today's curated deals / discounts / 优惠 / 特价 on smzdm. Drives Chrome via AppleScript because smzdm has anti-bot protection; uses the user's existing login for personalized content.
+---
+
+# smzdm-picks
+
+Pull today's personalized curated deals (个性化好价) from 什么值得买 by driving the user's already-logged-in Chrome via AppleScript + JS injection.
+
+## Why AppleScript
+
+smzdm.com is protected by an Akamai-style JS challenge: plain `curl` returns HTTP 202 with a `probe.js` and no content. The only way to get the rendered, personalized feed is through a real browser that's already authenticated. The user has Chrome logged in, so this skill steers Chrome itself.
+
+## One-time setup (per Mac)
+
+**This skill is per-machine** — each Mac needs its own setup because Chrome's cookie store and AppleScript permission are local. When the user mentions running this on a new Mac, or this skill triggers on a machine for the first time, walk them through this checklist.
+
+Use the built-in self-check command to verify each step:
+```bash
+bash ~/.claude/skills/smzdm-picks/scripts/fetch.sh --check
+```
+
+It prints ✓/✗ for each requirement and pinpoints what's missing. Manual checklist if you prefer step-by-step:
+
+1. **Open Chrome** and confirm it stays open in the background.
+2. **Enable AppleScript JS API**: Chrome menu → View → Developer → **Allow JavaScript from Apple Events** ✓
+   - If the "Developer" submenu is hidden: Chrome → Settings → search for "developer menu" → enable.
+   - In Chinese Chrome: 查看 → 开发者 → 允许 Apple 事件中的 JavaScript.
+3. **Grant Automation permission (first run only)**: when the script runs for the first time on a new Mac, macOS pops up *"Terminal (or iTerm/Claude) wants to control 'Google Chrome'"* — click **OK**. To verify or fix later: System Settings → Privacy & Security → Automation → expand your terminal app → ensure **Google Chrome ✓** is checked.
+4. **Log into smzdm.com in this Chrome**: open https://www.smzdm.com/ and sign in. Cookies are per-profile and don't sync from other machines.
+5. **Chrome variant**: if using Chrome Canary or Chrome Beta, set `CHROME_APP="Google Chrome Canary"` (or similar) in the environment — the default is `"Google Chrome"`.
+
+If `fetch.sh` returns exit 4 (JS API rejected) → step 2 is the issue. Exit 6 (--check failed) → check the ✗ line. Exit 2 (Chrome not running) → step 1.
+
+## Workflow
+
+1. **New Mac?** If this is the first time on this machine (no successful prior run in this session, or the user mentions "另一台电脑"/"new computer"/"on this Mac"), run `bash ~/.claude/skills/smzdm-picks/scripts/fetch.sh --check` first and walk through any ✗ items per the Setup section above. Don't proceed to scrape until --check passes.
+2. Run: `bash ~/.claude/skills/smzdm-picks/scripts/fetch.sh [target]`
+   - No arg → homepage (`/`) — the personalized recommendation feed
+   - `jingxuan` → `/jingxuan/` — curated picks
+   - `faxian` → `faxian.smzdm.com` — pure deals stream
+3. The script briefly opens a tab in the user's front Chrome window, waits 6s for JS, extracts items via DOM selectors, closes the tab, restores focus.
+4. Parse the JSON on stdout. Read stderr diagnostics for any warnings (logged_in flag, item count).
+5. Curate and render to the user (see Curation Rules + Output Format below).
+
+## Curation Rules
+
+From the extracted ≤30 raw items, pick the **10 best** for display:
+
+- **Must have** title + link. Items missing either are noise — skip.
+- **Prefer items with a concrete price** (¥XXX) over vague ones ("低至"/"满减"). Sort price-ed items first.
+- **Skip soft ads**: title containing 赞助 / 广告 / 软广 / 测评推荐.
+- **Diversify sources**: avoid >3 items from the same e-commerce platform (京东/天猫/etc.) in the top 10.
+- **Mark the standout**: prefix the top 1 with 🔥 if `value` field (smzdm 值得买/不值得指数) suggests strong consensus, otherwise no prefix.
+
+## Output format
+
+Mobile-friendly markdown list, no tables. Match `daily-hunt` / `pulse` style:
+
+```markdown
+# 🛒 smzdm 今日精选好价 · {today}
+
+> 已为你筛选 {N} 条来自{个性化推荐|精选|发现}流的好价
+
+1. 🔥 **{标题}** · {商城} · {价格}
+   {短链}
+
+2. **{标题}** · {商城} · {价格}
+   {短链}
+
+...
+
+— 数据来自 smzdm.com（{personalized|curated}），共抓取 {total} 条，展示前 {N}
+```
+
+Notes for rendering:
+- Use full-width Chinese punctuation (，。：！) inside Chinese text.
+- Keep each item to ≤ 2 lines; long titles wrap naturally.
+- Link goes on its own line for tappability.
+- If a tag is interesting (like 双 11 / PLUS 会员价 / 限时), append it inline: `· 京东 · ¥499 · 双11 价`.
+
+## Error handling
+
+| Symptom | Likely cause | Tell the user |
+|---|---|---|
+| Exit 2 — "Chrome not running" | Chrome process not found | "请先打开 Chrome 并确认 smzdm.com 已登录"（提示：Chrome Canary/Beta 需设置 `CHROME_APP` 环境变量） |
+| Exit 4 — JS API rejected | Allow JS from Apple Events disabled | Walk through the one-time Setup above. Also check System Settings → Privacy & Security → Automation. |
+| Exit 5 — empty result | Page load slow / DOM changed | "smzdm 页面没在 6 秒内加载完，请稍后重试" |
+| Exit 6 — --check failed | New machine setup incomplete | Use the ✓/✗ output from `--check` to pinpoint which step is missing |
+| `logged_in: false` in JSON | Chrome session expired on this Mac | "Chrome 里 smzdm 登录已过期 / 这台电脑还没登录过，请到浏览器登录后再试" |
+| 0 items extracted | DOM selectors out of date | "smzdm 页面结构可能变了，需要更新 fetch.sh 里的 selector" |
+
+Always show the **raw stderr** from the script when reporting an error — it has the exit code and hint.
+
+## Limitations
+
+- **Per-machine setup**: this skill won't auto-work on a new Mac. Each Mac needs Chrome's JS-from-AppleEvents toggle, macOS Automation permission, and a fresh smzdm.com login. Run `--check` on new machines.
+- **macOS-only**: relies on AppleScript + Chrome AppleScript bindings. Won't work on Linux/Windows without a port.
+- **Briefly steals Chrome focus** during the 6s scrape (opens then closes a tab in the front window).
+- **Cookie freshness**: smzdm cookies last 30+ days but logout/clear-cookies/different-profile breaks it.
+- **DOM drift**: selectors will need updating as smzdm redesigns. If extraction returns 0 items repeatedly, update the `candidates` list in `scripts/fetch.sh`.
+- **Read-only digest**: no price history, no alerts, no auto-purchasing.
+
+## Out of scope
+
+- Scheduled push (cron/notifications) — manual trigger only.
+- Multi-day trend tracking — stateless per invocation.
+- 非个性化好价（公开 RSS）fallback — if login breaks, fix the login, don't degrade silently.

package/skills/smzdm-picks/scripts/fetch.sh

@@ -0,0 +1,296 @@
+#!/usr/bin/env bash
+# fetch.sh — Drive the user's already-logged-in Chrome via AppleScript to
+# scrape smzdm.com personalized feed and output items as JSON on stdout.
+#
+# Usage:
+#   bash fetch.sh                 # scrape homepage (/)
+#   bash fetch.sh jingxuan        # scrape 精选 page (/jingxuan/)
+#   bash fetch.sh faxian          # scrape 好价 page (/faxian/)
+#   bash fetch.sh --check         # setup self-check (no scrape, just verify env)
+#
+# Environment:
+#   CHROME_APP   Chrome app name (default: "Google Chrome"). Set to
+#                "Google Chrome Canary" / "Google Chrome Beta" if needed.
+#
+# Exit codes:
+#   0   success — JSON written to stdout (or all checks passed in --check mode)
+#   2   Chrome not running
+#   3   osascript invocation failed
+#   4   Chrome JS API rejected (Allow JS from Apple Events likely disabled)
+#   5   empty / unparseable result
+#   6   --check found a problem (details on stderr)
+#
+# Diagnostics go to stderr. JSON goes to stdout.
+
+set -uo pipefail
+
+CHROME_APP="${CHROME_APP:-Google Chrome}"
+TARGET="${1:-home}"
+CHECK_MODE=0
+
+case "$TARGET" in
+  home)     URL="https://www.smzdm.com/" ;;
+  jingxuan) URL="https://www.smzdm.com/jingxuan/" ;;
+  faxian)   URL="https://faxian.smzdm.com/" ;;
+  --check)  CHECK_MODE=1; URL="https://www.smzdm.com/" ;;
+  *)        URL="$TARGET" ;;  # allow passing full URL
+esac
+
+# 1. Chrome must be running
+if ! pgrep -x "$CHROME_APP" > /dev/null; then
+  echo "ERROR: $CHROME_APP is not running. Open it and make sure smzdm.com is logged in, then retry." >&2
+  echo "(If you use Chrome Canary/Beta, set: CHROME_APP=\"Google Chrome Canary\" bash fetch.sh)" >&2
+  exit 2
+fi
+
+# --check mode: run a trivial JS probe instead of full scrape, report each setup step
+if [ "$CHECK_MODE" = "1" ]; then
+  echo "[smzdm-picks --check] running setup verification..." >&2
+  echo "  ✓ $CHROME_APP is running" >&2
+
+  PROBE=$(osascript <<OSAEOF 2>&1
+tell application "$CHROME_APP"
+  if (count of windows) is 0 then return "__OSAERROR__:0:no windows"
+  try
+    set probe to execute (active tab of front window) javascript "1+1"
+    return "OK:" & probe
+  on error errMsg number errNum
+    return "__OSAERROR__:" & errNum & ":" & errMsg
+  end try
+end tell
+OSAEOF
+)
+  case "$PROBE" in
+    OK:2)
+      echo "  ✓ AppleScript→Chrome JS injection works (View → Developer → Allow JavaScript from Apple Events is enabled)" >&2
+      ;;
+    __OSAERROR__:*)
+      echo "  ✗ AppleScript→Chrome JS injection rejected: $PROBE" >&2
+      echo "    Fix: $CHROME_APP menu → View → Developer → Allow JavaScript from Apple Events ✓" >&2
+      echo "    (If 'Developer' is hidden: Chrome → Settings → search 'developer menu' → enable)" >&2
+      echo "    Also check System Settings → Privacy & Security → Automation: allow your terminal to control $CHROME_APP" >&2
+      exit 6
+      ;;
+    *)
+      echo "  ✗ Unexpected probe response: $PROBE" >&2
+      exit 6
+      ;;
+  esac
+
+  # Login check: visit smzdm and look for login markers
+  LOGIN_PROBE=$(osascript <<OSAEOF 2>&1
+tell application "$CHROME_APP"
+  set originalIndex to active tab index of front window
+  set t to make new tab at end of tabs of front window with properties {URL:"https://www.smzdm.com/"}
+  delay 5
+  set logged to "false"
+  try
+    set logged to execute t javascript "(document.cookie.indexOf('sess=')>=0||document.cookie.indexOf('user=')>=0||!!document.querySelector('[class*=\"user-info\"],[class*=\"nickname\"],[class*=\"avatar\"]'))+''"
+  end try
+  try
+    close t
+  end try
+  try
+    set active tab index of front window to originalIndex
+  end try
+  return logged
+end tell
+OSAEOF
+)
+  if [ "$LOGIN_PROBE" = "true" ]; then
+    echo "  ✓ smzdm.com login state detected in Chrome" >&2
+    echo "" >&2
+    echo "All checks passed. Run 'bash fetch.sh' to scrape." >&2
+    exit 0
+  else
+    echo "  ✗ smzdm.com not logged in (probe returned: $LOGIN_PROBE)" >&2
+    echo "    Fix: open https://www.smzdm.com/ in $CHROME_APP and log in, then retry." >&2
+    exit 6
+  fi
+fi
+
+# 2. Write JS extractor to a tmpfile (avoids AppleScript string escaping hell)
+JS_TMP=$(mktemp -t smzdm_extract.XXXXXX)
+mv "$JS_TMP" "${JS_TMP}.js"
+JS_TMP="${JS_TMP}.js"
+trap 'rm -f "$JS_TMP"' EXIT
+
+cat > "$JS_TMP" <<'JSEOF'
+(function () {
+  function txt(el) {
+    return el ? (el.innerText || el.textContent || '').trim() : '';
+  }
+
+  function findPrice(root) {
+    // Look for leaf elements containing ¥/元/价 — usually the price chip
+    const all = root.querySelectorAll('*');
+    for (const n of all) {
+      if (n.children.length > 0) continue;
+      const t = txt(n);
+      if (t.length > 0 && t.length < 40 && /(¥|元|售价|价格|低至)/.test(t)) {
+        return t;
+      }
+    }
+    return '';
+  }
+
+  function findSource(root) {
+    const re = /^(京东|天猫|淘宝|拼多多|官网|苏宁|亚马逊|网易严选|得物|抖音|京东国际|京东自营|天猫超市|山姆|Costco|考拉|唯品会)$/;
+    const all = root.querySelectorAll('*');
+    for (const n of all) {
+      const t = txt(n);
+      if (t.length > 0 && t.length < 20 && re.test(t)) return t;
+    }
+    return '';
+  }
+
+  function findTags(root) {
+    return [...root.querySelectorAll('[class*="tag"], [class*="Tag"], [class*="label"]')]
+      .map(n => txt(n))
+      .filter(t => t && t.length < 20 && t.length > 0)
+      .slice(0, 5);
+  }
+
+  // Try multiple selector strategies — smzdm changes class names periodically
+  const candidates = document.querySelectorAll(
+    '[class*="feed-row"], [class*="feed-block"], [data-feed-id], article, [class*="z-feed"], [class*="feed-item"]'
+  );
+
+  const items = [];
+  const seen = new Set();
+
+  for (const el of candidates) {
+    // Title
+    const titleEl = el.querySelector('[class*="title"], h5, h3, h4, h2, a[title]');
+    let title = txt(titleEl);
+    if (!title && titleEl) title = titleEl.getAttribute('title') || '';
+    if (!title || title.length < 4) continue;
+
+    // Link — prefer post/faxian links, fall back to any href
+    const linkEl = el.querySelector(
+      'a[href*="//post.smzdm.com/"], a[href*="//faxian.smzdm.com/"], a[href*="//www.smzdm.com/p/"], a[href]'
+    );
+    let link = linkEl ? linkEl.href : '';
+    if (!link || link === window.location.href) continue;
+    if (seen.has(link)) continue;
+    seen.add(link);
+
+    const price = findPrice(el);
+    const source = findSource(el);
+    const tags = findTags(el);
+
+    // Hot/value score if present
+    const valueEl = el.querySelector('[class*="value"], [class*="zhi"], [class*="hot"]');
+    const value = txt(valueEl);
+
+    items.push({ title, price, link, source, tags, value });
+  }
+
+  // Login detection — multiple heuristics
+  const loggedIn = !!(
+    document.querySelector('[class*="user-info"]') ||
+    document.querySelector('[class*="nickname"]') ||
+    document.querySelector('[class*="userpic"]') ||
+    document.querySelector('[class*="avatar"]') ||
+    document.cookie.includes('user=')
+  );
+
+  return JSON.stringify({
+    items: items.slice(0, 30),
+    total_candidates: candidates.length,
+    logged_in: loggedIn,
+    url: location.href,
+    title: document.title,
+    ts: new Date().toISOString()
+  });
+})();
+JSEOF
+
+# 3. Drive Chrome via AppleScript
+RESULT=$(osascript <<OSAEOF 2>&1
+set jsFile to POSIX file "$JS_TMP"
+set jsCode to read jsFile as «class utf8»
+
+tell application "$CHROME_APP"
+  if (count of windows) is 0 then
+    make new window
+  end if
+
+  -- Remember which tab was active so we can restore focus
+  set originalIndex to active tab index of front window
+
+  -- Open target in a new tab
+  set newTab to make new tab at end of tabs of front window with properties {URL:"$URL"}
+
+  -- Wait for JS-rendered content
+  delay 6
+
+  set extractedJSON to ""
+  try
+    set extractedJSON to execute newTab javascript jsCode
+  on error errMsg number errNum
+    set extractedJSON to "__OSAERROR__:" & errNum & ":" & errMsg
+  end try
+
+  -- Close the scrape tab
+  try
+    close newTab
+  end try
+
+  -- Restore focus
+  try
+    set active tab index of front window to originalIndex
+  end try
+
+  return extractedJSON
+end tell
+OSAEOF
+)
+
+OSA_EXIT=$?
+
+# 4. Handle osascript failures
+if [ $OSA_EXIT -ne 0 ]; then
+  echo "ERROR: osascript invocation failed (exit $OSA_EXIT)." >&2
+  echo "Raw output: $RESULT" >&2
+  exit 3
+fi
+
+# 5. Detect JS API rejection
+if [[ "$RESULT" == __OSAERROR__:* ]]; then
+  echo "ERROR: Chrome rejected the JS injection: $RESULT" >&2
+  echo "" >&2
+  echo "HINT (most common cause): enable the JS-from-AppleEvents toggle in Chrome:" >&2
+  echo "  Chrome menu → View / 查看 → Developer / 开发者 → Allow JavaScript from Apple Events / 允许 Apple 事件中的 JavaScript ✓" >&2
+  echo "  (If 'Developer' submenu is hidden: Chrome → Settings → Advanced → enable 'Show Develop menu')" >&2
+  exit 4
+fi
+
+# 6. Empty result?
+if [[ -z "$RESULT" || "$RESULT" == "missing value" ]]; then
+  echo "ERROR: Empty result from Chrome JS. Possible causes:" >&2
+  echo "  - 'Allow JavaScript from Apple Events' is not enabled (see Chrome → View → Developer)" >&2
+  echo "  - Page didn't finish loading in 6s (try again)" >&2
+  echo "  - smzdm DOM structure changed" >&2
+  exit 5
+fi
+
+# 7. Output JSON to stdout
+echo "$RESULT"
+
+# 8. Diagnostics to stderr
+python3 - <<PY 2>/dev/null
+import sys, json
+try:
+    d = json.loads('''$RESULT''')
+    items = d.get('items', [])
+    logged = d.get('logged_in', '?')
+    cand = d.get('total_candidates', '?')
+    sys.stderr.write(f"[smzdm-picks] target={'$URL'} items={len(items)} candidates={cand} logged_in={logged}\n")
+    if not logged:
+        sys.stderr.write("WARNING: Not logged in — feed may be generic, not personalized. Re-login in Chrome.\n")
+    if len(items) == 0:
+        sys.stderr.write("WARNING: Zero items extracted. Page DOM likely changed; check the extractor selectors.\n")
+except Exception as e:
+    sys.stderr.write(f"[smzdm-picks] (could not parse result for diagnostics: {e})\n")
+PY

package/skills/smzdm-picks/skill.json

@@ -0,0 +1,5 @@
+{
+  "name": "smzdm-picks",
+  "version": "0.1.0",
+  "description": "Fetch personalized 什么值得买 (smzdm.com) deal picks from the user's already-logged-in Chrome on macOS. Drives Chrome via AppleScript + JS injection to bypass anti-bot. Per-machine setup; includes --check mode for new-Mac self-verification."
+}