local-places（当地的地方）

Local Places

Location intelligence powered by Nimble Web Search Agents and web data APIs.

User request: $ARGUMENTS

Before running any commands, read references/nimble-playbook.md for Claude Code constraints (no shell state, no &/wait, sub-agent permissions, communication style).

Instructions

Step 0: Preflight

Run the preflight pattern from references/nimble-playbook.md (5 simultaneous Bash calls: date calc, today, CLI check, profile load, index.md load).

Also simultaneously:

• mkdir -p ~/.nimble/memory/{reports,local-places/checkpoints}
• Check for existing checkpoints: ls ~/.nimble/memory/local-places/checkpoints/ 2>/dev/null

From the results:

• CLI missing or API key unset -> references/profile-and-onboarding.md, stop
• Profile exists -> note the user's location preferences if any. Determine mode using smart date windowing from references/nimble-playbook.md:

- Full mode: first run OR last run > 14 days ago - Quick refresh: last run < 14 days ago (skip social enrichment, reviews only for new places) - Same-day repeat: if last_runs.local-places is today, check if a report already exists at ~/.nimble/memory/reports/local-places-*[today].md. If so, ask: "Already ran today for this area. Run again for fresh data?" Don't silently re-run. - Skip to Step 1

• No profile -> that's fine. Local places doesn't require onboarding. Proceed to Step 1.

Step 1: Parse Request & Starting Questions

Parse $ARGUMENTS for place type and location. Extract:

If both place type and location are clear from $ARGUMENTS, confirm briefly and proceed: "Searching for coffee shops in Williamsburg, Brooklyn..."

If partial or ambiguous, ask one combined question in plain text:

"What type of places are you looking for, and where? (e.g., 'coffee shops in Williamsburg' or 'gyms near downtown Austin')"

If the user provided both but you want to scope further, use AskUserQuestion (counts as 1 of max 2 prompts):

How thorough should this search be? - Quick scan -- top results from Google Maps + Yelp (~20 places) - Comprehensive -- full discovery + social enrichment + reviews (~50+ places) - Deep dive with map -- everything above + interactive neighborhood map

Step 2: Location Disambiguation

Before any API calls, resolve the location to avoid wasted searches.

Disambiguation triggers:

• Location name exists in multiple cities/states (e.g., "Williamsburg" = Brooklyn NY vs. Williamsburg VA)
• Location is a broad area (e.g., "downtown Austin" = multiple neighborhoods)
• Location is informal (e.g., "Soho" = NYC vs. London)

If ambiguous, ask the user (counts toward 2-prompt max):

"There are a few places called Williamsburg. Which one?" - Williamsburg, Brooklyn, NY - Williamsburg, VA - Other -- I'll specify

If unambiguous, infer the full location (city + state/country) and confirm inline: "Searching Williamsburg, Brooklyn, NY..."

After disambiguation, derive the slug for checkpointing and file paths: lowercase, hyphenated, includes city + state/country (e.g., williamsburg-brooklyn-ny).

Step 3: Check for Existing Checkpoint

Follow the Checkpointing & Resume pattern from references/memory-and-distribution.md.

Check: cat ~/.nimble/memory/local-places/checkpoints/{slug}/discovery.json 2>/dev/null

• Checkpoint found -> offer: "Found previous run ({N} places from {date}). Resume and fill gaps, or start fresh?"
• No checkpoint -> proceed to Step 4

Step 4: WSA Discovery

Discover available WSAs for all phases before execution. Run these searches simultaneously:

nimble agent list --search "maps" --limit 20

nimble agent list --search "reviews" --limit 20

nimble agent list --search "social" --limit 20

nimble agent list --search "{place-type}" --limit 20

From the combined results:

1. Filter by entity_type: SERP for discovery, PDP/Profile for enrichment/detail
2. Prefer managed_by: "nimble" over managed_by: "community"
3. Classify into phases -- see references/wsa-pipeline.md for classification strategy
4. Validate each with nimble agent get --template-name {name} to confirm params
5. Cache all discovered WSA names + validated params for the rest of the run

If no WSAs found for a phase, that phase falls back to nimble search. Log which phases had WSA coverage and which are using fallback.

Step 5: Primary Search (Phase 1)

Read references/wsa-pipeline.md for category detection logic.

Run discovered maps/location WSAs simultaneously, using the validated params from Step 4:

nimble agent run --agent {discovered_maps_wsa} --params '{...validated params...}'

nimble agent run --agent {discovered_review_site_wsa} --params '{...validated params...}'

Tertiary (conditional): Run discovered credibility WSAs only if primary + secondary return < 10 combined unique results, or if the user asked for credibility/trust data.

If any WSA fails or returns empty, fall back to: nimble search --query "[place-type] in [location]" --max-results 20 --search-depth lite

After discovery:

1. Parse all results into a unified entity list
2. Deduplicate following the Entity Deduplication pattern from references/nimble-playbook.md: place_id exact match -> domain normalization -> fuzzy name + city
3. Save checkpoint: ~/.nimble/memory/local-places/checkpoints/{slug}/discovery.json

Step 6: Social Enrichment (Phase 2)

For each discovered place that has a Facebook page or Instagram handle, run the social WSAs discovered in Step 4. Batch max 4 concurrent Bash calls.

nimble agent run --agent {discovered_social_wsa} --params '{...validated params...}'

Run each discovered social WSA for places with matching handles. Skip social platforms for which no WSA was discovered. If no social WSAs were found in Step 4, skip this phase entirely.

Save checkpoint: ~/.nimble/memory/local-places/checkpoints/{slug}/social.json

Step 7: Reviews (Phase 3)

For the top places (by source count and data completeness), run the review WSAs discovered in Step 4:

nimble agent run --agent {discovered_reviews_wsa} --params '{...validated params...}'

Batch max 4 concurrent calls. Focus on places that have a place_id or equivalent identifier from Phase 1 discovery. If no review WSAs were found in Step 4, fall back to: nimble search --query "[place-name] reviews" --max-results 5 --search-depth lite

Save checkpoint: ~/.nimble/memory/local-places/checkpoints/{slug}/reviews.json

Step 8: Food/Drink Bonus (Phase 4)

Auto-trigger when the place type category matches food/drink keywords. See references/wsa-pipeline.md for the category detection logic.

If triggered, run the delivery/food WSAs discovered in Step 4. Discovery first, then detail:

nimble agent run --agent {discovered_delivery_serp_wsa} --params '{...validated params...}'

For places found on delivery platforms, fetch full details using discovered detail WSAs:

nimble agent run --agent {discovered_delivery_detail_wsa} --params '{...validated params...}'

If no delivery WSAs were found in Step 4, fall back to: nimble search --query "[place-name] [location] delivery" --max-results 3 --search-depth lite

Only run for food/drink categories. Skip if category doesn't match.

Step 9: Deduplication & Confidence Scoring

Deduplication: Run a final dedup pass across all phases following the Entity Deduplication pattern from references/nimble-playbook.md. Merge fields from multiple sources into a single enriched record per place.

Confidence scoring: Follow the Entity Confidence Scoring pattern from references/nimble-playbook.md. Skill-specific target fields (N=8):

Scoring criteria:

• High (8/8 fields + 2+ sources + 10+ reviews) -> display as *** High
• Medium (5-7/8 fields OR 2+ sources with partial data) -> ** Medium
• Low (<=4/8 fields, single source, few/no reviews) -> * Low

Step 10: Output

Present results as a numbered table sorted by confidence (High first), then by rating within each tier.

# Local Places: [Place Type] in [Location]
*Found [N] places | [Date] | Confidence: [H] High, [M] Medium, [L] Low*

## Results

| # | Name | Rating | Reviews | Confidence | Address | Sources |
|---|------|--------|---------|------------|---------|---------|
| 1 | Place A | 4.8 (312) | *** High | 123 Main St | [Maps][Yelp] |
| 2 | Place B | 4.6 (89)  | ** Medium | 456 Oak Ave | [Maps] |
...

## Top Picks (High Confidence)

### 1. Place A
- **Address:** 123 Main St, Williamsburg, Brooklyn, NY
- **Phone:** (555) 123-4567 | **Website:** [placea.com](https://placea.com)
- **Rating:** 4.8/5 (312 reviews on Google Maps, 289 on Yelp)
- **Social:** Instagram @placea (2.1K followers) | Facebook (1.8K likes)
- **Hours:** Mon-Fri 7am-7pm, Sat-Sun 8am-6pm
- **Delivery:** Available on DoorDash, Uber Eats
- **Why it stands out:** [1-2 sentences from review highlights]
- **Sources:** [Google Maps](link) | [Yelp](link) | [Facebook](link)

[Repeat for each High confidence place]

## Other Results (Medium + Low Confidence)
[Briefer format -- name, rating, address, missing data noted]

## What's Missing
[Note any data gaps: "3 places had no website or social presence",
 "Reviews unavailable for BBB-only listings"]

Source links are mandatory. Every place must have at least one clickable source URL (Google Maps link, Yelp listing, website, or social profile). Places without any source link should be noted in "What's Missing" but still included if they have sufficient data from WSA results.

Drill-down: After presenting, tell the user:

"Want details on any place? Say 'tell me more about #3' or ask for the interactive map."

Step 11: Interactive Map (on request or "Deep dive" mode)

Generate an HTML file with Leaflet.js + OpenStreetMap tiles. See references/wsa-pipeline.md for the full map generation pattern and color scheme.

Save to: ~/.nimble/memory/local-places/{slug}-map-{date}.html

Open in browser: open ~/.nimble/memory/local-places/{slug}-map-{date}.html

Only generate automatically if the user chose "Deep dive with map" in Step 1. For map generation details, see references/wsa-pipeline.md. Otherwise, offer it as a follow-up action.

Step 12: Save to Memory

Make all Write calls simultaneously:

• Report -> ~/.nimble/memory/reports/local-places-{slug}-{date}.md
• Per-place data -> ~/.nimble/memory/local-places/{slug}/places.json (structured JSON with all enriched records)
• Profile -> update last_runs.local-places in ~/.nimble/business-profile.json (only if profile exists)
• Follow the wiki update pattern from references/memory-and-distribution.md: update index.md rows for all affected entity files, append a log.md entry for this run.
• Clean up checkpoint (complete run) or keep (partial run)

Step 13: Share & Distribute

Always offer distribution -- do not skip this step. Follow references/memory-and-distribution.md for connector detection, sharing flow, and source links enforcement.

Notion: full results table as a dated subpage. Slack: TL;DR with top 5 places only.

Step 14: Follow-ups

• "Tell me more about #N" -> show full detail for that place
• "Show the map" -> generate interactive map (Step 11)
• "Add filters" -> re-search with additional constraints
• "Search nearby area" -> expand to adjacent neighborhoods
• "Export as CSV" -> generate CSV from places.json
• "Looks good" -> done

Sibling skill suggestions:

Next steps: - Run company-deep-dive for a full 360 profile on any business from this list - Run meeting-prep if you're meeting with someone at one of these businesses - Run competitor-positioning to compare businesses in this area

Sub-Agent Strategy

For comprehensive searches (50+ places), use nimble-researcher agents (agents/nimble-researcher.md) to parallelize enrichment.

Follow the sub-agent spawning rules from references/nimble-playbook.md (bypassPermissions, batch max 4, explicit Bash instruction, fallback on failure). For WSA calls at scale (11+ entities), tell agents to use agent run-batch instead of individual calls. See the Scaled Execution pattern in references/nimble-playbook.md for tier selection. Pass the discovered WSA names from Step 4 to each agent so they use the same cached names.

Spawn pattern: One agent per batch of 10 places for social enrichment. Each agent runs the Phase 2 WSAs for its batch and returns structured results.

Single-batch optimization: If <= 10 places, run enrichment directly from the main context instead of spawning agents -- saves overhead.

Fallback: If any agent fails, run those WSA calls directly from the main context.

Agent Teams Mode (Dual-Mode)

Check at startup: echo $CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS

Team mode (flag set): Spawn teammates for parallel phases:

• Discovery teammate: Runs all Phase 1 WSAs, deduplicates, returns unified list
• Enrichment teammate: Runs Phases 2-4 for each place batch
• Lead (you): Coordinates, scores, generates output and map

Solo mode (flag not set): Standard sequential flow from Steps 4-7.

Error Handling

See references/nimble-playbook.md for the standard error table (missing API key, 429, 401, empty results, extraction garbage). Skill-specific errors:

• WSA/Search 500: Retry once with the same params. If still failing, fall back to nimble search for that place/query. Log the failure but don't skip the place.
• WSA/Search timeout: Retry once, then skip that call and continue — consistent with the playbook's timeout policy.
• WSA not found: If no WSAs are discovered for a phase, skip that phase's WSA calls and fall back to nimble search. Log which phases had no WSA coverage.
• Location not found: "Couldn't find results for [location]. Could you be more specific? Try including city and state (e.g., 'Williamsburg, Brooklyn, NY')."
• No results for place type: "No [place type] found in [location]. Want to try a broader category or nearby area?"
• Ambiguous place type: "Did you mean [option A] or [option B]?" (e.g., "bar" could be cocktail bar, sports bar, wine bar)