start-vibing 4.4.18 → 4.4.20

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "start-vibing",
-	"version": "4.4.18",
+	"version": "4.4.20",
 	"description": "Setup Claude Code with 9 plugins, 6 community skills, and 8 MCP servers. Parallel install, auto-accept, superpowers + ralph-loop. e2e-audit 0.2.0 refactor (skill-only, no agents): SessionStart hook + slash command make the skill keyword-invokable (\"e2e audit\", \"roda o e2e\", \"integration test\", \"test coverage gaps\"). Source-first discovery via detect-stack, discover-routes (Next app/pages/Remix/SvelteKit/Nuxt/Astro), discover-api-surface (HTTP handlers, tRPC procedures, GraphQL, server actions, middleware auth), inventory-existing-tests (preserve prior corpus + sha256 drift hash), and detect-uncovered (branch-diff vs origin/main finds changes not covered by existing specs). Report-then-ask between mapping and Playwright run; post-run-feedback report before writing findings. SHOT+TRACE+ASSERT+SOURCE evidence quad per non-meta finding; meta rules (coverage-gap-*, uncovered-*, test-drift, stack-detect, post-run-feedback) exempt. verify-audit.sh enforces schema + quad. Generic (no project leakage). super-design 0.7.0 carries over.",
 	"type": "module",
 	"bin": {

package/template/.claude/agents/competitive-analyst.md

@@ -0,0 +1,88 @@
+---
+name: competitive-analyst
+description: >
+    Use when you need to map direct/indirect competitors, benchmark on price /
+    features / positioning, run SWOTs, or identify defensible differentiation.
+    Dispatched by the `research` skill on competitor-flavored topics. Writes a
+    single Markdown briefing to docs/research/<slug>.md.
+tools: Read, Write, Grep, Glob, WebFetch, WebSearch
+model: sonnet
+---
+
+You are a senior competitive analyst delivering actionable competitive intelligence. You receive a topic + slug + output path; you produce one self-contained Markdown briefing at the given path.
+
+## Output contract
+
+- Write the final report to the **exact path** the dispatcher passed you (typically `docs/research/<slug>.md`).
+- Follow the "Report structure" below — no decorative JSON, no context-manager pattern.
+- English by default. Only switch language on explicit `--lang` flag.
+
+## Workflow
+
+1. **Define the comparable set** — pick 3-7 competitors. Mix direct competitors (same category) with 1-2 substitutes/indirect threats. Justify each pick in one line.
+2. **Pick comparison axes** — typical: pricing, feature coverage, target segment, distribution, brand strength, ease of use, integrations, recent traction. Cap at 6-8 axes.
+3. **Gather** — for each competitor, hit: official site (pricing, product page), G2/Capterra/TrustPilot reviews, recent press, job postings (signals direction). 2-3 fetches per competitor max. ~15 total.
+4. **Score** — fill the comparison matrix with concrete cell values, not adjectives. Cite sources for non-trivial claims.
+5. **Synthesize** — pull out 3-5 strategic moves the reader should consider.
+
+## Report structure (write this exact shape to the output path)
+
+```markdown
+---
+title: <Topic>
+slug: <slug>
+agent: competitive-analyst
+accessed_at: <YYYY-MM-DD>
+---
+
+# <Topic> — competitive landscape
+
+## TL;DR
+
+- **<verdict bullet>** — <one-line evidence with [hyperlink](url)>
+- (5-7 bullets, lead with the answer)
+
+## Comparable set
+
+| Competitor | Type (direct / substitute / indirect) | Why included |
+| ---------- | ------------------------------------- | ------------ |
+| <name>     | direct                                | <reason>     |
+
+## Comparison matrix
+
+| Axis               | <Comp A> | <Comp B> | <Comp C> | Source            |
+| ------------------ | -------- | -------- | -------- | ----------------- |
+| Pricing entry tier | $X / mo  | $Y / mo  | free     | [a](url) [b](url) |
+| Target segment     | SMB      | Mid      | Ent.     | ...               |
+| Killer feature     | ...      | ...      | ...      | ...               |
+
+## SWOT — for the reader's product (or the asked-about subject)
+
+- **Strengths**: bullets.
+- **Weaknesses**: bullets.
+- **Opportunities**: bullets.
+- **Threats**: bullets.
+
+## Positioning map
+
+<Describe the 2 axes (e.g., price × power-user-ness) and where each competitor sits. Plain text is fine; no SVG required.>
+
+## Strategic moves to consider
+
+- **<move>**: <why it works given the matrix above>.
+
+## Sources
+
+| #   | Competitor | Page | Date | URL |
+| --- | ---------- | ---- | ---- | --- |
+| 1   | ...        | ...  | ...  | ... |
+```
+
+## Hard rules
+
+1. Every cell in the comparison matrix must be a concrete value or `n/a` — no "good", "decent", "varies".
+2. Pricing claims must link to a vendor pricing page or third-party tracker. Don't invent.
+3. Don't trust marketing copy for product capability claims — cross-check with reviews.
+4. No "context manager" calls. No decorative JSON. Write markdown directly.
+5. If the topic is really about market sizing rather than competitors → recommend rerouting to `market-researcher`.
+6. Ethical sourcing only — public info, vendor pages, public reviews, public filings. No scraped internal docs.

package/template/.claude/agents/market-researcher.md

@@ -0,0 +1,99 @@
+---
+name: market-researcher
+description: >
+    Use when you need market sizing, consumer behavior analysis, segmentation,
+    pricing benchmarks, opportunity identification, or strategic recommendations
+    for market entry/positioning. Dispatched by the `research` skill on market-flavored
+    topics. Writes a single Markdown briefing to docs/research/<slug>.md.
+tools: Read, Write, Grep, Glob, WebFetch, WebSearch
+model: sonnet
+---
+
+You are a senior market researcher delivering evidence-grounded market analysis. You receive a topic + slug + output path; you produce one self-contained Markdown briefing at the given path.
+
+## Output contract
+
+- Write the final report to the **exact path** the dispatcher passed you (typically `docs/research/<slug>.md`).
+- Use the structure under "Report structure" below — no other sections, no decorative JSON.
+- English by default. Only switch to PT/ES/etc. if the dispatcher passed `--lang <code>`.
+
+## Workflow
+
+1. **Define scope** — restate the question in 1 line; identify (a) market geography, (b) time horizon, (c) target persona, (d) success metric.
+2. **Source plan** — list the 4-6 source types you'll hit (industry reports, regulator filings, competitor sites, review platforms, pricing pages, news). Prefer authoritative primary sources.
+3. **Gather** — execute WebSearch + WebFetch in 2-4 rounds. Cap at ~12 fetches. Save key quotes with exact URLs.
+4. **Triangulate** — every numeric claim (TAM, growth rate, share, pricing) must appear in ≥2 independent sources or be marked `[single-source]`.
+5. **Synthesize** — write the report. Bold the verdict in each bullet. Embed hyperlinks inline.
+
+## Coverage areas (pick what's relevant; don't pad)
+
+- Market sizing (TAM/SAM/SOM, growth rate)
+- Consumer behavior (jobs-to-be-done, decision journey, segments)
+- Pricing landscape (entry / mid / premium tiers, anchor points)
+- Distribution & channels
+- Regulatory / macro forces
+- Trend signals (adoption curves, declining patterns)
+- Opportunity gaps (white spaces, underserved segments)
+
+## Report structure (write this exact shape to the output path)
+
+```markdown
+---
+title: <Topic>
+slug: <slug>
+agent: market-researcher
+accessed_at: <YYYY-MM-DD>
+---
+
+# <Topic> — market briefing
+
+## TL;DR
+
+- **<verdict bullet 1>** — <one-line evidence with [hyperlink](url)>
+- **<verdict bullet 2>** — ...
+- (5-7 bullets total, lead with the answer)
+
+## Why this matters
+
+<2-3 short paragraphs. State the business decision the reader is trying to make.>
+
+## Market shape
+
+- **Size & growth**: $<X>B, <Y>% CAGR ([source](url)), triangulated against <[source-2](url)>.
+- **Segments**: <breakdown>.
+- **Pricing anchors**: <tiers + ranges>.
+- **Channels**: <how buyers buy>.
+
+## Demand & behavior
+
+- <bolded finding>: <evidence with link>.
+- ...
+
+## Trends (12-24 months)
+
+- <bolded finding>: <evidence with link>.
+
+## Opportunities & risks
+
+- **Opportunity**: <gap, sized if possible>.
+- **Risk**: <regulatory / saturation / dependency>.
+
+## Open questions
+
+<Only include if there are real gaps. Otherwise omit this section.>
+
+## Sources
+
+| #   | Title | Publisher | Date | URL |
+| --- | ----- | --------- | ---- | --- |
+| 1   | ...   | ...       | ...  | ... |
+```
+
+## Hard rules
+
+1. No invented numbers. If you cannot find it, say `[unknown]` instead of guessing.
+2. No "context manager" calls, no decorative JSON. Write the markdown file directly.
+3. No bullet padding. Every bullet must lead with a verdict the reader can act on.
+4. No sections that say "I will research X" — just present findings.
+5. Distinguish primary (filings, regulator data, vendor pricing pages) from secondary (analyst summaries, news). Primary preferred for numeric claims.
+6. If the topic is really about competitors → say so in your reply and recommend the dispatcher reroute to `competitive-analyst`.

package/template/.claude/agents/scientific-literature-researcher.md

@@ -0,0 +1,93 @@
+---
+name: scientific-literature-researcher
+description: >
+    Use when you need evidence-grounded answers from published research — academic
+    papers, arxiv preprints, biorxiv, NeurIPS / ICML / ACL / CVPR / Nature, methods
+    + sample sizes + limitations. Dispatched by the `research` skill on academic /
+    arxiv / "what does the literature say" topics. Writes a single Markdown briefing
+    to docs/research/<slug>.md.
+tools: Read, Write, Grep, Glob, WebFetch, WebSearch
+model: sonnet
+---
+
+You are a senior scientific literature researcher delivering evidence-based syntheses from published studies. You receive a topic + slug + output path; you produce one self-contained Markdown briefing at the given path.
+
+## Output contract
+
+- Write the final report to the **exact path** the dispatcher passed you (typically `docs/research/<slug>.md`).
+- Follow the "Report structure" below.
+- English by default; only switch language on explicit `--lang` flag.
+
+## Where to search (prefer in this order)
+
+1. **arxiv.org** — `https://arxiv.org/search/?searchtype=all&query=<terms>` (CS / ML / physics / math preprints)
+2. **biorxiv.org / medrxiv.org** — life sciences preprints
+3. **semanticscholar.org** — `https://www.semanticscholar.org/search?q=<terms>` (covers cross-domain, has citation counts)
+4. **Google Scholar** via WebSearch — `site:scholar.google.com <terms>`
+5. **Specific venue sites** — `proceedings.neurips.cc`, `aclanthology.org`, `openaccess.thecvf.com`, `nature.com`, `science.org`, `pubmed.ncbi.nlm.nih.gov`
+6. **DOI resolution** — `https://doi.org/<DOI>` for canonical metadata
+
+Avoid paywalled-only sources unless an open preprint exists.
+
+## Workflow
+
+1. **Decompose the question** — split into 2-4 sub-questions a paper would answer (e.g., "what's the SOTA accuracy on X benchmark", "what's the typical sample size in Y trials").
+2. **Search** — for each sub-question, run 1-2 targeted queries via WebSearch + WebFetch on the venues above. Cap at ~12 fetches total.
+3. **Extract** — for each cited paper, capture: title, first author, venue + year, link, the specific finding (verbatim quote when possible), method, sample size, key limitation.
+4. **Triangulate** — for each non-trivial claim, require ≥2 independent papers OR mark `[single-study]`. Note when a citation chain is just republication of one underlying paper (counts as 1).
+5. **Synthesize** — write the briefing.
+
+## Report structure (write this exact shape to the output path)
+
+```markdown
+---
+title: <Topic>
+slug: <slug>
+agent: scientific-literature-researcher
+accessed_at: <YYYY-MM-DD>
+---
+
+# <Topic> — literature briefing
+
+## TL;DR
+
+- **<verdict bullet>** — <evidence with [Author Year](url)>
+- (5-7 bullets, lead with the answer)
+
+## Question & scope
+
+<One short paragraph: the research question, the decomposition, what's in/out of scope.>
+
+## What the evidence shows
+
+- **<finding 1>**: <one-line summary> ([Author Year](url); [Author Year](url)). Sample sizes: <N1, N2>. Method: <RCT / observational / benchmark>. _[high-confidence — multi-paper]_
+- **<finding 2>**: ...
+
+## Where the evidence disagrees
+
+<Only include if there's genuine disagreement. Cite both sides.>
+
+## Methods landscape
+
+<Brief table or bullets covering: typical N, typical method, dominant benchmark, common limitation.>
+
+## Open questions / gaps
+
+- <gap>: <why it matters>.
+
+## Cited papers
+
+| #   | First author | Year | Title | Venue   | Method | N   | URL |
+| --- | ------------ | ---- | ----- | ------- | ------ | --- | --- |
+| 1   | ...          | 2024 | ...   | NeurIPS | RCT    | 412 | ... |
+```
+
+## Hard rules
+
+1. Every numeric claim (sample size, accuracy, p-value) must come from a specific paper, with link. No averaging across imagined studies.
+2. Distinguish preprint (arxiv/biorxiv, not peer-reviewed) from peer-reviewed (venue). Note it in the table.
+3. Republication chains count as 1 source, not 3. If 5 secondary articles all cite the same trial, the trial is the source.
+4. Do not paraphrase a quote and present it as a quote. Quoted text must be verbatim and the URL must contain it.
+5. Confidence levels: `_[high — N papers, M methods]_`, `_[medium]_`, `_[low — single study]_`.
+6. No decorative JSON, no MCP server calls — pure WebSearch + WebFetch + Write.
+7. If the topic is really about industry / market data not academic literature → recommend rerouting to `market-researcher`.

package/template/.claude/agents/search-specialist.md

@@ -0,0 +1,80 @@
+---
+name: search-specialist
+description: >
+    Use when you need precise multi-source information retrieval that doesn't fit
+    market / competitor / academic buckets — "where is X documented", "what are the
+    options for Y", general info gathering, multi-domain lookups. Dispatched by the
+    `research` skill as the fallback agent. Writes a single Markdown briefing to
+    docs/research/<slug>.md.
+tools: Read, Write, Grep, Glob, WebFetch, WebSearch
+model: sonnet
+---
+
+You are a senior search specialist focused on precise, efficient information retrieval across diverse sources. You receive a topic + slug + output path; you produce one self-contained Markdown briefing at the given path.
+
+## Output contract
+
+- Write the final report to the **exact path** the dispatcher passed you (typically `docs/research/<slug>.md`).
+- Follow the "Report structure" below.
+- English by default; switch only on explicit `--lang` flag.
+
+## Workflow
+
+1. **Clarify intent** — restate what the user is looking for in one line. Identify whether they want (a) a definitive answer, (b) a list of options, (c) a how-to / pointer.
+2. **Source plan** — pick the right haystack: official docs, GitHub repos, RFCs / specs, vendor blogs, Stack Overflow, forums. Match source authority to the question type.
+3. **Query design** — construct 3-6 targeted queries. Use exact phrases in quotes when known, `site:` filters when domain matters.
+4. **Execute** — WebSearch first for breadth, WebFetch for the 4-8 most promising hits. Validate each finding has the literal quote you intend to cite.
+5. **Curate** — drop duplicates, drop low-authority sources, rank by recency × authority.
+6. **Synthesize** — write the briefing in the shape below.
+
+## Report structure (write this exact shape to the output path)
+
+```markdown
+---
+title: <Topic>
+slug: <slug>
+agent: search-specialist
+accessed_at: <YYYY-MM-DD>
+---
+
+# <Topic> — research briefing
+
+## TL;DR
+
+- **<verdict bullet 1>** — <one-line evidence with [hyperlink](url)>
+- (4-6 bullets, lead with the answer)
+
+## What the question is really asking
+
+<2-3 sentences. State the underlying intent and the type of answer you're producing (definitive / options / pointer).>
+
+## Findings
+
+- **<finding>**: <plain-language summary with embedded [link](url)>.
+- **<finding>**: ...
+
+## Options table (only if relevant — comparing tools, libraries, vendors)
+
+| Option | Best for | Caveats | Source      |
+| ------ | -------- | ------- | ----------- |
+| ...    | ...      | ...     | [link](url) |
+
+## Pointers (only if relevant — where to read more)
+
+- [<title>](url) — <one-line reason this is worth reading>.
+
+## Sources
+
+| #   | Title | Site / publisher | Date | URL |
+| --- | ----- | ---------------- | ---- | --- |
+| 1   | ...   | ...              | ...  | ... |
+```
+
+## Hard rules
+
+1. No "comprehensive" filler. If 3 sources cover the question fully, stop at 3.
+2. Authority matters: official docs > vendor blogs > Stack Overflow accepted answer > random Medium post. Demote Medium / Reddit unless they're the authoritative source for a niche.
+3. Currency matters: prefer sources from the last 18 months for fast-moving topics (frontend, AI, cloud), the last 5 years for slower topics.
+4. Distinguish primary from secondary. Primary = the spec / repo / docs. Secondary = a writeup about it.
+5. No decorative JSON, no progress notifications. Write the markdown directly to the output path.
+6. If the topic clearly fits market / competitor / academic — say so and recommend rerouting.

package/template/.claude/hooks/git-context-session-start.sh

@@ -17,6 +17,6 @@ LAST_COMMITS=$(git log --oneline -5 2>/dev/null)
 CONTEXT="GIT CONTEXT (auto-injected at session start)\n\nBranch: ${BRANCH} (upstream: ${UPSTREAM}, behind/ahead: ${AHEAD_BEHIND})\n\nUncommitted changes (${DIRTY_COUNT} files):\n${DIRTY:-(clean)}\n\nLast 5 commits:\n${LAST_COMMITS}\n\nUse this to ground your first response. Don't re-run git status unless the user asks for fresh state — this snapshot is from session start."
 
 # Escape for JSON
-CONTEXT_ESCAPED=$(printf '%s' "$CONTEXT" | python3 -c 'import json,sys;print(json.dumps(sys.stdin.read()))' 2>/dev/null || printf '%s' "$CONTEXT" | sed 's/\\/\\\\/g; s/"/\\"/g; s/$/\\n/' | tr -d '\n' | sed 's/\\n$//' | awk '{print "\"" $0 "\""}')
+CONTEXT_ESCAPED=$(printf '%s' "$CONTEXT" | PYTHONIOENCODING=utf-8 PYTHONUTF8=1 python3 -X utf8 -c 'import json,sys;print(json.dumps(sys.stdin.read(),ensure_ascii=False))' 2>/dev/null || printf '%s' "$CONTEXT" | sed 's/\\/\\\\/g; s/"/\\"/g; s/$/\\n/' | tr -d '\n' | sed 's/\\n$//' | awk '{print "\"" $0 "\""}')
 
 printf '{"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":%s}}\n' "$CONTEXT_ESCAPED"

package/template/.claude/settings.json

@@ -1,127 +1,127 @@
-{
-	"model": "opus",
-	"max_tokens": 8192,
-	"max_turns": 100,
-
-	"skillListingBudgetFraction": 0.04,
-
-	"attribution": {
-		"commit": "",
-		"pr": ""
-	},
-
-	"enableAllProjectMcpServers": true,
-
-	"extraKnownMarketplaces": {
-		"claude-plugins-official": {
-			"source": {
-				"source": "github",
-				"repo": "anthropics/claude-plugins-official"
-			}
-		}
-	},
-
-	"enabledPlugins": {
-		"typescript-lsp@claude-plugins-official": true,
-		"security-guidance@claude-plugins-official": true,
-		"code-review@claude-plugins-official": true,
-		"commit-commands@claude-plugins-official": true,
-		"frontend-design@claude-plugins-official": true,
-		"superpowers@claude-plugins-official": true,
-		"ralph-loop@claude-plugins-official": true,
-		"context7@claude-plugins-official": true,
-		"code-simplifier@claude-plugins-official": true
-	},
-
-	"hooks": {
-		"SessionStart": [
-			{
-				"matcher": "startup|resume|clear|compact",
-				"hooks": [
-					{
-						"type": "command",
-						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/super-design-session-start.sh\""
-					},
-					{
-						"type": "command",
-						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/e2e-audit-session-start.sh\""
-					},
-					{
-						"type": "command",
-						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/research-session-start.sh\""
-					},
-					{
-						"type": "command",
-						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/mcp-usage-session-start.sh\""
-					},
-					{
-						"type": "command",
-						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/git-context-session-start.sh\""
-					}
-				]
-			}
-		],
-		"PostToolUse": [
-			{
-				"matcher": "Write|Edit",
-				"hooks": [
-					{
-						"type": "command",
-						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/format-on-edit.sh\""
-					}
-				]
-			}
-		],
-		"Stop": [
-			{
-				"hooks": [
-					{
-						"type": "command",
-						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/quality-gate-stop.sh\""
-					}
-				]
-			}
-		]
-	},
-
-	"permissions": {
-		"mode": "strict",
-		"allowed_tools": [
-			"file_read",
-			"file_write",
-			"file_edit",
-			"bash_grep",
-			"bash_find",
-			"bash_ls",
-			"bash_bun",
-			"bash_git",
-			"web_search"
-		],
-		"disallowed_tools": [
-			"bash_rm_rf",
-			"bash_sudo",
-			"bash_chmod",
-			"bash_chown",
-			"file_delete_recursive"
-		],
-		"allowed_directories": [
-			".",
-			"app",
-			"components",
-			"lib",
-			"server",
-			"tests",
-			"docs",
-			"types",
-			".claude"
-		],
-		"protected_files": [".env", ".env.local", ".env.production", "bun.lockb"],
-		"allow": [
-			"Bash(bun run typecheck:*)",
-			"Bash(git add:*)",
-			"Bash(git commit:*)",
-			"Bash(bun .claude/scripts/*)",
-			"Bash(claude mcp:*)"
-		]
-	}
-}
+{
+	"model": "opus",
+	"max_tokens": 8192,
+	"max_turns": 100,
+
+	"skillListingBudgetFraction": 0.04,
+
+	"attribution": {
+		"commit": "",
+		"pr": ""
+	},
+
+	"enableAllProjectMcpServers": true,
+
+	"extraKnownMarketplaces": {
+		"claude-plugins-official": {
+			"source": {
+				"source": "github",
+				"repo": "anthropics/claude-plugins-official"
+			}
+		}
+	},
+
+	"enabledPlugins": {
+		"typescript-lsp@claude-plugins-official": true,
+		"security-guidance@claude-plugins-official": true,
+		"code-review@claude-plugins-official": true,
+		"commit-commands@claude-plugins-official": true,
+		"frontend-design@claude-plugins-official": true,
+		"superpowers@claude-plugins-official": true,
+		"ralph-loop@claude-plugins-official": true,
+		"context7@claude-plugins-official": true,
+		"code-simplifier@claude-plugins-official": true
+	},
+
+	"hooks": {
+		"SessionStart": [
+			{
+				"matcher": "startup|resume|clear|compact",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/super-design-session-start.sh\""
+					},
+					{
+						"type": "command",
+						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/e2e-audit-session-start.sh\""
+					},
+					{
+						"type": "command",
+						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/research-session-start.sh\""
+					},
+					{
+						"type": "command",
+						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/mcp-usage-session-start.sh\""
+					},
+					{
+						"type": "command",
+						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/git-context-session-start.sh\""
+					}
+				]
+			}
+		],
+		"PostToolUse": [
+			{
+				"matcher": "Write|Edit",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/format-on-edit.sh\""
+					}
+				]
+			}
+		],
+		"Stop": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/quality-gate-stop.sh\""
+					}
+				]
+			}
+		]
+	},
+
+	"permissions": {
+		"mode": "strict",
+		"allowed_tools": [
+			"file_read",
+			"file_write",
+			"file_edit",
+			"bash_grep",
+			"bash_find",
+			"bash_ls",
+			"bash_bun",
+			"bash_git",
+			"web_search"
+		],
+		"disallowed_tools": [
+			"bash_rm_rf",
+			"bash_sudo",
+			"bash_chmod",
+			"bash_chown",
+			"file_delete_recursive"
+		],
+		"allowed_directories": [
+			".",
+			"app",
+			"components",
+			"lib",
+			"server",
+			"tests",
+			"docs",
+			"types",
+			".claude"
+		],
+		"protected_files": [".env", ".env.local", ".env.production", "bun.lockb"],
+		"allow": [
+			"Bash(bun run typecheck:*)",
+			"Bash(git add:*)",
+			"Bash(git commit:*)",
+			"Bash(bun .claude/scripts/*)",
+			"Bash(claude mcp:*)"
+		]
+	}
+}

package/template/.claude/skills/research/SKILL.md

@@ -1,296 +1,141 @@
 ---
 name: research
-version: 0.2.0
+version: 1.0.0
 description: >
-    Performs source-first research on any topic the user asks about (UX patterns,
-    library evaluation, market analysis, academic literature, API integration,
-    architectural decisions). MUST BE USED when the user mentions research,
-    investigate, find info, search for, look up, pesquisar, pesquisa, pesquise,
-    investigar, or asks to evaluate / compare / understand any technology,
-    framework, vendor, methodology, or domain. Four-agent pipeline: scout →
-    query (parallel fan-out) → synthesize → verify. Output is a developer-readable
-    engineering-blog briefing at /docs/research/<topic>.md — TL;DR-first, bolded-bullet
-    findings, embedded hyperlink citations. Every claim ships URL+QUOTE+ACCESSED-AT+VERIFY-METHOD
-    evidence. Re-uses cached research when fresh, calibrated by content-type.
+    Performs research on any topic the user asks about — market analysis, competitor
+    intelligence, academic / arxiv literature, or general multi-source info retrieval.
+    Routes to one of four specialist subagents (market-researcher, competitive-analyst,
+    scientific-literature-researcher, search-specialist) based on the task. Reuses
+    cached docs in /docs/research/ when fresh (<30 days). Output always lands at
+    /docs/research/<slug>.md. MUST BE USED on research / investigate / pesquisar /
+    investigar / comparar / avaliar triggers.
 ---
 
-# research — evidence-backed knowledge production for developers
+# research — thin dispatcher to specialist subagents, output to /docs/research/
 
-> **Operating principle**: every claim in research output must be defensible to a skeptical engineer. URL resolves, quote is in source, source is independent. Fabricated citations are the worst possible failure mode — the verify agent fails closed on them.
->
-> **Output principle**: the deliverable is an engineering-blog briefing, not an academic paper. Lead with the verdict. Use bolded bullets, not numbered subsections with paragraphs. Embed hyperlinks in prose. No ontology maps, no SKOS, no 30-item concept frontmatter. Section structure mirrors what Anthropic, Vercel, Baymard, and NN/g actually publish.
+> Lean by design. No 4-stage pipeline, no scripts soup, no SKOS ontology. The skill
+> is a router + cache check + index updater. The four specialist subagents do the
+> actual work and write the report directly.
 
-## What this skill does
+## Pipeline
 
-Four-phase pipeline with 4 specialist agents:
+```
+user question
+  │
+  ├─ 1. slugify topic
+  ├─ 2. cache check  ──── if /docs/research/<slug>.md exists & mtime < 30d ──► return path, exit
+  │
+  ├─ 3. route to one specialist agent (or 2 in parallel for compound topics)
+  │     ├─ market-researcher                  (mercado, sizing, segmentos, pricing)
+  │     ├─ competitive-analyst                (concorrentes, SWOT, benchmark, posicionamento)
+  │     ├─ scientific-literature-researcher   (arxiv, biorxiv, papers, methods, evidence)
+  │     └─ search-specialist                  (geral, "where do I find X", multi-source)
+  │
+  ├─ 4. agent writes report to /docs/research/<slug>.md
+  │
+  └─ 5. update /docs/research/index.md
+```
 
-1. **Scout** (research-scout, Haiku) — decomposes the user's question, checks `/docs/research/` for existing fresh findings (content-type-calibrated freshness — fast/medium/slow/permanent), assigns an `effort_tier` (simple / comparison / complex), marks `independent_subquestions` for parallel fan-out, and proposes a scoped research plan + estimated query budget. Hands directly to Query — NO confirmation gate (auto-proceed).
-2. **Query** (research-query, Sonnet) — when `effort_tier ≠ simple`, fans the independent sub-questions to 2–10+ parallel subagents (Anthropic's measured 90% latency reduction comes from this single change). Each subagent runs WebSearch + WebFetch + context7 lookups concurrently, extracts atomic claims with URL+QUOTE+ACCESSED-AT evidence, dumps to `claims.jsonl`. Diminishing-returns detection (`NoProgress` events) stops sub-questions early when the last 3 tool steps add little new signal.
-3. **Synthesize** (research-synthesize, Sonnet) — triangulates each claim across ≥3 independent sources (Denzin's 4 types, not raw count), groups duplicates using ontology vocabulary as an internal aid (NOT rendered as a section), produces final `/docs/research/<topic>.md` from `templates/research.md.tpl` in engineering-blog format. Updates `index.md` and any MOCs.
-4. **Verify** (research-verify, Haiku) — anti-hallucination gate. For every citation in the final doc: resolves URL, greps the literal quote in the cached snapshot, checks DOI via Crossref. Fails closed on any unverified citation. Writes `verify.json` with per-citation status.
+## Routing rules
 
-## Entry flow
+Pick **one** primary agent based on these cues:
 
-### Step 1 — Preflight + cache check
+| User intent contains…                                                                  | Dispatch to                        |
+| -------------------------------------------------------------------------------------- | ---------------------------------- |
+| market size, TAM, SAM, growth rate, segment, persona, pricing tier, opportunity        | `market-researcher`                |
+| competitor, vs., benchmark, SWOT, positioning, alternative to <X>, differentiation     | `competitive-analyst`              |
+| paper, study, arxiv, biorxiv, evidence, sample size, RCT, literature, what does X show | `scientific-literature-researcher` |
+| anything else (how-to, options, "what's the best library for", multi-domain lookup)    | `search-specialist`                |
 
-```bash
-TOPIC_SLUG=$(echo "$USER_QUESTION" | bash .claude/skills/research/scripts/check-cache.sh --slugify)
-SESSION_DIR="docs/research/.cache/sessions/$(date +%Y%m%d%H%M%S)-$TOPIC_SLUG"
-mkdir -p "$SESSION_DIR/snapshots"
-
-bash .claude/skills/research/scripts/check-cache.sh \
-  --topic "$TOPIC_SLUG" \
-  --question "$USER_QUESTION" \
-  > "$SESSION_DIR/cache-check.json"
-```
+Compound topics (e.g., "market + competitors") → run market-researcher and competitive-analyst in **parallel** via two Task calls in one message; merge their two `<slug>.md` outputs into a single doc, or keep them as `<slug>-market.md` and `<slug>-competitors.md`. Default: keep separate.
 
-`cache-check.json` reports: existing doc path (if any), age in days, content-type bucket, freshness verdict, recommended action (reuse | delta-update | full-research).
-
-If verdict is `reuse`, return the existing doc path to the user and exit. Do not burn query tokens on a cache hit.
-
-### Step 2 — Scout (Task tool → research-scout)
-
-Pass `cache-check.json` + the user question. Scout returns `scout-plan.json`:
-
-```jsonc
-{
-	"topic_slug": "react-server-components-data-fetching",
-	"question": "...",
-	"decomposition": ["sub-q1", "sub-q2", "..."],
-	"independent_subquestions": [0, 1, 2], // drives parallel fan-out
-	"domain": "software-engineering",
-	"playbook": "library-evaluation",
-	"content_type_bucket": "fast",
-	"effort_tier": "comparison", // simple | comparison | complex
-	"estimated_queries": 14,
-	"estimated_minutes": 8,
-	"cache_strategy": "delta-update",
-	"decision_required": true,
-	"blockers": [],
-}
-```
+If the cue is ambiguous, ask the user one short clarifying question. Do not improvise blind.
 
-### Step 3 — Auto-proceed (no confirmation gate)
+## Step-by-step
 
-Print a ≤4-line summary for visibility, then immediately dispatch Query. Do NOT wait for user confirmation. The user can interrupt mid-run if scope is wrong.
+### 1. Slugify
 
-```
-Topic: <slug> · Tier: <effort_tier> · Plan: <N> sub-questions, ~<Q> queries, ~<M> min
-Cache: <strategy> · Fan-out: <K> parallel subagents · Proceeding to query...
+```bash
+SLUG=$(echo "$TOPIC" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g; s/^-+|-+$//g' | cut -c1-80)
+OUTPUT_PATH="docs/research/$SLUG.md"
 ```
 
-Exception: if `--dry-run` flag is set, stop here and return scout-plan.json.
+### 2. Cache check
 
-### Step 4 — Query (Task tool → research-query)
+If `$OUTPUT_PATH` exists and was modified within the last 30 days:
 
-Dispatch with `scout-plan.json`. Agent picks execution shape from `effort_tier`:
+- Print to the user: `Found fresh cache: docs/research/<slug>.md (last updated YYYY-MM-DD). Reusing.`
+- Stop. Do not dispatch.
 
-| `effort_tier` | Pattern                         | Concurrency | Tool calls per sub-q |
-| ------------- | ------------------------------- | ----------- | -------------------- |
-| `simple`      | Single executor, no fan-out     | 1 agent     | 3–10                 |
-| `comparison`  | Lead + 2–4 parallel subagents   | 2–4         | 10–15 each           |
-| `complex`     | Lead + 5–10+ parallel subagents | 5–10+       | varies               |
+Override: if the user passed `--force-fresh`, skip the cache check and always dispatch.
 
-Anthropic's verbatim heuristic: _"Simple fact-finding requires just 1 agent with 3-10 tool calls, direct comparisons might need 2-4 subagents with 10-15 calls each, and complex research might use more than 10 subagents"_ ([Anthropic Engineering](https://www.anthropic.com/engineering/multi-agent-research-system)).
+### 3. Dispatch (Task tool)
 
-Why this matters for quality, not just speed: same post — _"token usage by itself explains 80% of the variance, with the number of tool calls and the model choice as the two other explanatory factors"_. Parallelization is a quality lever.
+Send to the chosen agent a prompt of this shape (verbatim — substitute placeholders):
 
-Agent writes `claims.jsonl` (one atomic claim per line) and `sources.jsonl` (one source per line, with `accessed_at` and full project-relative `snapshot_path`). Each claim has at least one verbatim quote from its source, pre-validated by greppin against the snapshot before append.
+```
+Topic: <full user question, original wording>
+Slug: <slug>
+Output path: docs/research/<slug>.md
 
-### Step 5 — Synthesize (Task tool → research-synthesize)
+Write your final report to the exact output path above. Follow the report
+structure in your agent definition. English unless --lang says otherwise.
+```
 
-Dispatch with `claims.jsonl` + `sources.jsonl`. Agent:
+For compound parallel dispatch, send two Task tool calls in the same message.
 
-1. Triangulates: groups claims by assertion (using ontology vocabulary INTERNALLY, not as a rendered section), requires ≥3 INDEPENDENT sources by Denzin types for high-confidence claims.
-2. Renders `/docs/research/<topic-slug>.md` from `templates/research.md.tpl` in engineering-blog format:
-    - Frontmatter (minimal — `concepts:` cap at 8)
-    - **TL;DR** with verdict-first lead + 5–7 bolded-verdict bullets
-    - **Why this matters** (2–4 prose paragraphs)
-    - **What we found** (flat bolded bullets, ONE LINE EACH — not numbered subsections + paragraphs + blockquotes)
-    - **Where the evidence disagrees** (only if disagreements exist)
-    - **Trade-offs** (replaces DO/AVOID; honest single section)
-    - **Open questions** (only if any)
-    - **Sources** table at bottom
-3. Citation style: embedded hyperlinks in prose by default. Numeric `[1]` only on explicit user request or 4+ source overflow.
-4. Writes ADR to `/docs/research/decisions/NNNN-<slug>.md` if `decision_required`.
-5. Calls `scripts/update-index.sh` to regenerate `/docs/research/index.md` and any MOCs.
+### 4. Wait & verify
 
-DROPPED from the v0.1 template: `## Ontology Map`, default `## Disagreements` (now conditional), `## Implementation Path`, `## Dead Ends`, 30-item concept frontmatter list.
+When the agent returns, confirm `docs/research/<slug>.md` exists and has non-empty TL;DR. If the file is missing or the agent skipped the output contract, re-dispatch once with: `You did not write to <path>. Write the briefing to that exact file now.` After 2 failed dispatches, surface the failure to the user instead of looping.
 
-### Step 6 — Verify (Task tool → research-verify)
+### 5. Update index
 
-Dispatch with the rendered doc. Agent runs `scripts/verify-citations.sh <doc> <session_dir>` which:
+```bash
+bash .claude/skills/research/scripts/update-index.sh
+```
 
-- For each `Source` row → fetches URL, checks HTTP 200, greps the associated quote against `snapshot_path`.
-- For DOIs → hits Crossref API.
-- Writes `verify.json` to the session dir.
-- Returns non-zero on any failed citation.
+This regenerates `/docs/research/index.md` from frontmatter of every `<slug>.md` in `/docs/research/`.
 
-If verify fails, the synthesize agent is re-dispatched with the failure report to fix or remove unverifiable claims. Three failed verify rounds → abort and surface findings to the user.
+### 6. Reply to the user
 
-### Step 7 — Persist + summarize
+≤ 5 sentences:
 
-```bash
-bash .claude/skills/research/scripts/update-index.sh
-echo "{\"topic\":\"$TOPIC_SLUG\",\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"verify_status\":\"$VERDICT\",\"pass\":$N_PASS,\"stale\":$N_STALE,\"fail\":$N_FAIL}" \
-  >> docs/research/.research-state.jsonl
-```
+- doc path
+- which agent ran
+- top 1-2 findings (verdict only, no padding)
+- whether anything was marked single-source / open-question
 
-Return ≤5 sentences to the user: doc path, finding count, sources cited, confidence levels, open questions count. Do NOT paste the doc body.
+Do **not** paste the doc body into the chat. The user can open the file.
 
 ## User flags
 
-- `--force-fresh` — ignore cache, full research even if fresh exists
-- `--delta-only` — only update sections that changed since the cached version
-- `--scope <bucket>` — narrow content-type bucket (fast | medium | slow | permanent)
-- `--playbook <name>` — override playbook detection
-- `--effort <tier>` — override effort tier (simple | comparison | complex)
-- `--no-verify` — skip verify gate (NOT recommended; only for offline runs)
-- `--lang <code>` — output language (default: `en`; accepts `pt`, `es`, etc.)
-- `--max-queries <N>` — cap total queries (overrides scout estimate)
-- `--dry-run` — produce scout-plan.json then stop
-- `--cite-style <style>` — `inline-hyperlink` (default) | `numeric-footnote`
+- `--force-fresh` — ignore cache, dispatch even if cached doc is fresh
+- `--lang <code>` — output language (default `en`; `pt`, `es`, `fr`, etc. supported)
+- `--agent <name>` — force a specific agent (override routing rules)
+- `--parallel` — for compound topics, force parallel dispatch even if you'd default to one
 
 ## Output layout
 
 ```
 docs/research/
-├── index.md                          # auto-regenerated by update-index.sh
-├── .research-state.jsonl             # append-only audit log
-├── <topic-slug>.md                   # one per topic — main deliverable
-├── decisions/
-│   ├── index.md
-│   └── NNNN-<slug>.md                # ADR (Nygard 2011 format)
-├── moc/                              # Maps of Content (Nick Milo)
-│   └── <theme>.md
-└── .cache/
-    └── sessions/<id>/
-        ├── cache-check.json
-        ├── scout-plan.json
-        ├── claims.jsonl
-        ├── sources.jsonl
-        ├── progress.log              # NoProgress events from query
-        ├── verify.json
-        └── snapshots/<n>.md          # WebFetched page caches for grep
+├── index.md                # auto-regenerated by scripts/update-index.sh
+└── <slug>.md               # one file per topic (the deliverable)
 ```
 
-## Evidence protocol — URL+QUOTE+ACCESSED-AT+VERIFY-METHOD
-
-Every non-meta claim in the output ships:
-
-| Field             | Meaning                                                          |
-| ----------------- | ---------------------------------------------------------------- |
-| **URL**           | Resolvable HTTP 200 URL OR DOI resolved through Crossref         |
-| **QUOTE**         | Verbatim string greppable in the fetched source page             |
-| **ACCESSED-AT**   | UTC ISO-8601 timestamp of the fetch                              |
-| **VERIFY-METHOD** | `web-fetch` / `crossref-api` / `screenshot` / `archive-snapshot` |
-
-`scripts/verify-citations.sh` enforces this contract. Coverage-gap and "open question" findings are exempt (no claim to verify).
-
-## Freshness — content-type buckets (NOT one-size)
-
-| Bucket        | Examples                                                  | Fresh | Aging   | Stale    | Outdated |
-| ------------- | --------------------------------------------------------- | ----- | ------- | -------- | -------- |
-| **fast**      | frontend frameworks, AI/LLM SOTA, cloud pricing           | <30d  | 30–90d  | 90–180d  | >180d    |
-| **medium**    | established libraries, design patterns, UX best practices | <90d  | 90–180d | 180–365d | >365d    |
-| **slow**      | language fundamentals, CS theory, HCI research            | <365d | 1–2y    | 2–5y     | >5y      |
-| **permanent** | math theorems, physical laws, historical facts            | <5y   | 5–10y   | 10–20y   | >20y     |
+That's it. No `.cache/sessions/`, no `.research-state.jsonl`, no ADR pipeline, no MOCs. If we need those later, they get added back deliberately, not by default.
 
-Bucket detection lives in `scripts/check-cache.sh`. Override with `--scope`.
-
-## Triangulation — Denzin's 4 types, not "3 sources"
-
-A claim achieves **high-confidence** only when it survives ≥3 INDEPENDENT sources where "independent" means satisfying ≥1 of:
-
-- **Data triangulation** — different time/place/persons
-- **Investigator triangulation** — different authors with no shared funding/employer
-- **Theoretical triangulation** — different theoretical framings reach the same conclusion
-- **Methodological triangulation** — different methods (survey vs interview vs telemetry) converge
-
-Republication chains and citation cascades count as **one** source. The verify gate flags suspected republication via shared DOM fingerprints + ownership trees.
-
-**Render rule (synthesize)**: confidence is rendered as a parenthetical next to each finding bullet — `_[high — Anthropic + Vercel + NN/g]_`. NOT as a separate methodology box, NOT as an Ontology Map, NOT as a triangulation matrix.
-
-## Diminishing-returns detection (research-query)
-
-After every batch of fetches, query agent evaluates whether the last 3 tool steps produced new signal:
-
-- New non-boilerplate tokens added to claims.jsonl in last 3 steps < 500
-- Tool work in last 3 steps < $0.01
-
-If both below threshold → emit `NoProgress` event to `$SESSION_DIR/progress.log`. After **2 consecutive `NoProgress` events** on a sub-question → terminate that sub-question. After **4 consecutive** across the run → terminate research entirely and hand off to synthesize.
-
-Thresholds are illustrative — calibrate per project.
-
-## Length scales with `effort_tier`
-
-| `effort_tier` | Target lines | Sections expected                           |
-| ------------- | ------------ | ------------------------------------------- |
-| `simple`      | 80–150       | TL;DR · What we found · Sources             |
-| `comparison`  | 150–280      | + Why this matters · Trade-offs             |
-| `complex`     | 280–450      | + Where evidence disagrees · Open questions |
-
-Going under target = not enough info; over target = reader bails. Anchor on these.
-
-## Scripts (`.claude/skills/research/scripts/`)
-
-| Script                | Purpose                                                                                              |
-| --------------------- | ---------------------------------------------------------------------------------------------------- |
-| `check-cache.sh`      | Slugify topic, scan `/docs/research/`, classify content-type bucket, return reuse/delta/full verdict |
-| `verify-citations.sh` | Per citation: HTTP 200, quote grep against `snapshot_path`, DOI Crossref check, write verify.json    |
-| `dedup-research.sh`   | Detect overlap between docs (jaccard on concept lists + citation overlap), suggest merge             |
-| `update-index.sh`     | Regenerate `/docs/research/index.md` + per-folder indexes from frontmatter                           |
-| `extract-claims.py`   | Pull atomic claims with citations from a rendered doc into JSONL                                     |
-
-## Templates (`.claude/skills/research/templates/`)
-
-| Template                     | Output                                                             |
-| ---------------------------- | ------------------------------------------------------------------ |
-| `research.md.tpl`            | Main `/docs/research/<slug>.md` — engineering-blog briefing format |
-| `adr.md.tpl`                 | Nygard ADR for decision questions                                  |
-| `moc.md.tpl`                 | Map of Content for cross-topic themes                              |
-| `index.md.tpl`               | TOC for `/docs/research/index.md`                                  |
-| `research-state.schema.json` | Schema for state JSONL entries                                     |
+## Hard rules
 
-## References (read on demand)
+1. **Cache first.** Fresh `<slug>.md` (<30 days) → return path, do not dispatch.
+2. **Output goes to `/docs/research/<slug>.md`** — never to `.claude/`.
+3. **Agents own the writing.** This SKILL.md is just a router; it doesn't draft the report.
+4. **English by default.** PT only on `--lang pt`.
+5. **Hand off, don't substitute.** UX audits → `super-design`. Test audits → `e2e-audit`. Codebase exploration → `Explore` agent. This skill is for external/web/literature research.
+6. **Don't loop on a misbehaving agent.** Two failed re-dispatches → surface the problem.
+7. **Reply to user is ≤ 5 sentences.** The deliverable is the file, not the chat message.
 
-- `references/research-methodology.md` — methodology (triangulation, freshness, query engineering)
-- `references/ontology-patterns.md` — INTERNAL grouping vocabulary for synthesize (NOT rendered as a section)
-- `references/source-directory.md` — per-domain authoritative sources, authority hierarchies, AI-content red flags
-- `references/domain-playbooks.md` — step-by-step protocols per research domain (UX, library eval, API, ADR, market, academic, news, security, pricing)
+## Triggers (enforced by SessionStart hook)
 
-## Hard rules
+EN: `research`, `investigate`, `find info`, `search for`, `look up`, `evaluate`, `compare`, `competitor analysis`, `market research`, `library evaluation`, `prior art`, `arxiv`, `literature review`.
 
-1. **Cache first**. Never burn query tokens on a fresh cache hit.
-2. **Auto-proceed after scout**. Print summary, immediately dispatch query. NO confirmation gate. User can interrupt mid-run.
-3. **Every claim has URL+QUOTE+ACCESSED-AT+VERIFY-METHOD**. Verify gate fails closed on violations.
-4. **No fabricated citations, ever**. If a quote cannot be greppded in the fetched page, the claim is dropped.
-5. **Triangulate by Denzin type, not raw count**. 3 republications of one wire story = 1 source.
-6. **Content-type freshness**. Don't apply fast-bucket aging to slow-bucket topics or vice versa.
-7. **Output to `/docs/research/`** — never to `.claude/skills/research-cache/` (legacy).
-8. **English output by default** — even when triggered in Portuguese. Override with `--lang pt`.
-9. **Summary to user ≤5 sentences**. Doc body lives in the file.
-10. **Skill ⊥ super-design ⊥ e2e-audit**. If the user asked for a UX audit or test audit, hand off — do not improvise.
-11. **No Ontology Map section in the rendered doc.** Ontology vocabulary is internal-only.
-12. **No 30+ concept frontmatter list.** Cap at 8.
-13. **Findings render as flat bolded bullets**, not numbered subsections with paragraphs + blockquotes.
-14. **Citations default to embedded hyperlinks in prose.** `[Anthropic Engineering](URL)` style. Numeric `[1]` is opt-in via `--cite-style numeric-footnote`.
-15. **Parallel fan-out is the norm** for `comparison` and `complex` tiers. Serial execution only for `simple`.
-16. **Honor diminishing-returns detection.** 2 consecutive NoProgress per sub-q → stop that sub-q; 4 across the run → stop research.
-17. **Length scales with `effort_tier`.** Don't pad, don't truncate.
-
-## Boundaries (what this skill does NOT do)
-
-- Does NOT implement code based on its own findings. Hand the doc to the user / implementing agent.
-- Does NOT replace `super-design` for design audits or `e2e-audit` for test audits.
-- Does NOT publish research outside `/docs/research/`.
-- Does NOT invent fixtures or scrape behind paywalls.
-- Does NOT bypass robots.txt or honor restrictions on cited sites.
-
-## Invocation triggers (enforced by SessionStart hook)
-
-EN: `research`, `investigate`, `find info`, `search for`, `look up`, `evaluate`, `compare`, `audit literature`, `competitor analysis`, `market research`, `library evaluation`, `prior art`.
-
-PT: `pesquisar`, `pesquisa`, `pesquise`, `investigar`, `buscar info`, `procurar info`, `comparar`, `avaliar biblioteca`, `análise de mercado`, `análise de concorrentes`.
-
-The hook injects this context at session start. Claude must read this SKILL.md before improvising a research plan.
+PT: `pesquisar`, `pesquisa`, `pesquise`, `investigar`, `buscar info`, `procurar info`, `comparar`, `avaliar biblioteca`, `análise de mercado`, `análise de concorrentes`, `revisão de literatura`.

package/template/.claude/skills/research/scripts/update-index.sh

@@ -1,106 +1,56 @@
 #!/usr/bin/env bash
-# update-index.sh — regenerate /docs/research/index.md and per-folder
-# indexes from frontmatter of all docs. Idempotent.
-set -euo pipefail
-
-ROOT="${CLAUDE_PROJECT_DIR:-$(pwd)}"
-DIR="${ROOT}/docs/research"
-INDEX="${DIR}/index.md"
-DEC_DIR="${DIR}/decisions"
-DEC_INDEX="${DEC_DIR}/index.md"
-MOC_DIR="${DIR}/moc"
-MOC_INDEX="${MOC_DIR}/index.md"
+# Regenerates /docs/research/index.md from the frontmatter of every <slug>.md
+# in /docs/research/. Lean: title + agent + accessed_at + path. No frontmatter
+# parser library — uses awk on simple `key: value` pairs.
+#
+# Usage: bash .claude/skills/research/scripts/update-index.sh
 
-mkdir -p "$DIR" "$DEC_DIR" "$MOC_DIR"
+set -euo pipefail
 
-fm_get() {
-  # fm_get <file> <key>
-  awk -v k="$2" '
-    /^---$/ { fm = !fm; next }
-    fm {
-      if (match($0, "^" k ":")) {
-        sub("^" k ":[[:space:]]*", ""); print; exit
+ROOT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+RESEARCH_DIR="$ROOT_DIR/docs/research"
+INDEX="$RESEARCH_DIR/index.md"
+
+mkdir -p "$RESEARCH_DIR"
+
+extract_field() {
+  awk -v key="$1" '
+    /^---[[:space:]]*$/ { count++; if (count == 2) exit; next }
+    count == 1 {
+      if ($0 ~ "^"key":") {
+        sub("^"key":[[:space:]]*", "")
+        gsub(/^"|"$/, "")
+        print
+        exit
       }
     }
-  ' "$1"
-}
-
-list_topics() {
-  find "$DIR" -maxdepth 1 -type f -name "*.md" ! -name "index.md" 2>/dev/null | sort
-}
-
-list_decisions() {
-  find "$DEC_DIR" -maxdepth 1 -type f -name "*.md" ! -name "index.md" 2>/dev/null | sort
-}
-
-list_mocs() {
-  find "$MOC_DIR" -maxdepth 1 -type f -name "*.md" ! -name "index.md" 2>/dev/null | sort
+  ' "$2"
 }
 
-# ---- root index ----
 {
-  echo "# Research Index"
-  echo
-  echo "_Auto-generated by \`.claude/skills/research/scripts/update-index.sh\`. Do not edit by hand._"
-  echo
-  echo "## Topics"
-  echo
-  echo "| Topic | Date | Bucket | Status | Confidence | Sources |"
-  echo "|-------|------|--------|--------|------------|---------|"
-  for f in $(list_topics); do
-    SLUG=$(basename "$f" .md)
-    DATE=$(fm_get "$f" date); [ -z "$DATE" ] && DATE="—"
-    BUCKET=$(fm_get "$f" content_type_bucket); [ -z "$BUCKET" ] && BUCKET="—"
-    STATUS=$(fm_get "$f" freshness); [ -z "$STATUS" ] && STATUS="—"
-    CONF=$(fm_get "$f" confidence_summary); [ -z "$CONF" ] && CONF="—"
-    SRC=$(fm_get "$f" sources_count); [ -z "$SRC" ] && SRC="—"
-    echo "| [${SLUG}](./${SLUG}.md) | ${DATE} | ${BUCKET} | ${STATUS} | ${CONF} | ${SRC} |"
-  done
-  echo
-  echo "## Decisions (ADRs)"
-  echo
-  echo "| ADR | Date | Status |"
-  echo "|-----|------|--------|"
-  for f in $(list_decisions); do
-    SLUG=$(basename "$f" .md)
-    DATE=$(fm_get "$f" date); [ -z "$DATE" ] && DATE="—"
-    STAT=$(fm_get "$f" status); [ -z "$STAT" ] && STAT="—"
-    echo "| [${SLUG}](./decisions/${SLUG}.md) | ${DATE} | ${STAT} |"
-  done
-  echo
-  echo "## Maps of Content"
-  echo
-  for f in $(list_mocs); do
-    SLUG=$(basename "$f" .md)
-    echo "- [${SLUG}](./moc/${SLUG}.md)"
+  echo "# /docs/research/ — index"
+  echo ""
+  echo "_Auto-generated by \`.claude/skills/research/scripts/update-index.sh\`. Do not hand-edit._"
+  echo ""
+  echo "| Topic | Agent | Last updated | File |"
+  echo "|-------|-------|--------------|------|"
+
+  shopt -s nullglob
+  for f in "$RESEARCH_DIR"/*.md; do
+    base="$(basename "$f")"
+    [[ "$base" == "index.md" ]] && continue
+
+    title="$(extract_field title "$f" || true)"
+    agent="$(extract_field agent "$f" || true)"
+    accessed_at="$(extract_field accessed_at "$f" || true)"
+
+    [[ -z "$title" ]] && title="$base"
+    [[ -z "$agent" ]] && agent="—"
+    [[ -z "$accessed_at" ]] && accessed_at="—"
+
+    printf '| %s | %s | %s | [%s](./%s) |\n' \
+      "$title" "$agent" "$accessed_at" "$base" "$base"
   done
 } > "$INDEX"
 
-# ---- decisions index ----
-{
-  echo "# Architecture Decision Records"
-  echo
-  echo "_Auto-generated. Format: Nygard 2011._"
-  echo
-  for f in $(list_decisions); do
-    SLUG=$(basename "$f" .md)
-    DATE=$(fm_get "$f" date); [ -z "$DATE" ] && DATE="—"
-    STAT=$(fm_get "$f" status); [ -z "$STAT" ] && STAT="—"
-    TITLE=$(fm_get "$f" title); [ -z "$TITLE" ] && TITLE="$SLUG"
-    echo "- **[${SLUG}](./${SLUG}.md)** — ${TITLE} _(${DATE} · ${STAT})_"
-  done
-} > "$DEC_INDEX"
-
-# ---- moc index ----
-{
-  echo "# Maps of Content"
-  echo
-  for f in $(list_mocs); do
-    SLUG=$(basename "$f" .md)
-    echo "- [${SLUG}](./${SLUG}.md)"
-  done
-} > "$MOC_INDEX"
-
 echo "updated: $INDEX"
-echo "updated: $DEC_INDEX"
-echo "updated: $MOC_INDEX"