opencode-skills-collection 4.0.71 → 4.0.73

package/bundled-skills/.antigravity-install-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "updatedAt": "2026-09-23T02:09:47.535Z",
+  "updatedAt": "2026-09-25T02:13:20.897Z",
   "entries": [
     "00-andruia-consultant",
     "007",
@@ -38,6 +38,7 @@
     "agent-harness-fault-injection",
     "agent-manager-skill",
     "agent-memory",
+    "agent-memory-discipline",
     "agent-memory-mcp",
     "agent-memory-systems",
     "agent-observability",
@@ -475,6 +476,7 @@
     "changelog-automation",
     "changelog-updates",
     "chat-widget",
+    "chatexport-need-miner",
     "check-identity-pack",
     "chrome-extension-developer",
     "churn-prevention",
@@ -656,6 +658,7 @@
     "daily",
     "daily-gift",
     "daily-news-report",
+    "dali-short-address-commissioner",
     "dast-scanning",
     "data-engineer",
     "data-engineering-data-driven-feature",
@@ -869,6 +872,7 @@
     "enterprise-vpn-attack",
     "entropy-box",
     "environment-setup-guide",
+    "eol-resistor-calculator",
     "error-debugging-error-analysis",
     "error-debugging-error-trace",
     "error-debugging-multi-agent-review",
@@ -877,6 +881,7 @@
     "error-diagnostics-error-trace",
     "error-diagnostics-smart-debug",
     "error-handling-patterns",
+    "esl-price-sync",
     "ethical-hacking-methodology",
     "evaluation",
     "event-sourcing-architect",
@@ -1477,6 +1482,7 @@
     "markstream-vue2",
     "markstream-vue2-cli",
     "markstream-vue2-vite",
+    "marlin-bed-leveling",
     "matematico-tao",
     "mathguard",
     "matplotlib",
@@ -1598,6 +1604,7 @@
     "nfs-storage",
     "nft-standards",
     "nika",
+    "noaa-radar-satellite-fetching",
     "nodejs-backend-patterns",
     "nodejs-best-practices",
     "nosql-expert",
@@ -1655,6 +1662,7 @@
     "onboarding-cro",
     "onboarding-psychologist",
     "one-drive-automation",
+    "oneroster-csv-validator",
     "ontoly-software-graph",
     "open-dynamic-workflows",
     "open-source-marketing",
@@ -2356,8 +2364,12 @@
     "warp-delegate",
     "warren-buffett",
     "wcag-audit-patterns",
+    "weather-data-lifecycle-management",
+    "weather-data-reproducibility",
     "weather-model-data-fetching",
+    "weather-model-run-discovery",
     "weather-observation-fetching",
+    "weather-pipeline-performance-diagnosis",
     "weaviate",
     "weaviate-cookbooks",
     "web-artifacts-builder",

package/bundled-skills/agent-memory-discipline/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: agent-memory-discipline
+description: "Rules for when an agent should recall from long-term memory before acting and when it should save decisions, corrections and failures afterwards. Works with any memory backend."
+category: memory
+risk: safe
+source: community
+source_repo: mnemoverse/agent-memory-discipline
+source_type: community
+date_added: "2026-09-23"
+author: mnemoverse
+tags: [agent-memory, long-term-memory, context-engineering, mcp, agent-skills]
+tools: [claude, cursor, gemini]
+license: "CC0-1.0"
+license_source: "https://github.com/mnemoverse/agent-memory-discipline/blob/main/LICENSE"
+---
+
+# Agent Memory Discipline
+
+## Overview
+
+Connecting a memory tool does not make an agent use it: tools register, the session runs, and nothing gets recalled or saved. This skill supplies the missing part, standing rules for when to read memory and when to write it.
+
+The problem it solves is specific. An agent with memory available still repeats settled questions, reverts corrected habits, and loses decisions between sessions, because nothing tells it when recall and save are due. The rules below make both moments explicit.
+
+## When to Use This Skill
+
+- Use when a memory tool or MCP memory server is connected but the agent is not using it consistently.
+- Use when the user complains that the assistant loses preferences, conventions or past decisions between sessions.
+- Use when setting up persistent memory for a project and the agent needs standing rules for reading and writing it.
+- Use when the user says "remember this", "what did we decide", "recall", or "save this for next time".
+
+## How It Works
+
+### Before You Start: Any Memory Backend
+
+The agent needs a memory tool it can call. Any backend works, and the rules are identical for each:
+
+- **Files.** A `memory/` folder of Markdown notes, one fact per file. No dependencies, fully greppable, versionable in git.
+- **A local MCP memory server.** Keeps everything on the local machine; several open-source options exist.
+- **A hosted memory service over MCP.** Adds portability across tools and machines at the cost of the data living elsewhere.
+
+Authentication is whatever the chosen backend requires: none for a local folder, the server's own configuration for a local MCP server, an API key or OAuth sign-in for a hosted service. This skill never handles credentials itself and never writes them into memory.
+
+### Step 1: Recall Before Acting
+
+Read memory **before** doing any of these, not after:
+
+- starting work on a project touched before
+- choosing a library, pattern, or tool
+- writing tests, commits, or documentation, where conventions apply
+- answering "how do we usually do X here"
+- anything the user phrases as "again", "like last time", or "as we agreed"
+
+Skip recall for one-off factual questions, arithmetic, or anything fully specified in the current message. Recall costs a tool call and context; spending it on a self-contained question is waste.
+
+Search with the words the user actually used, plus the project or repository name. If the first search returns nothing useful, try one broader query, then stop and proceed without memory rather than looping.
+
+### Step 2: Save After Deciding
+
+Write to memory when one of these has just happened:
+
+- a **decision** was made and will still matter next week ("we use pnpm", "the billing module stays untouched")
+- the user **corrected** the agent, which is the strongest signal there is
+- an approach **failed**, and why it failed
+- a preference was stated that applies beyond this task
+- a fact about the environment was discovered the hard way (a port, a flag, a service that must be running)
+
+Do **not** save: the contents of files that can be read again, restatements of the current task, transient state, anything the user marked as temporary, and anything containing secrets, tokens, or personal data.
+
+One memory, one fact. A paragraph containing four decisions cannot be superseded cleanly when one of them changes.
+
+### Step 3: Write It So It Survives
+
+A memory that is useless in three weeks was written wrong. Give each entry, in the text if the backend has no fields for it:
+
+- **what** was decided or observed, in one sentence
+- **why**, briefly, because the reason outlives the decision
+- **when** it became true, and when it stopped being true if it has
+- **where it came from**: a file, a commit, a conversation, a test run
+
+Prefer the user's own words over a paraphrase. Paraphrase drifts.
+
+### Step 4: Close the Past Instead of Overwriting It
+
+When something changes, the old memory is not wrong. It is **closed**.
+
+If the project moved from Redux to Zustand, "we use Redux" was true from January to June. Deleting it destroys the explanation for every component written in that window. Mark it superseded, keep its validity window, and write the new one alongside.
+
+This is the single most destructive habit in agent memory, and it stays invisible until someone asks a question about old code.
+
+### Step 5: Keep Contradictions Visible
+
+If recall returns two entries that disagree, do not pick the closer match and proceed. Surface both, with their dates, and ask or flag. A convention that a recent failure contradicts is exactly the situation where the user needs to be told, not smoothed over.
+
+### Step 6: Weigh Evidence and Policy Differently
+
+- **Evidence** is what happened: one run, one failure, one observation. Cheap, plentiful, individually unreliable.
+- **Policy** is what should happen: a convention, a decision, a rule. Expensive, and should be hard to change by accident.
+
+An observation becomes policy when a human confirms it, when it lands in a merged decision record, or when it has worked repeatedly. Never promote a single observation to a rule without one of those.
+
+### What Following This Skill Produces
+
+Two things, and nothing else:
+
+- **Recalled context, stated before the work starts.** The relevant entries are named with their dates and sources, so the user can see what the agent is relying on. Conflicting entries are shown side by side, not merged.
+- **New memory entries after decisions, corrections and failures.** One fact each, in this shape:
+
+```text
+Project uses pnpm, not npm. Stated by the user on 2026-08-11 after a lockfile conflict. Applies to all packages in this repo.
+```
+
+A superseded entry keeps its text and gains an end date and a pointer to the entry that replaced it. The full format, with closing and evidence examples, is in [references/entry-format.md](references/entry-format.md).
+
+## Examples
+
+### Example 1: A Correction
+
+The user says: *"stop using npm here, we're on pnpm."*
+
+1. This is a correction, which is the strongest save signal. Save it.
+2. Write the entry:
+
+```text
+Project uses pnpm, not npm. Stated by the user on 2026-08-11 after a lockfile conflict. Applies to all packages in this repo.
+```
+
+3. Do not also save "the user was annoyed", "ran npm install", or the lockfile contents.
+4. Next session, before running any package command in this repo, recall first and find it.
+
+### Example 2: A Contradiction
+
+Recall returns two entries:
+
+```text
+Integration tests run against the staging database (2026-06-02)
+Integration tests use a local container; staging is off limits after the incident (2026-08-19)
+```
+
+1. Do not pick one and continue. State both, with dates.
+2. Ask: *"Memory has two rules for integration tests; the August one says staging is off limits. Use the local container?"*
+3. After the answer, close the entry that no longer holds, with its end date, and keep the other.
+
+### Example 3: Closing an Entry That Stopped Being True
+
+Do not delete the old entry. Add an end date and a pointer to what replaced it, then write the new entry alongside:
+
+```text
+[closed 2026-06-30, replaced by "State management uses Zustand"] State management uses Redux. Decided in the January architecture review.
+State management uses Zustand. Migrated in June after the bundle size review. Applies to all new components.
+```
+
+## Best Practices
+
+- **Do:** recall before project-specific work, and name the entries you rely on with their dates and sources.
+- **Do:** save right after a decision, a correction, or a failure, in one sentence with its reason.
+- **Do:** keep one fact per entry, so a later change can supersede it cleanly.
+- **Do:** prefer the user's own words over a paraphrase.
+- **Don't:** overwrite or remove an entry that stopped being true; close it with an end date instead.
+- **Don't:** save file contents that can be read again, restatements of the current task, or transient state.
+- **Don't:** promote a single observation to a rule without human confirmation, a merged decision record, or repeated success.
+
+## Limitations
+
+- This skill installs no memory backend and requires no account. Without a memory tool the agent can call, it can only say that memory is unavailable and continue.
+- It decides when to recall and what to save. How well entries are found again depends on the backend's own search.
+- It does not resolve contradictions by itself. It surfaces them with their dates and asks the user which one holds.
+- What happens to an entry the user asks to remove depends on what the backend supports.
+- This skill does not replace environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, or safety boundaries are missing.
+
+## Security & Safety Notes
+
+- The skill contains no shell commands and makes no network calls of its own. It reads and writes memory only through the memory tool the user has already connected.
+- Never save secrets, tokens, passwords, or personal data into memory, and never write credentials into an entry.
+- A hosted memory backend stores entries outside the local machine. Choose the backend with that in mind.
+- When the user asks for an entry to be removed, close or remove it as the backend allows, and confirm what was removed.
+
+## Common Pitfalls
+
+- **Problem:** The memory tool is unavailable or failing.
+  **Solution:** Proceed without memory, say so in one line, and do not retry in a loop. Save the pending decision as soon as the tool is back, rather than dropping it.
+- **Problem:** Recall returns nothing.
+  **Solution:** Run one broader query, then continue without memory. An empty result is information: the topic is new, so a decision made now is worth saving.
+- **Problem:** Recall returns too much.
+  **Solution:** Keep the entries that match the current project and task; ignore the rest rather than pasting them into context.
+- **Problem:** Two entries disagree.
+  **Solution:** Show both with their dates and ask which holds. Do not resolve the conflict silently.
+- **Problem:** A save is rejected or filtered by the backend.
+  **Solution:** Report it once. Do not rephrase the same fact repeatedly to get it through.
+
+## Related Skills
+
+- `@memory-systems`: when designing the memory architecture itself (short-term, long-term, graph-based) rather than the habit of using it.
+- `@context-engineering`: when setting up rules files and session context, which this skill complements with rules for long-term memory.
+
+## Additional Resources
+
+- [Upstream repository](https://github.com/mnemoverse/agent-memory-discipline) (CC0-1.0)
+- [Agent Skills overview](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)
+- [Claude Code skills](https://code.claude.com/docs/en/skills)
+- [Model Context Protocol](https://modelcontextprotocol.io), for connecting memory servers
+
+*Written and maintained by the team behind [Mnemoverse](https://mnemoverse.com), which is one hosted implementation. The rules above are deliberately backend-neutral and were written to be useful without it.*

package/bundled-skills/agent-memory-discipline/references/entry-format.md

@@ -0,0 +1,37 @@
+# Memory entry format
+
+Reference for Step 3 and Step 4 of the skill. Use fields when the backend has them; otherwise write the same information into the text of the entry.
+
+## A new entry
+
+| Part | What to write | Example |
+|---|---|---|
+| What | One sentence, the decision or observation | Project uses pnpm, not npm. |
+| Why | The reason, briefly | Lockfile conflict between npm and pnpm. |
+| When | The date it became true | 2026-08-11 |
+| Source | Where it came from | Stated by the user in the session |
+| Scope | Where it applies | All packages in this repository |
+
+As a single line:
+
+```text
+Project uses pnpm, not npm. Stated by the user on 2026-08-11 after a lockfile conflict. Applies to all packages in this repo.
+```
+
+## Closing an entry that stopped being true
+
+Do not delete it. Add an end date and a pointer to what replaced it, then write the new entry alongside.
+
+```text
+[closed 2026-06-30, replaced by "State management uses Zustand"] State management uses Redux. Decided in the January architecture review.
+State management uses Zustand. Migrated in June after the bundle size review. Applies to all new components.
+```
+
+## Evidence and policy
+
+Mark which kind an entry is, so a single observation is not read later as a rule.
+
+```text
+[evidence] The integration suite failed twice against staging on 2026-08-19.
+[policy] Integration tests use a local container; staging is off limits. Confirmed by the user on 2026-08-20.
+```

package/bundled-skills/antigravity-maintainer-batch-release/SKILL.md

@@ -115,7 +115,7 @@ Use `data/specialized-plugin-candidates.json` for specialized-plugin membership
 
 Treat the current catalog and the legacy user-site bridge as one public system:
 
-- Current catalog: `sickn33/agentic-awesome-skills` at `https://sickn33.github.io/agentic-awesome-skills/`.
+- Current catalog: `sickn33/agentic-awesome-skills` at `https://aaskills.tech/`.
 - Legacy bridge: `sickn33/sickn33.github.io` at `https://sickn33.github.io/antigravity-awesome-skills/`.
 
 For SEO, indexing, Pages, redirect, or infrastructure changes:
@@ -163,7 +163,7 @@ Every stable or prerelease version requires full release alignment. Creating the
 5. Merge that release PR through its required checks, update local `main` to equal `origin/main`, and wait for every source, release, or canonical-sync PR in the release path to close. Re-run the release-state and plugin gates if protected `main` moved.
 6. Run `npm run release:publish -- X.Y.Z`. It must resolve exactly one merged release PR from the same repository, authored by the repository owner, with base `main`, exact title `chore: release vX.Y.Z`, and head branch `release/vX.Y.Z`. Zero or multiple candidates fail closed; never select the newest approximate match. The command then verifies that exact protected merge before creating or reusing the tag and GitHub Release.
    The npm publication workflow must first check out protected `main`, verify that the peeled release tag is an ancestor of current `origin/main`, validate the version directly from the tagged `package.json`, and only then check out or execute tag-controlled code. It has no manual-dispatch bypass.
-7. Wait for publishing workflows, then bind every proof to the exact released commit: verify the tag/ref, GitHub Release, npm version and intended dist-tag, required CI, CodeQL, and the explicitly dispatched release-only Pages build from the exact immutable `vX.Y.Z` tag. Never dispatch Pages from `main` or another branch. Verify live `llms.txt`, `skills.json`, catalog and plugin routes, and the legacy redirect bridge; do not accept a successful run for a different SHA.
+7. Wait for publishing workflows, then bind every proof to the exact released commit: verify the tag/ref, GitHub Release, npm version and intended dist-tag, required CI, CodeQL, and the release-tag Pages build from the exact immutable `vX.Y.Z` tag using `deployment_target=release`. Never manually dispatch the release-tag build from `main` or another branch. A separate `deployment_target=main` dispatch may publish a protected main commit after source and canonical-sync work completes; it must verify current-main identity before build and again before deploy. Canonical-sync commits marked `[skip pages]` are never dispatched by canonical synchronization. Verify live `llms.txt`, `skills.json`, catalog and plugin routes, and the legacy redirect bridge; do not accept a successful run for a different SHA.
 8. After npm confirms `X.Y.Z` as the published dist-tag, discover every already-configured local AAS MCP host from its real configuration and update each one to the exact same package version before declaring the release complete. Updating existing AAS host entries is part of the release; creating a previously absent host configuration still requires explicit authorization.
    - Use the published package's `aas mcp configure` two-pass flow: first preview the change, then repeat the identical command with its approval digest. Supply absolute host-config, cache, and backup paths; require a backup when replacing an existing configuration.
    - Pin `agentic-awesome-skills@X.Y.Z` and `--version X.Y.Z`; never use `latest`, reuse an older cached runtime, or create a previously absent host configuration without explicit authorization.

package/bundled-skills/chatexport-need-miner/SKILL.md

@@ -0,0 +1,196 @@
+---
+name: chatexport-need-miner
+description: "Mines offline Telegram Desktop chat exports (result.json) for unmet market needs and product opportunities using chunked streaming and verbatim quote grounding. Trigger phrases: mine chat export, telegram result.json, find unmet needs, analyze telegram chat."
+category: development
+risk: safe
+source: community
+source_repo: wwewtech/chatexport-need-miner
+source_type: community
+date_added: "2026-09-22"
+author: wwewtech
+tags: [telegram, market-research, text-mining, offline-analytics, developer-tools]
+tools: [claude, cursor, gemini, windsurf]
+license: "MIT"
+---
+
+# ChatExport Need Miner: Offline Market Signal & Pain-Point Extractor
+
+Transform offline Telegram Desktop chat exports (`result.json`) into quantified, quote-grounded rankings of unmet market needs with zero memory crashes and absolute source fidelity.
+
+## When to Use This Skill
+
+Activate this skill when:
+- The user provides an offline Telegram Desktop chat export (`result.json` or multi-file directory) and requests market research, customer problem analysis, or tool opportunity discovery.
+- The user asks: "What are people in this chat struggling with?", "Find product ideas from this export", "What tools do users wish existed?", or "Mine complaints from this group".
+- Analyzing multi-megabyte or gigabyte JSON dumps where standard in-memory deserialization (`json.load()`) risks out-of-memory (OOM) fatal crashes.
+- Cross-referencing user complaints across multiple independent communities to eliminate echo-chamber noise.
+
+Do NOT use this skill when:
+- The user wants live channel scraping, continuous bot monitoring, or MTProto API automation (use dedicated online fetchers).
+- Analyzing personal 1-on-1 romantic or private relationships.
+- Processing generic SaaS helpdesk feeds (Zendesk, Intercom, Gong) with structured ticket schemas.
+
+## Core Mental Models & Non-Negotiable Rules
+
+1. **The 4MB Stream & Overlap Invariant (Memory Ceiling <= 8MB)**:
+   - Telegram Desktop `result.json` files routinely exceed 500MB to 5GB.
+   - NEVER load an entire export into memory with `json.load()` or `fs.readFileSync()`.
+   - Read the file in fixed 4MB chunks with a 4KB overlap tail.
+   - **Boundary Counting Law**: A substring hit is recorded if and only if its terminus falls past the overlap boundary. This guarantees zero missed boundary-spanning phrases and strictly zero duplicate counts.
+
+2. **Cross-Chat Multiplicity Law ($U \ge 3$ Priority)**:
+   - One user posting 50 complaints in a single chat is an anecdote; 5 distinct users posting the same complaint across 3 independent chats is a market signal.
+   - Cluster rank score is calculated as:
+     $$\text{Score} = U \times \sqrt{H}$$
+     where $U$ is the number of distinct chat exports containing the signal, and $H$ is the total verified keyword hits.
+   - A pattern appearing in $U \ge 3$ chats always outranks a pattern confined to $U = 1$, regardless of raw hit volume.
+
+3. **Verbatim Quote Anchor & Anti-Hallucination Law**:
+   - Every identified need theme MUST be backed by 2 to 5 verbatim quotes with exact ISO timestamp (`date`) and chat identifier.
+   - NEVER paraphrase a quote inside quotation marks. NEVER synthesize synthetic user statements.
+   - If a hypothesized theme lacks verbatim quote support, it MUST be marked `[UNCONFIRMED / NO VERBATIM EVIDENCE]`.
+
+4. **Bi-Lingual Case-Insensitive Seed Lexicons**:
+   - Russian Lexicon: `не хватает`, `вот бы`, `бесит`, `надоело`, `задолбал`, `ищу инструмент`, `ищу бот`, `есть ли бот`, `есть ли сервис`, `посоветуйте тул`, `не работает`, `вручную`, `рутина`, `приходится руками`.
+   - English Lexicon: `i wish`, `missing`, `annoying`, `frustrating`, `looking for a tool`, `is there an app`, `is there a bot`, `any alternative to`, `doesn't work`, `manually`, `repetitive`, `waste of time`.
+   - Custom terms may be added only when explicitly approved or provided by the user.
+
+5. **Strict Air-Gap & Zero Exfiltration**:
+   - The entire analysis executes locally and offline. No network requests, no external telemetry, no remote LLM proxying of raw message contents.
+
+## Named Sins & Anti-Patterns (Что категорически ЗАПРЕЩЕНО)
+
+| Anti-Pattern | Manifestation in Code/Workflow | Mandatory Production Counter-Rule |
+| :--- | :--- | :--- |
+| **The OOM Slurp** | `data = json.load(open('result.json'))` on 800MB file. | Use incremental regex streaming or chunked buffered file reading with `<= 8MB` RAM footprint. |
+| **Chunk Boundary Blindness** | Chunking without overlap, truncating `"looking for a tool"` across 4096-byte splits. | Maintain a 4KB sliding overlap tail across chunk transitions. |
+| **Double-Count Overlap Trap** | Counting hits found in both chunk $N$ and the overlap window of chunk $N+1$. | Only increment match counter if `match.end() > overlap_size`. |
+| **The Echo-Chamber Distortion** | Elevating a bug mentioned 80 times by 1 single user in 1 chat to the #1 product opportunity. | Apply Cross-Chat Multiplicity Law ($U \times \sqrt{H}$) and count unique authors when available. |
+| **Hallucinated Quotations** | "User expressed desire for better sync" written in quotes as `"I really need better sync"`. | Exact substring slice from source buffer; if unquoted, label as synthetic analysis. |
+| **Service Message Pollution** | Mining system notifications (`"pinned a message"`, `"joined group"`, bot spam) as human needs. | Filter out messages where `type == "service"` or text begins with known bot commands (`/start`). |
+| **Premature Uniqueness Claim** | Stating "No tool currently exists for this problem" without validation. | Run explicit coverage audit; if unverified, output strictly: `I cannot confirm this`. |
+| **Lossy Encoding Crash** | Crashing on multi-byte emoji surrogate pairs or non-UTF-8 characters in chat history. | Decode with `errors='replace'` or raw byte-level UTF-8 traversal. |
+| **Monolithic Theme Lumping** | Grouping all complaints under `"Users want better UI"` or `"Performance issues"`. | Disaggregate into specific actionable workflows (e.g. `"No zero-downtime database migration path"`). |
+| **API Creep** | Prompting the user for Telegram Bot tokens or phone numbers for MTProto login. | Reject live requests; reiterate that input contract requires offline `result.json` exports only. |
+
+## Concrete Archetypes / Presets
+
+### Archetype 1: Streaming Regex Need Scanner (Python 3.10+)
+```python
+import re
+import os
+from typing import Generator, Dict, List, Tuple
+
+CHUNK_SIZE = 4 * 1024 * 1024  # 4 MB
+OVERLAP = 4096                 # 4 KB
+
+RU_LEXICON = re.compile(
+    r"(?i)\b(не\s+хватает|вот\s+бы|бесит|надоело|задолбал|ищу\s+(?:инструмент|бот|софт)|"
+    r"есть\s+ли\s+(?:бот|сервис|тул)|посоветуйте|вручную|рутина|приходится\s+руками)\b"
+)
+EN_LEXICON = re.compile(
+    r"(?i)\b(i\s+wish|missing|annoying|frustrating|looking\s+for\s+a\s+(?:tool|bot|app)|"
+    r"is\s+there\s+(?:an?\s+app|a\s+bot|a\s+tool)|any\s+alternative\s+to|manually|waste\s+of\s+time)\b"
+)
+
+def stream_chat_chunks(filepath: str) -> Generator[Tuple[str, int], None, None]:
+    overlap_tail = ""
+    with open(filepath, "r", encoding="utf-8", errors="replace") as f:
+        while True:
+            chunk = f.read(CHUNK_SIZE)
+            if not chunk:
+                break
+            combined = overlap_tail + chunk
+            yield combined, len(overlap_tail)
+            overlap_tail = combined[-OVERLAP:] if len(combined) >= OVERLAP else combined
+
+def mine_need_signals(filepath: str, regex: re.Pattern, max_samples: int = 5) -> Dict:
+    hits = 0
+    samples: List[str] = []
+    for text_block, overlap_len in stream_chat_chunks(filepath):
+        for m in regex.finditer(text_block):
+            if m.end() > overlap_len:
+                hits += 1
+                if len(samples) < max_samples:
+                    start = max(0, m.start() - 60)
+                    end = min(len(text_block), m.end() + 140)
+                    snippet = " ".join(text_block[start:end].split())
+                    samples.append(snippet)
+    return {"total_hits": hits, "samples": samples}
+```
+
+### Archetype 2: Need Cluster & Prioritization Schema
+```json
+{
+  "theme_id": "NEED-001",
+  "theme_name": "Zero-Downtime SQLite Replication for Edge Daemons",
+  "aggregate_score": 14.14,
+  "distinct_chats": 4,
+  "total_hits": 50,
+  "chats_observed": ["devops_talk_ru", "sqlite_users", "homelab_ops", "backend_craft"],
+  "evidence": [
+    {
+      "date": "2026-08-14T11:22:04",
+      "chat": "devops_talk_ru",
+      "verbatim_quote": "бесит что нет нормальной репликации для sqlite на edge серверах без поднятия тяжелого postgres"
+    },
+    {
+      "date": "2026-09-02T19:40:12",
+      "chat": "sqlite_users",
+      "verbatim_quote": "is there a tool that actually handles multi-master sqlite sync without crashing on high concurrency?"
+    }
+  ],
+  "existing_coverage": [
+    {"tool": "LiteFS", "gap": "Requires Consul / Fly.io infrastructure; complex on bare-metal edge."},
+    {"tool": "rqlite", "gap": "Raft layer alters SQLite interface semantics."}
+  ],
+  "verdict": "Real commercial gap for turnkey lightweight edge replication."
+}
+```
+
+### Archetype 3: Multi-File Directory Batch Orchestrator
+```python
+def process_export_directory(dir_path: str, pattern: re.Pattern) -> List[Dict]:
+    results = []
+    for root, _, files in os.walk(dir_path):
+        for file in files:
+            if file == "result.json" or file.endswith(".json"):
+                full_path = os.path.join(root, file)
+                chat_name = os.path.basename(root) if file == "result.json" else file
+                data = mine_need_signals(full_path, pattern)
+                if data["total_hits"] > 0:
+                    results.append({"chat": chat_name, **data})
+    return results
+```
+
+## The Pre-Emit Quality Gate Checklist
+
+Before emitting any market research summary or opportunity report, verify:
+- [ ] **Memory Protection**: Confirmed that raw JSON was parsed via chunked stream or filtered iterator, never loaded as a monolithic object.
+- [ ] **Boundary Integrity**: Overlap boundary logic was applied so split phrases across chunk cuts were not lost or double-counted.
+- [ ] **Verbatim Quote Integrity**: Every listed quote exists word-for-word in the input file with exact date and source. Zero paraphrasing.
+- [ ] **Cross-Chat Breadth**: Verified how many independent chat files the signal appeared in ($U \ge 3$ emphasized).
+- [ ] **Service Message Stripping**: Confirmed system and bot notifications were not tabulated as customer pain points.
+- [ ] **Honesty and Verification Clause**: If a gap or existing competitor cannot be verified, explicitly output: `"I cannot confirm this"`.
+- [ ] **Actionable Granularity**: Themes are tied to specific engineering or operational workflows, not generic platitudes.
+
+## Self-Correction & Verification Loop
+
+### Bad (Vibe-Coded AI Slop Output):
+> "I reviewed the chats and users are looking for better dev tools. Many people complain about speed and say they wish things worked better. There is a huge opportunity to build an AI bot for developers."
+*Problems: Zero verbatim quotes, zero date citations, zero chat distribution count, ungrounded speculation, generic meaningless advice.*
+
+### Good (Production ChatExport Need Miner Output):
+> ### 1. Schema Migration Rollbacks for Flyway in CI/CD — 38 hits across 4 chats ($U=4, H=38, \text{Score}=24.66$)
+> - **Chat Distribution**: `k8s_ru` (14 hits), `devops_community` (12 hits), `backend_pro` (8 hits), `java_chat` (4 hits).
+> - **Evidence 1**: *"бесит когда flyway падает на миграции в CI и приходится вручную чистить schema_version таблицу на стейдже"* (2026-07-19T09:12:44, `devops_community`).
+> - **Evidence 2**: *"is there a tool to safely dry-run flyway down migrations before merging to master?"* (2026-08-04T16:21:09, `k8s_ru`).
+> - **Coverage Check**: Flyway Pro provides undo migrations; however, community tier users lack automated sandbox validation without custom Docker scripts.
+> - **Verdict**: Confirmed gap for a lightweight CLI pre-flight validator for open-source Flyway migrations.
+
+## Limitations
+
+- Use only exports you are authorized to analyze. Chat exports can contain personal or sensitive information; minimize copied excerpts, redact identifiers in reports, and follow applicable retention and privacy requirements.
+- Keep raw exports local and offline as described above. Do not upload messages, quotes, or identifiers to external services or include them in public reports without explicit authorization.
+- Keyword counts and clustered themes are exploratory signals, not representative market research. Validate conclusions with independent evidence and do not infer intent from isolated messages.
+- Chunked text scanning is not a complete Telegram JSON parser; malformed exports, escaped content, nested schemas, or encoding issues can affect counts. Verify any quoted excerpt against the original export.