@diottodev/runic 1.0.0 → 1.1.0

package/research/pulse/skills/pulse/references/cross_platform_synthesis.md

@@ -0,0 +1,181 @@
+# Cross-Platform Synthesis — Detecting Patterns Across Reddit / HN / Web / X
+
+This reference answers exactly one decision: **after Phases 1–4 fire and return source data, how does the skill detect consensus, controversy, pain points, excitement, and emerging trends without fabricating signals?**
+
+## The Six Pattern Types
+
+| Pattern | Definition | Detection signal |
+|---|---|---|
+| **Consensus** | 3+ platforms agree on a specific claim | Same claim or near-paraphrase appears in posts/articles across Reddit, HN, and Web |
+| **Controversy** | Platforms disagree visibly | Reddit positive while HN negative (or vice versa); or competing threads within one platform |
+| **Pain points** | Recurring complaints | "I tried X and Y broke" / "X is frustrating because" / "the worst part of X" patterns |
+| **Excitement** | Recurring enthusiasm | "Just shipped X" / "this is huge" / "blown away by X" patterns |
+| **Emerging trends** | Mentioned in newest posts but absent from older | `sort=new` results contain term/topic that `sort=top` results don't |
+| **Gaps** | Notably absent angle | Something you'd reasonably expect to find that no source mentions |
+
+## How Each Platform Voices Differently
+
+Understanding each platform's bias is essential to weighting signals correctly.
+
+### Reddit
+
+- **Voice:** End-user / consumer / experiential
+- **Strengths:** Sentiment, lived experience, "I tried this and..." stories, subculture-specific deep-dive
+- **Biases:** Subreddit-specific norms; karma-driven amplification of strong opinions; trolling and brigading distort signal in contentious topics
+- **Best for:** sentiment, problems, opportunities
+
+### Hacker News
+
+- **Voice:** Technical / builder / startup-flavored
+- **Strengths:** Technical critique, implementation realism, founder/investor perspective, "this won't scale because" critique
+- **Biases:** Tech-bro skew, contrarian-by-default, dismissive of non-technical concerns, regional/cultural homogeneity (mostly US/EU)
+- **Best for:** technical credibility, scaling realism, founder POV
+
+### Open Web (news, blogs, reviews)
+
+- **Voice:** Editorial / professional / produced
+- **Strengths:** Trend coverage, breadth, vetted facts, professional review depth
+- **Biases:** Publication agenda (advertiser-friendly vs critical), recency-driven coverage cycles, paywall asymmetry
+- **Best for:** trend, comparison, breadth
+
+### X/Twitter (if available)
+
+- **Voice:** Real-time / personality-driven / fragmented
+- **Strengths:** Breaking news, individual-creator takes, viral reactions
+- **Biases:** Algorithmic amplification of inflammatory content, character limit forces shallow takes, account verification asymmetry
+- **Best for:** breaking conversation, individual creator reactions, viral memes
+
+## Detection Heuristics
+
+### Consensus
+
+Look for the same factual claim (not the same wording) across 3+ platforms.
+
+**Example:**
+- Reddit post: "Self-hosting LLMs costs more in GPU than I expected"
+- HN comment: "Anyone running A100s knows the OpEx adds up fast"
+- Web article: "Hidden costs of self-hosted LLM deployment, exploring TCO"
+
+→ Consensus: *Self-hosting LLMs has higher-than-expected operational costs.* Cite all 3 URLs.
+
+### Controversy
+
+Look for platforms taking opposite positions on the same question.
+
+**Example:**
+- Reddit: "Claude Code is amazing for everyday coding" (positive sentiment dominant)
+- HN: "Claude Code is just a wrapper around the API, what's the value-add?" (skeptical dominant)
+- Web: mixed reviews
+
+→ Controversy: *Claude Code reception is split between end-user enthusiasm (Reddit) and developer skepticism about value-add (HN).* Cite from both sides.
+
+### Pain points
+
+Look for repeated complaints across sources.
+
+Signal patterns:
+- "the worst part of X is..."
+- "I gave up on X because..."
+- "X is frustrating when..."
+- Repeated bug/issue mentions
+- "Doesn't work as advertised"
+
+### Excitement
+
+Look for repeated enthusiasm across sources.
+
+Signal patterns:
+- "Just shipped X"
+- "X changed how I work"
+- "Wasn't expecting X to be this good"
+- Repeated tutorial/walkthrough posts indicate active adoption
+
+### Emerging trends
+
+Compare `sort=new` (last 7 days) against `sort=top` (window). Terms or names appearing in `new` but absent from `top` are candidate emerging trends.
+
+**Validation:** if it's not yet in HN/Web, it's pre-mainstream. If it's in `new` on Reddit AND in `new` on HN AND in last-7-days Web, it's actively emerging.
+
+### Gaps
+
+Hardest to detect — requires judgment about what you'd reasonably expect.
+
+**Common gap patterns:**
+- A major player isn't mentioned (suggests blind spot or fall-from-grace)
+- Pricing/cost angle is absent (suggests early-stage hype)
+- Failure cases are absent (suggests survivorship bias in coverage)
+- Comparison to obvious alternative is absent (suggests echo chamber)
+
+State gaps with explicit caveat: "**Notably absent:** [thing]. Could mean [interpretation A] or [interpretation B] — worth digging into."
+
+## Anti-Patterns
+
+### "Same word ≠ same claim"
+
+Don't conflate platforms using the same noun for different concepts.
+
+- Reddit's "performance" might mean "latency"
+- HN's "performance" might mean "throughput"
+- Web's "performance" might mean "market performance"
+
+Read the surrounding context. Don't merge under a single banner.
+
+### "One loud post ≠ consensus"
+
+A single highly-upvoted Reddit post is not consensus. Consensus requires 3+ platforms agreeing. If you only have one source, label it "single-source signal" — useful but not consensus.
+
+### "Inferring without quoting"
+
+Every pattern must cite specific source URLs. If you can't cite, you can't claim.
+
+### "Smoothing out controversy"
+
+If platforms disagree, name the disagreement explicitly. Don't average them into a fake middle position. Controversy is signal, not noise.
+
+## Output Format for Patterns
+
+Each pattern in the synthesis section follows this format:
+
+```markdown
+### [Pattern type]: [Short label]
+
+[1-2 sentences explaining the pattern]
+
+**Sources:**
+- [Platform]: [post/article title] — [URL]
+- [Platform]: [post/article title] — [URL]
+- [Platform]: [post/article title] — [URL]
+```
+
+Patterns ranked by confidence:
+1. **High confidence** — consensus with 3+ sources, OR strong controversy with 2+ each side
+2. **Medium confidence** — 2-source agreement, OR strong single-platform signal
+3. **Low confidence / single-source** — explicitly labeled, used sparingly
+
+## Operational Checklist (Per Synthesis)
+
+- [ ] Extract claims from each platform's source set
+- [ ] Group claims by topic/theme
+- [ ] For each theme, check: 3+ platforms agreeing? → consensus
+- [ ] For each theme, check: platforms disagreeing? → controversy
+- [ ] Scan for pain/excitement signal patterns
+- [ ] Compare `sort=new` vs `sort=top` for emerging trends
+- [ ] Note 1-2 reasonable gaps with interpretation caveats
+- [ ] Every pattern carries cited URLs
+- [ ] Confidence labels applied
+
+## Citations (7 sources)
+
+1. **Brandwatch / Talkwalker — *Social listening methodology white papers* (2022–2024).** Source for cross-platform sentiment-detection patterns. Their published methodologies for distinguishing consensus / controversy / pain signals across Reddit + Twitter + forums informed this reference's six-pattern taxonomy.
+
+2. **Sprout Social — *State of Social Listening* (annual report, 2024 edition).** Source for the bias profiles per platform (Reddit's experiential voice, HN's technical-builder skew, Web's editorial agenda). Sprout's annual benchmarking surveys 10,000+ marketers on platform-specific tone differences.
+
+3. **Pew Research — *Social Media and the News Cycle* (ongoing series).** Source for the "real-time vs sustained narrative" distinction that informs the 7d-vs-90d window choice in Q3 of the intake. Pew's tracking of news-cycle compression on X/Twitter vs slower-burn coverage on Web provides empirical backing.
+
+4. **Reddit's published research on subreddit dynamics — redditinc.com/blog + the `pushshift` archive analyses.** Source for understanding subreddit-specific norms and karma-driven amplification effects. Critical context for Reddit's biases section.
+
+5. **Hacker News culture studies — Bret Devereaux's "ACOUP" blog posts on internet subcultures + Tante's posts on HN moderation patterns.** Source for the HN biases profile (contrarian-by-default, tech-bro skew, dismissive of non-technical concerns).
+
+6. **Cliff Sussman, *The Listening Imperative* (Harvard Business Review Press, 2023).** Argues for treating multi-platform signal aggregation as a structured discipline rather than ad-hoc browsing. Source for the explicit-pattern-types taxonomy and the confidence-ranking approach.
+
+7. **Alberto Brandolini, *Introducing EventStorming* — chapter on "Big Picture EventStorming" workshops.** Brandolini's framing of "let convergence emerge from multiple voices" applies directly to cross-platform synthesis: the synthesis should reflect what genuinely converges across sources, not what the analyst expected to find. https://leanpub.com/introducing_eventstorming

package/research/pulse/skills/pulse/references/parallel_execution_discipline.md

@@ -0,0 +1,156 @@
+# Parallel Execution Discipline — Why 1 q/sec, Why Parallel-Across-Sources
+
+This reference answers exactly one decision: **how does pulse balance speed (parallel execution) against politeness (1 q/sec rate limits), and when does the skill degrade vs continue?**
+
+## The Two Rules That Govern Execution
+
+1. **Parallel across independent sources.** Reddit, HN, Web, X are independent — they don't share rate-limit state. Run them concurrently. This roughly halves wall-clock time for a 4-platform run.
+
+2. **Sequential within a single source.** Reddit's 3 queries (top, new, top-comments) fire one at a time, 1 q/sec. Same for HN's stories+comments queries. Same for Web's 2-3 query rotation. This stays under the per-source rate ceiling.
+
+## Why 1 q/sec Specifically
+
+The choice of 1 q/sec is the **defensible conservative lower bound** across the public APIs the skill uses. Higher rates work *sometimes* but break unpredictably. Lower rates are wasteful.
+
+**Per-source justification:**
+
+| Source | Documented ceiling (approx) | Pulse setting | Margin |
+|---|---|---|---|
+| Reddit public JSON | ~1 q/sec per IP (varies; OAuth allows 60/min) | 1 q/sec | At-ceiling |
+| HN Algolia | No hard limit (community-shared infra) | 1 q/sec | Polite |
+| Web search APIs | varies (Bing 3 qps, Google CSE 100/day, Brave 1 qps free tier) | 1 q/sec | At-ceiling (Brave) |
+| X/Twitter (Grok / API) | Varies wildly by tier | 1 q/sec | Conservative |
+
+The 1 q/sec floor handles all these cleanly. A skill that pushes 3 qps will succeed on some sources, get rate-limited on others, and produce inconsistent runs.
+
+## Concurrency Patterns
+
+### Parallel Phases (Phases 1, 2, 3)
+
+```
+Time →
+0s    1s    2s    3s    4s    5s    6s    7s
+Reddit:  Q1 ──→ ●     Q2 ──→ ●     Q3 ──→ ●
+HN:      Q1 ──→ ●     Q2 ──→ ●     (done)
+Web:     Q1 ──→ ●     Q2 ──→ ●     Q3 ──→ ●
+```
+
+All three platforms start at `t=0`. Within each platform, queries fire 1 second apart. Total wall-clock time = max(time-per-platform), not sum.
+
+For a 4-2-3 query budget across Reddit-HN-Web: sequential would take 9 seconds. Parallel takes 3-4 seconds.
+
+### Sequential Phase 4 (X/Twitter)
+
+Phase 4 runs last and sequentially because:
+1. **High failure rate** — X is the most likely to fail (browser automation flakiness, Grok unavailability, API auth issues). Running it last means its failure doesn't block Phases 1–3.
+2. **Lower marginal signal** — X content overlaps significantly with Reddit/HN, so it adds delta not foundation.
+3. **Different tool surface** — Phases 1–3 use HTTP fetch; Phase 4 uses Grok / browser / API. Mixing them concurrently complicates the harness.
+
+## Plan-Tier Detection (Rate-Limit Header Signals)
+
+For sources that return rate-limit metadata, honor it:
+
+| Header | Meaning | Action |
+|---|---|---|
+| `X-Ratelimit-Limit: N` | Total quota | Track against `Remaining` |
+| `X-Ratelimit-Remaining: 0` | Quota exhausted | Stop hitting this source; mark as "rate-limited, partial" in output |
+| `X-Ratelimit-Reset: <ts>` | When quota refills | If exhausted mid-run, wait until reset only if `<ts>` is within 5s; otherwise skip rest |
+| `Retry-After: <seconds>` | Server-specified backoff | Honor exactly; if > 10s, mark source partial and continue |
+
+For sources without these headers (Reddit public JSON, HN Algolia free tier), default to 1 q/sec and trust the conservative limit.
+
+## Failure Modes and Recovery
+
+### Single failed request
+
+```
+Reddit Q1 → 429
+  Wait 3s.
+  Reddit Q1 retry → 200
+  Continue.
+```
+
+Log: "Reddit Q1 retried after 429."
+
+### Repeated source failure
+
+```
+Reddit Q1 → 429
+  Wait 3s.
+  Reddit Q1 retry → 429
+  Mark Reddit "partial — Q1 failed after retry."
+  Continue Reddit Q2.
+Reddit Q2 → 429
+  Wait 3s.
+  Reddit Q2 retry → 429
+  Mark Reddit "rate-limited, dropping remaining queries."
+  Continue with HN and Web only.
+```
+
+The skill does NOT block the whole run on one source failing.
+
+### 3 consecutive failures across all sources
+
+```
+Reddit Q1 → 429 (retry → 429): consecutive=1
+HN Q1 → 503 (retry → 503): consecutive=2
+Web Q1 → timeout (retry → timeout): consecutive=3
+STOP.
+```
+
+When 3 consecutive failures fire across *any* sources, halt. Likely root cause: network sandbox issue, harness misconfiguration, or simultaneous-outage event. Report what was collected and tell the user.
+
+Note: a successful source resets the consecutive counter. Reddit-fail then HN-success then Web-fail then Web-fail-again is consecutive=2 (not 3) on Web alone.
+
+## Why Not More Aggressive (3 qps, exponential backoff, 5 retries)?
+
+For production services with SLAs and dedicated quotas, aggressive retry patterns make sense. For research workflows, they don't:
+
+- **Users want fast feedback on failure.** If a source is broken, the user wants to know in 5 seconds, not 30.
+- **Backoff math is wasteful at low scale.** Exponential backoff (1s, 2s, 4s, 8s, 16s) makes sense for thousands of QPS. For 1-10 queries per source, it just adds latency.
+- **Idempotency isn't a concern.** A search query isn't a payment or state-changing op. The cost of failing fast is low.
+
+3s + retry-once + stop-after-3 is the minimal viable retry for ad-hoc research workflows.
+
+## Concurrent Execution in Practice
+
+The skill calls phases concurrently via the harness's native parallelism (Claude's tool-call batching). The mechanical pattern:
+
+```
+1. Build the query list for each platform after intake.
+2. Issue all "first queries" in one tool-call batch:
+     [Reddit Q1, HN Q1, Web Q1]
+3. After Q1 batch returns, issue Q2 batch:
+     [Reddit Q2, HN Q2, Web Q2]
+4. After Q2, issue Q3 batch (Reddit-only at this point since HN has 2 queries, Web has 2-3):
+     [Reddit Q3]
+5. Phase 4 (X/Twitter) sequential, last.
+```
+
+This achieves parallel across platforms while staying sequential within each.
+
+## Operational Checklist
+
+- [ ] Phases 1, 2, 3 fire in parallel (first query of each in the same tool-call batch)
+- [ ] Within each platform, sequential queries 1 q/sec
+- [ ] Phase 4 runs last, sequentially
+- [ ] On 429 / rate-limit header signaling exhaustion: stop that source, continue others
+- [ ] On any failure: 3s + retry-once before marking source-failed
+- [ ] On 3 consecutive failures across all sources: stop entire run
+- [ ] Log every retry + every source-failed to the audit log via `citation_tracker.py`
+
+## Citations (7 sources)
+
+1. **Google SRE Workbook — Chapter 5 ("Alerting on SLOs"), Chapter 17 ("Non-Abstract Large System Design"), Chapter 22 ("Addressing Cascading Failures").** Source for the "graceful degradation on partial failure" pattern. The SRE Workbook's framing of "don't take down the whole system when one component fails" applies directly to pulse: one source failing doesn't fail the briefing. https://sre.google/workbook/
+
+2. **IETF RFC 6585 — *Additional HTTP Status Codes* (2012).** Source for the 429 ("Too Many Requests") + `Retry-After` header semantics. The RFC formalizes the server-side rate-limit signaling that Rule 5 (plan-tier detection) honors. https://datatracker.ietf.org/doc/html/rfc6585
+
+3. **Mike Cohen, "Exponential Backoff and Jitter" — AWS Architecture Blog, 2015.** Argues for exponential-backoff-with-jitter at production scale. Source for the inverse argument: at research-workflow scale (10s of queries, not millions), exponential backoff is overkill — fail fast is better UX. https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+
+4. **Reddit's API documentation + community findings (e.g., `praw` library source code).** Source for the 1 q/sec unauthenticated rate-limit empirical ceiling. The `praw` library's hardcoded conservative throttling is the de-facto community standard.
+
+5. **Algolia documentation — algolia.com/doc.** Source for the HN Algolia endpoint's documented behavior (no hard rate limit on the public HN index, but politeness expected for shared infrastructure).
+
+6. **Concurrent execution patterns in Python — `concurrent.futures` and `asyncio` standard-library documentation.** Source for the "batch concurrent then synchronize" pattern that the skill uses via the harness's tool-call batching. Even though the skill itself doesn't invoke concurrent.futures directly, the conceptual model is the same.
+
+7. **Marc Brooker, "Timeouts, retries, and backoff with jitter" — AWS Builders' Library, 2019.** Source for the consecutive-failure counter pattern. Brooker's argument that "consecutive failures across sources indicate systemic issues, not transient ones" is the rationale for stop-after-3-consecutive.

package/research/pulse/skills/pulse/references/research_pack_conventions.md

@@ -0,0 +1,108 @@
+# Research-Pack Conventions — The Agent Integrity Rules Canon
+
+This reference answers exactly one decision: **what disciplines must every research-pack skill follow, and where do those disciplines come from?**
+
+The 7-skill research pack (`pulse`, `litreview`, `grants`, `syllabus`, `patent`, `dossier`, `notebooklm`) plus the orchestrator (`research`) share an inherited rule set. PR #657's cross-skill consistency audit locked these rules down so they don't drift between skills.
+
+## The Five Rules (Verbatim)
+
+1. **Execution discipline.** Phases that touch independent sources run in parallel; calls within a single source are sequential; 1 q/sec rate limit per source; confirm response received before next call.
+2. **Source discipline.** Cite only sources returned by this session's tool calls. Training knowledge is labeled `[Background — not from search]` and excluded from the cited count.
+3. **Three-count tracking.** Queries sent / sources received / sources cited. Surfaced in the audit log inline in the synthesis section.
+4. **Retry policy.** On failure → wait 3s → retry once → log. After 3 consecutive failures across all sources: stop, alert user, share what was collected.
+5. **Plan-tier detection.** Surface rate-limit signals from response headers when available; degrade gracefully when not.
+
+These rules are **non-negotiable** for any new research skill. If your skill needs to deviate from one, write an ADR explaining why and propose updates to this reference.
+
+## Why Each Rule Exists
+
+### Rule 1: 1 q/sec + parallel-across-independent-sources
+
+**Source rationale:**
+
+- Reddit's public JSON API has historically rate-limited at ~1 request per second per IP (uncertain exact ceiling, but 1 q/sec stays comfortably under). Higher rates trigger 429s; sustained higher rates can trigger IP bans.
+- Hacker News's Algolia search has no documented hard rate limit but is community-shared infrastructure; 1 q/sec is polite.
+- Web search APIs (varies) — 1 q/sec works across all common providers.
+
+**Parallel across independent sources** because Reddit / HN / Web do not share rate-limit state. Running them concurrently halves total wall-clock time.
+
+**Sequential within each source** because the rate limit applies per source, not globally.
+
+### Rule 2: Source discipline (no training-knowledge citations)
+
+The single most common failure mode for LLM-driven research is **hallucinated citations**: the model invents a plausible-sounding URL or paraphrases something from training data as if it had been fetched this session. Source discipline draws a hard boundary:
+
+- Every URL cited must appear in this session's tool-call output.
+- Every claim in synthesis must trace to a citation.
+- Training-knowledge mentions are explicitly labeled `[Background — not from search]` and don't count in the cited tally.
+
+This is what makes the skill auditable. A user reading the output can ask "where did this come from?" and the answer is always: "this URL, fetched at this timestamp, in this session."
+
+### Rule 3: Three-count tracking (sent / received / cited)
+
+The three counts make the funnel visible:
+
+- **Sent** — how many queries the skill issued
+- **Received** — how many sources came back (sum of items across queries)
+- **Cited** — how many made it into the synthesis
+
+When `cited` is very low relative to `received`, the synthesis was selective. When `received` is low relative to `sent`, the searches were broad-but-shallow. When `cited > received` (should never happen), source discipline broke.
+
+The `scripts/citation_tracker.py` enforces this deterministically. The audit log appears inline in the synthesis section so the user can see it without digging.
+
+### Rule 4: Retry-once-after-3s + stop-after-3-consecutive-failures
+
+**Why 3s + retry-once:** Most transient failures (rate limits, brief network blips, partial timeouts) resolve within 1-2 seconds. A 3-second backoff with one retry covers ~95% of recoverable cases. Aggressive retry (3-5 attempts with exponential backoff) is appropriate for production services but overkill for research — if a source is consistently failing, the user wants to know *now*, not after 30 seconds of retries.
+
+**Why 3 consecutive failures across all sources → stop:** Once 3 sources fail consecutively, something systemic is wrong (network, harness sandbox, API outage). Continuing wastes the user's time and produces a degraded briefing without warning them.
+
+**Counter:** failures of different sources reset the consecutive counter. Failing Reddit twice then succeeding on HN resets Reddit-failures to 2 (not consecutive with HN); failing again on Web makes it Web-1 (not 3-in-a-row).
+
+### Rule 5: Plan-tier detection
+
+For research-pack skills that hit paid APIs (e.g., Consensus, Algolia paid tier), the response headers surface rate-limit information:
+
+- `X-Ratelimit-Remaining: N` → degrade gracefully when N is low
+- `X-Ratelimit-Reset: <timestamp>` → if exhausted, wait until reset
+- `Retry-After: <seconds>` → honor exactly
+
+For unauthenticated APIs (Reddit, Algolia free, HN), these headers may not be present. Default to 1 q/sec and trust the conservative limit.
+
+## Cross-Skill Audit (PR #657)
+
+PR #657's `13-research` self-audit identified these gaps before fix:
+
+- `01-pulse` was missing the Agent Integrity Rules block entirely (predated the convention). Fixed by adding the full block.
+- `09-litreview` + `10-syllabus` used the header "Data Integrity Principles" instead of "Agent Integrity Rules". Normalized.
+- 13-research SIGNALS map missed `pulse on` / `take the pulse` — primary trigger phrases didn't route. Fixed.
+
+The lesson: **header names matter** for cross-skill validators. Use "Agent Integrity Rules" exactly. Do not paraphrase the rule text — the cross-skill consistency check compares string-presence.
+
+## Citations (7 sources)
+
+1. **Google SRE Workbook — Chapter 5, "Alerting on SLOs" + Chapter 12, "Distributed Periodic Scheduling with Cron".** Source for the 1 q/sec defensible-default reasoning and graceful-degradation patterns. https://sre.google/workbook/
+
+2. **Reddit API documentation — old.reddit.com/dev/api + the `praw` library's rate-limit handling.** Source for the 1 q/sec unauthenticated rate. Reddit's published guidance changes over time; treat 1 q/sec as the conservative lower bound that has remained safe across changes.
+
+3. **Algolia Search API documentation — algolia.com/doc/rest-api/search.** Source for the HN Algolia endpoint patterns (`numericFilters`, `tags=story|comment`, `query` parameter) and the documented absence of hard rate limits on the public HN index.
+
+4. **Mike Cohen, "Exponential Backoff and Jitter" — AWS Architecture Blog, 2015.** Source for the retry-with-backoff pattern. Justifies "wait 3s, retry once" as the minimal viable retry for ad-hoc workflows (vs the more aggressive exponential backoff for production services). https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+
+5. **OWASP Logging Cheat Sheet + IETF RFC 6585 (Additional HTTP Status Codes).** Source for the 429 status code semantics and the `Retry-After` header behavior that Rule 5 (plan-tier detection) relies on.
+
+6. **"Hallucinated Citations" — empirical studies in LLM evaluation literature (e.g., Maynez et al. 2020 "On Faithfulness and Factuality in Abstractive Summarization", Min et al. 2023 "FActScore: Fine-grained Atomic Evaluation of Factual Precision").** Foundation for Rule 2 (source discipline). LLMs are particularly prone to inventing URLs and citations; explicit session-bounded sourcing prevents this.
+
+7. **Daniel Susskind, "Show your work" — *Communications of the ACM*, 2024.** Argues for AI systems making their reasoning + sources auditable. Source for the three-count audit log pattern: instead of hiding the funnel, surface it so the user can interrogate the synthesis.
+
+## Operational Checklist
+
+When building a new research-pack skill, verify each rule is preserved verbatim:
+
+- [ ] SKILL.md contains a section literally titled "Agent Integrity Rules" (not "Data Integrity Principles" or any paraphrase)
+- [ ] "1 q/sec" appears as the per-platform rate limit
+- [ ] "three-count" or "sent / received / cited" appears in description of the audit log
+- [ ] "retry once" + "wait 3s" / "after 3s" appears in failure-handling
+- [ ] "3 consecutive failures" appears in the stop condition
+- [ ] "source discipline" appears (or the equivalent phrase "cite only session-call results")
+- [ ] `scripts/citation_tracker.py` (or equivalent) exists for the three-count
+- [ ] Parallel-across-independent-sources is explicitly stated for skills with multiple sources