# Jove Labs Sweep

> On-demand deep sweep that reconstructs the entire JoVE Labs state from every surface in knowledge/jove-labs/surfaces.yaml (vault and Google Docs, Slack, Gmail, calendar, Wispr and Granola, GitLab code, Jira and Confluence, Mixpanel and Redash, Figma, the QA and Champions sheets, Linear) into the canonical knowledge/jove-labs/STATUS.md brief. Proves its own coverage arithmetically, reports whether it is converged with the other Claude account, flags stale or redundant docs for confirmation, and routes action items to Linear and Jira. Every invocation covers ALL surfaces, delta-only against the stored cursors; if that does not fit one context it runs as a Workflow, never as a smaller sweep. Invoke when Dhiraj says "labs sweep", "reconstruct jove labs", "what is the state of jove labs", "what happened on labs", "catch me up on labs", or /jove-labs-sweep.

- Skill: `build-with-dhiraj/jove-labs-sweep` (Agent Skill)
- Install (CLI): `npx get-skill add build-with-dhiraj/jove-labs-sweep`
- Raw SKILL.md: https://api.skillmd.com/api/skills/build-with-dhiraj/jove-labs-sweep/raw
- Safety review: pending (external: skill-scanner PASS, skillspector CAUTION)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Design & Media
- Author: build-with-dhiraj (https://skillmd.com/u/build-with-dhiraj)
- Updated: 2026-11-11
- Page: https://skillmd.com/skills/build-with-dhiraj/jove-labs-sweep

---


> **Project root:** every relative path in this skill (`knowledge/...`, `tools/...`, `.claude/skills/...`) resolves against `~/dev/jove-hq`, never the current working directory. This skill is invocable from any cwd, so prefix accordingly: `~/dev/jove-hq/knowledge/jove-labs/STATUS.md`.

# JoVE Labs sweep (the project-brain rebuild)

Purpose: Dhiraj should never have to tell Claude what happened on JoVE Labs. It was all recorded. This skill reconstructs the full picture from every surface into one canonical brief (`knowledge/jove-labs/STATUS.md`) so any session reads that instead of being fed context.

This is not the belt's daily sweep. The belt routines (08:06 `jove-open-work-sync`, 19:09 `jove-ppp-eod-draft`) are scheduled, delta-based, and all-work. This one is project-scoped, on-demand, deep, and its job is cross-source reconciliation plus doc hygiene. Read ownership per surface is in the precedence table in `_shared/jove-connectors.md`.

**What changed in v2 (8 Aug 2026).** Surfaces are data, not prose: they live in `knowledge/jove-labs/surfaces.yaml`. State lives in the repo at `knowledge/jove-labs/.sweep/`, not in the home directory, so both Claude config dirs converge on it. Coverage is asserted arithmetically instead of narrated. A run now says out loud whether it is converged with the other account.

## `/jove-labs-sweep` means every surface, always (Dhiraj, 13 Aug 2026)

**Standing instruction, and it overrides the group-scoping section below.** When Dhiraj
invokes this skill by name, the run covers **all five groups and every enabled surface in
`surfaces.yaml`**. There is no such thing as a partial run by choice any more. Scoping to
one group is allowed only when he names the group in the same breath.

**If it does not fit in one context, that is not a reason to cover less. It is the reason
to use the `Workflow` tool.** He gave standing authorization for it here, in his own words:
*"if this require batches then start a workflow to have the sweep run end to end of all
surfaces."* That opt-in is scoped to this skill, and it does not generalise to other work.

Shape of the workflow, when one is needed:

- One phase per group, `comms`, `trackers`, `docs`, `code`, `metrics`. Use `pipeline()`, not
  `parallel()`, because no group's read depends on another group's results, and a barrier
  would only add wall-clock.
- One agent per surface, or per small cluster of surfaces that share a connector and a cursor.
- Every agent is handed **its surface's cursor and fingerprint from `state.json` and its
  existing findings from `findings.md`**, and is told to return only the delta plus a coverage
  row. An agent that re-derives what the ledger already holds has burned its budget for nothing.
- The orchestrator does the join pass, the reconcile and the write-back. Subagents never write
  `state.json`, `findings.md` or `STATUS.md`, or they will clobber each other.
- The coverage arithmetic is still per-surface and still mandatory. A workflow that returns 41
  of 43 rows is a `partial` run that must say so, exactly like a single-context run.

**Delta, never reconstruction.** This is the mechanism that makes full coverage affordable,
and it already exists in gate steps 2 and the fingerprint table: read what is stored, pull
only what moved, write the new and changed on top. A full sweep is expensive only when it
re-reads unchanged surfaces, and gate step 2 plus the fingerprint check are what stop that.
Rebuild from scratch only when `state.json` is missing or unparseable.

## Gate (run first)

0. **World versus vault, before anything else (CLAUDE.md rule 18).** Write the MCP handoffs first, then run the enumerator:
   - `knowledge/jove-labs/.sweep/enum/slack.json` from `slack_list_user_channels` (types `public_channel,private_channel`, `exclude_archived`), every channel as a `containers` row `{id, title}`.
   - `knowledge/jove-labs/.sweep/enum/jira.json` from `searchJiraIssuesUsingJql` on `project in (JVA, JPMT) AND (parent = JVA-29512 OR text ~ "\"JoVE Labs\"" OR labels = jove-labs) AND updated >= "2026-07-01"`, every issue as an `items` row `{id: key, title, modified}` and every parent epic as a `containers` row.
   - `knowledge/jove-labs/.sweep/enum/granola.json` from Granola `list_meetings` (last 30 days), each meeting an `items` row. Wispr is read from `knowledge/meetings/.state/wispr-snapshot.json`, which the meetings gate already refreshes.
   - Then `node tools/sweep/enumerate-coverage.mjs --emit-stubs`. Gemini and Drive are listed live through the Drive API. Every `UNINGESTED`, `NEW SURFACE` and `UNENUMERABLE` line prints **first, before the coverage ledger and before any finding**, and the worklist it writes (`.sweep/uningested-<date>.md`) is this run's first work queue. A handoff missing or older than 48h is `UNENUMERABLE`, which is a breach, not a skip. A `NEW SURFACE` is closed only by registering it (surfaces.yaml, or the Slack registry) or by Dhiraj adding it to `knowledge/jove-labs/surfaces-ignored.yaml` with a reason; the sweep proposes, it never self-ignores.
1. Read `knowledge/jove-labs/surfaces.yaml`. This is the scope. A surface absent from it is out of scope; a surface in it that this run does not report is a finding, never silence.
2. Read `knowledge/jove-labs/.sweep/state.json`. It holds per-surface cursors and fingerprints and it is your prior: never re-pull what it already covers. Pull only the window after each cursor. If it is missing or unparseable, ignore it and do a full reconstruction, then rebuild it at write-back. A bad cache can only cost duplicate work, never missed items.
3. Read `_shared/jove-connectors.md` before pulling any live data.
3a. Read `knowledge/jove-labs/.sweep/findings.md`. It is what is currently believed about Labs and it is the prior for every finding this run will make. Then run **both** health gates; a non-zero exit from either is reported with the coverage breach, not as a footnote:
   - `node tools/vault-index/health.mjs` — is the semantic mirror still a mirror.
   - `node tools/sweep/claim-check.mjs` — **does any document still assert something we have since settled otherwise.** This is the one check that is not delta-shaped. Every other mechanism here asks "what moved?"; a stale document that never moves is invisible to all of them, which is exactly how a PI-facing FAQ kept telling researchers the trial ran six months for three weeks after 90 days was verified in code (F-014, F-015). Contradictions are a finding, and the fix is the document, not the allow-list.
   - `node tools/sweep/thread-check.mjs` — **were Slack threads actually opened, or only parents.** Exits non-zero on any surface read parents-only. A surface reported `OK` with unread threads is the specific false confidence that has now cost three misses.
   - `node tools/sweep/finding-clock.mjs` — **does anything need a human today, and does it have one.** The other gates ask whether the SYSTEM is honest. This is the only one that asks whether the PRODUCT is in trouble. It failed on its first run with three launch-blocking findings three days from launch and F-003 unowned, while every other gate was green.
   - **Register-app ingest (before pulling, after the other gates).** Two action sources
     during the transition, both drained every run: (1) the repo inbox
     `knowledge/jove-labs/.register-app/actions-inbox.json`, written by the Vercel app's
     Save button, and (2) until the Vercel app is verified live, the interactive artifact
     (URL in the register frontmatter `app:`) via WebFetch of its `register-actions`
     block. Apply per `tools/register-app/README.md`: close/reopen only WITH a probe at
     the row's closing surface, notes verbatim, asks into the run's work queue; applied
     actions are removed from the inbox in the same commit. At write-back, rerun
     `node tools/register-app/web/scripts/gen-data.mjs` and commit the regenerated
     `src/data/register.json` so the next push deploys fresh data; the git-connected
     Vercel project (jove-labs-register) redeploys on every push to master. An action
     ignored is Dhiraj's instruction dropped; an action applied without a probe is F-253
     again. Both are findings. After the write-back push deploys, run
     `node tools/register-app/audit.mjs`: any STALE/BEHIND/UNSWEPT row is a finding, because
     the register app is Dhiraj's stated single source of truth and a stale app misrepresents
     the vault to its one reader.
   - `node tools/sweep/claim-subject-check.mjs` — **does every code-backed outbound draft say
     which object each claim was checked on.** Two facts verified on two different objects,
     fused into one sentence, produced a claim to a stakeholder that a feature was broken when
     the feature did not exist (19 Aug, JVA-31347). Form checks cannot catch a wrong subject, so
     the table carries an explicit Subject column and a line naming what is NOT claimed. The same
     error recurred once after the first fix, which is why the subject is now its own column
     rather than something the writer is trusted to hold in mind.
   - `node tools/sweep/provenance-check.mjs` — **does every live draft carry its stitched
     source timeline.** A draft written from one surface while another surface holds the
     newer or fuller word is the failure this catches (19 Aug: a ticket drafted from a call
     transcript alone while the morning's Slack DM carried the requirement).
   - `node tools/sweep/verdict-check.mjs`: **does every verdict note carry its Recall run,
     Attribution and Reconciled record sections.** A counter certified from its definition
     alone, while the vault already held the attribution rule it broke, is the failure this
     catches (24 Sep: Redash 2936 was called "faithful to what production enforces" and missed
     7,492 accounts).
   - `node tools/redash/customer-rule.mjs`: **do the nine dashboard 169 queries still embed the one
     customer-lab rule.** Nine hand-typed copies of "a lab in a PI's hands" drift apart unseen
     (24 Sep: only 2933 carried the QA-account flag). The rule lives in
     `knowledge/jove-labs/redash-customer-lab-rule.sql`; drift is a finding, and `--apply` rewrites
     only on Dhiraj's go.
   - `node tools/sweep/ledger-health.mjs` — **did every prior run's findings actually reach the ledger.** Drift here means an earlier run swept surfaces and taught nobody, so this run's prior is incomplete and its own findings may be re-derivations of work already paid for. Fix the drift before pulling, or you will pay for it twice.

3b. **This run is accountable to the ledger.** At write-back it must do exactly one of two things: add its findings and list its `run_id` under `runs_ingested`, or list it under `no_new_findings` with a reason. Do not stamp the id at the gate, only once findings exist. Silence is the single outcome the gate rejects, and it is the one that has already happened once.
3e. **Surface discovery (added 15 Aug 2026, system v3 P3: the Wispr-class fix made structural).**
   Before pulling, enumerate the data sources this session can actually see: every connected
   MCP server whose tools read a data store (meetings, mail, docs, tickets, analytics), plus
   `mcp-registry list_connectors` when available. Diff that list against `surfaces.yaml`.
   **Any data-bearing source with no registry entry is a finding this run must report**, with
   a proposed entry, never a silent skip. Bought by the incident: Wispr Flow held the 14 Aug
   the Director 1:1 in full transcript while every sweep saw only "a huddle started", and it was
   found because Dhiraj asked, not because the system looked. Infrastructure services
   (Pinecone, GitLab-as-transport) are not surfaces; anything holding words people said or
   wrote is.

3d. **Read `knowledge/jove-labs/roadmap.md` before ranking anything.** Its `phase` flag decides the question this run is asking: **pre-launch** asks *will it work*, **launch** asks *is it working now*, **post-launch** asks *is anyone using it, where do they drop, which institution is stalling*. Coverage tells you the surfaces were read. The roadmap tells you which of them mattered. A run that reports "no breach" while a launch-blocking finding sits unowned has measured integrity and missed consequence, which is exactly what happened on 11 Aug.

3b-bis. **Is every recording a note? `node tools/meetings/coverage.mjs`.** The active meeting
recorders are Wispr (primary), Gemini and Granola, all `critical` surfaces, and a sweep that reads a
call from one of them while the vault holds no per-meeting record of it is reasoning from a source
the next run cannot find. **tl;dv was retired 25 Sep 2026** (Dhiraj stopped the subscription); its
surfaces.yaml entry is `criticality: archive`, `reachable: false` by design, and a 401 from it is
expected, never a coverage gap, never grounds to ask for re-authorisation. Earlier tl;dv-sourced call
notes already in the vault remain valid. Exit 1 lists uncoupled conversations: report them in the
coverage table and name PPP STEP 1c as the owner (this skill never writes meeting notes). Exit 2
means a snapshot is stale or missing, so a recorder went unread, which is a coverage breach in its
own right.

3c. `knowledge/jove-labs/INDEX.md` is the map of the 248-note corpus, one line each, newest first. Read it before searching the folder or querying the index: it is cheaper than a semantic query and it shows what exists, which a similarity score cannot. It is generated, so never hand-edit it; fix the source note's frontmatter `subject` instead.
4. Read `~/dev/jove-code/.kernel/KERNEL.md`. **If a brief and the kernel disagree, the kernel wins.**
5. Write `last_run.status: "in_progress"` with this run's `run_id` and enabled count **before the first pull**. That is the first durable write, per CLAUDE.md rule 10, so a limit-death mid-run loses at most one surface. **Stamp the skill version in the same write:** run `node tools/sweep/skill-version.mjs` and copy `skill_commit`, `skill_sha256` and `skill_dirty` onto `last_run`. A skill is loaded into context at invocation, so an edit made mid-session never reaches a run already in flight, and without the stamp a run that *predated* a rule is indistinguishable from one that *ignored* it. Runs 2104Z and 2118Z on 10 Aug are exactly that case. `skill_dirty: true` means uncommitted rules were in force, which is the one state nobody can reconstruct later.
6. On-demand only. Never schedule it, never run it at session start, never loop it.

`run_id` is `<UTC compact timestamp>-<account short name>`, for example `2026-08-10T2053Z-gmail`.

**Probe the account, do not infer it (added 13 Aug 2026).** `node tools/jove-drive/account.mjs --json` returns the work account behind the connectors. That value, and only that value, goes on `last_run.account`. The session system prompt reports Dhiraj's **Claude subscription** email, which is a different identity and has been quoted as the answer repeatedly. Global rule at the top of `~/.claude/CLAUDE.md`.

**Probe the capability, do not infer it from a notice (added 27 Aug 2026).** Same shape as the account rule above, and it cost a whole sweep. A session-start notice listed `plugin:productivity:slack`, `plugin:productivity:atlassian`, `plugin:productivity:linear`, `plugin:figma:figma` and `GitLab` as needing authorization. Those are the **plugin duplicates**. The live claude.ai connectors carry hashed-UUID tool names (`mcp__c6399901-…__slack_*`, `mcp__564fb47c-…__searchJiraIssuesUsingJql`, `mcp__cd286948-…__list_issues`, `mcp__Figma__*`) and were authenticated the whole time. The run declared 31 of 70 surfaces BLOCKED, wrote off all of Slack, Jira, Confluence, Linear and Figma, and reported a partial sweep on the day Labs went live to 365 institutions. Nothing in the notice was false; the inference from it was.

So, before any surface is recorded `BLOCKED (capability)`:

1. **One live call against that connector, and paste its result.** `slack_read_channel` on `C0XXXXXXXXX`, `getAccessibleAtlassianResources`, `list_issues` with no filter, `get_metadata` on the Labs file. A `BLOCKED` row whose evidence is a notice rather than a failed call is malformed and does not ship.
2. **A duplicate server name is not the server.** Match the tool name you would actually call, not the human-readable label in a notice. Two entries can carry one product's name and only one of them is wired.
3. **GitLab reads live via the PAT** at `.claude.json` → `projects/<repo>/mcpServers/gitlab/env/GITLAB_PERSONAL_ACCESS_TOKEN`, and `tools/jove-code-sync.sh` fetches the clones over SSH regardless of MCP state. `~/.claude/jove-code-sync/last-sync.json` carries `remote_sha` per repo, so clone freshness is a fact to read, never a caveat to assume. The MCP needing OAuth has never been a reason to fall back to a stale clone.
4. **Read the extraction, not just the regex.** The first PAT probe here returned 401 because a loose `glpat-` regex over the whole config grabbed a malformed match. Pull the value by its key path and check the length before concluding a credential is dead.

A capability claim is a claim like any other and takes the same evidence as a finding.

**Identity is the account, never the config dir (corrected 10 Aug 2026).** Dhiraj switches accounts by logging out of the Claude desktop app and back in as the other one, on the same machine and therefore in the *same* config dir. Keying identity on the config dir made both accounts look identical, so the cross-account check could never fire. Record `account` on `last_run` and stamp `updated_by` with the account, not the directory. State the account at the start of the run; never infer it from the app (CLAUDE.md, accounts and pools).

The two accounts: `personal-account@example.com` (Max) and `work-account@example.com` (personal seat plus the JoVE org seat). The JoVE account is the one that holds the work connectors.

## Convergence check (before any finding)

Both accounts run on the same machine and share `state.json` on disk. That file, not the chat, is how the second account knows what the first one saw, and it is why switching accounts mid-effort costs nothing. Print this block first, always.

Read `last_run` from `state.json`. If `account` differs from the account running now, this is a cross-account run and the verdict matters. Classify every difference into exactly one of three buckets. Never merge them, they mean different things.

- **DRIFT** the world moved since the prior run. Expected and healthy. Every DRIFT row must carry a timestamp **after** the prior run's `last_ok` for that surface. A DRIFT row timestamped before it is a GAP wearing a disguise, and you say so.
- **GAP** the prior run never covered this surface, evidenced by its own coverage row. This is the only status that proves a defect in the skill rather than movement in the world. It is what the two-account test is actually checking.
- **REGRESSION** same window, different fingerprint, so one of the two runs read wrong. Two documented live instances of this class: the Confluence `contentFormat` fallback silently returning markdown with no anchors, and reading `main` instead of `feat/JVA-29725` (that second instance is historical, 5-11 Aug 2026 only; since the 12 Aug merge the rule inverted and main is correct).

Verdict line: `CONVERGED` requires zero GAPs, zero REGRESSIONs, and every DRIFT row timestamped after the prior `last_ok`. The assertion is not zero events; on live surfaces, real movement between two runs is correct.

**Under CONVERGED the run is read-only.** No STATUS edit, no Linear ticket, no Jira comment. It still writes its receipt and still refreshes `last_ok` per surface, which is what keeps the staleness rule honest, and it still prints the coverage table.

## Surfaces

Pull every surface in `surfaces.yaml` whose `consumers` include `labs-sweep`, in parallel where the tool allows, each windowed by its cursor in `state.json`.

- A `binding_rule` on an entry **is binding**. Read it before pulling that surface. It exists because someone already got this wrong.
- A surface with `fidelity: verbatim` gets the DM fidelity rule below.
- A surface whose `owner` is anyone but Dhiraj is **read-only**. The Champions sheet is CS's, the bug tracker is the QA lead's. Propose rows to Dhiraj; never write them.
- `reachable: false` or `unknown` still gets a row in the ledger every run, with its reason. An unreachable surface is a reported gap, not an absence.
- **`critical_nodes` is the point of the surface, not a detail of it.** Where an entry lists them, resolving each one is the job: pull the surface, resolve every node, and write the name and today's date back into the surface's `cache`. A node whose `name` is null has never been resolved by anyone; report it as unresolved and **never infer a name from its id**.
- **`cache` first, network second.** If an entry has a `cache`, read it before pulling. If the surface is unreachable for this account, the cache is the answer: report those items as STALE with their last-verified date, not as unknown. If the surface IS reachable, pull, then write what changed back to the cache so the account that cannot reach it still benefits.

### Capability is per account, so failure needs an owner

The two accounts do not have the same connectors. Figma and GitLab in particular
work on one and not the other. So a surface that cannot be read is not simply
failing, and recording it as `FAIL` loses the only fact that matters: whether the
*other* account could have read it.

Three distinct outcomes, and they must not be merged:

- **FAIL (data)** the surface is reachable and the read genuinely broke. Retrying on the other account changes nothing.
- **BLOCKED (capability)** this account lacks the connector or the authorization. Record the account in `blocked_for` and mark it **HANDOFF**: the next run on the other account picks it up first, ahead of its own priority order.
- **FAIL (unknown)** never probed, so which of the two is unknown. Probe before classifying.

A run that ends with open HANDOFF items says so in its receipt and in the STATUS
block, naming the account that should take them. That, not the coverage count, is
what makes switching accounts worth doing rather than merely survivable.
- Slack is one registry entry (`slack.registry`) pointing at `knowledge/memory/slack-surface-registry.md`, which is the sole authority for Slack IDs and owns the read-once cursor contract. Never copy its tables into this skill or into `surfaces.yaml`.

Every finding must come from a live tool result. Cite or abstain, per surface.

### Doc hygiene (vault docs and Google Docs)

Per file, one verdict: superseded-by (a newer doc covers the same ground), duplicate-of, untouched-since (old mtime, no inbound wikilinks), or contradicts-a-current-decision.

Output a list: file, verdict, reason, recommendation (archive to `projects/_archive`, merge into X, or delete). **Never auto-delete or auto-archive. Flag it, Dhiraj confirms, then act.** Some of these docs are not yours to remove and a wrong delete is hard to reverse.

### DM fidelity rule (added 17 Jul 2026, after a scope decision in a the dev lead DM was compressed into a half-wrong bullet)

Any DM or channel message that changes a scope, a decision, or a ticket's meaning is quoted VERBATIM in the output: speaker, timestamp, exact words, and the ticket id the thread names. The sweeping agent must read the actual thread via `slack_read_channel` (threads and context, not just the search snippet) before summarizing it. A decision-bearing message that arrives in the report as a paraphrase is a defect: the 16 Jul miss kept "co-trainer invites are lab-level" and dropped the sentence that actually settled scope ("Then this ticket's scope is only for module and lab level upload csv").

Which surfaces this fires on is declared in the registry (`fidelity: verbatim`) and marked per row in the Slack registry, so a new surface inherits the rule by declaration instead of by someone remembering.

### Never skip a live surface because another routine touched it today (added 13 Aug 2026)

**The incident.** Dhiraj posted a Slack thread at 12:44 IST. A delta sweep run at ~16:50 IST
was told *"do not re-read Slack, the belt already covered it today"* and missed it entirely.
Three causes stacked, and only the third is the actual rule violation:

1. ~~Two independent cursor stores~~ **CLOSED 15 Aug 2026 (system v3 P2): there is ONE
   Slack cursor value store, `~/.claude/jove-watchdog/slack-cursors.json`, keyed by
   conversation id (C*/D*; U-id keys are legacy belt aliases).** Sweep readers take their
   cursor from it **READ-ONLY. AMENDED 26 Aug 2026, and this is a deliberate REVERSAL of
   the 15 Aug one-store-two-writers arrangement, logged as such: only the belt advances
   this file (08:06 and 19:09; the registry contract in `jove-connectors.md` is the
   authority). The sweep never writes it.** Why the reversal: the sweep is Labs-scoped and
   the sink is all-work, so a mid-day sweep advance moves the sink's window past the Director/
   squad Slack that is not Labs, and that signal has no other route into the PPP row or
   day-prep (Cursor-Eater). The registry contract's own guard (advance only if no
   later-slotted belt run has stamped) cannot see a sweep, because the sweep correctly
   never stamps the belt cache, so the old arrangement was unguardable, not merely costly.
   Duplicate Labs-Slack delta reads are the accepted, cheaper cost. The per-channel files
   under `.sweep/slack/` carry verbatim notes ONLY, never cursor values; `state.json`'s
   `slack.registry` rollup mirrors the max timestamp this sweep **OBSERVED** for coverage
   arithmetic, which may run ahead of the belt cursor it read from. A reader that
   takes a cursor from anywhere else is re-introducing the F-141 defect.
2. Even within this skill's own store, a per-channel file can be current while the parent
   rollup entry in `state.json` is stale, if the rollup is not re-written in the same edit.
   Reconcile the rollup to the child files, every write-back, not only at the gate. (Post-26-Aug reversal this rollup is the sweep's ONLY Slack cursor write, and it lives in `state.json`, never in `slack-cursors.json`.)
3. **The rule this incident sets.** `slack.registry` is `cadence: live`. A live surface is
   marked so precisely because a cursor-delta pull on it is cheap, which means it is never
   correct to skip it on the theory that "it was read recently by something." Read it fresh
   from THIS skill's own cursor, every run, no exception for same-day activity on another
   surface's clock. The cost of the delta is what makes full coverage affordable; skipping it
   is what makes coverage claims false.

### Threads are mandatory, and the cursor cannot see them

**This section was two sections saying the same thing, written 10 and 11 Aug. That is
itself the symptom: a rule restated is a rule nobody is executing.** Merged 11 Aug, and
the enforcement moved out of prose into `tools/sweep/thread-check.mjs`.

`slack_read_channel` returns PARENT messages only. Reading it is not reading the surface.
Every miss of this class has been identical: the parent was captured, the reply that
settled the question was never opened.

**The incident that made it binding.** On 8 Aug Dhiraj posted the P0 that the 90-day
trial is never granted. the dev lead replied *in-thread*: "I've migrated the dev data to
preview. Subscription issues should be fixed. Please verify." That reply is the entire
state of the item. It says the fix was a data migration rather than the code change the
ticket asks for, and it says verification had not happened. Three sweeps read that
parent, printed `Reply count: 2` in their own output, and none opened it.

**The incident that proved prose alone does not work.** On 11 Aug a Haiku workflow read
30 surfaces under instructions that included this rule. On the QA group DM it opened
**3 of 50 threads** and reported the surface `OK`. It then produced the headline
"P0 trial bug (domainArticleIds fix deployed)" whose only support in the file was
Dhiraj's own bug report ending "Fix: send domainArticleIds in the sync request" — a
PROPOSED fix turned into a deployment claim. Believed, it would have retracted F-001.

Binding, on every Slack surface:

1. **Any parent with a non-zero reply count gets `slack_read_thread` on its ts.** Not the
   interesting ones. Every one. If a surface has 50 parents with replies, that is 50
   thread calls; budget for it rather than sampling.
2. **A reply outranks its parent.** Where they disagree the reply is current state. Quote
   the reply.
3. **The cursor is the latest activity timestamp including replies, never the newest
   parent.** This is what made the failure permanent rather than occasional: a reply added
   later to an older parent carries a timestamp *behind* a parent-keyed cursor, so a delta
   sweep passes it correctly by its own rules and can never recover it.
4. **State-tag every decision-bearing item**: `PROPOSED` / `DECIDED` / `DONE` / `DISPUTED`,
   each with the exact words that establish it. "Fix: do X" in a bug report is PROPOSED.
   "I deployed X" is DONE. "Please verify" means verification was **requested**, not
   performed. The 11 Aug fabrication was a missing distinction, not carelessness.
5. **`threads_opened < parents_with_replies` is `PARTIAL`, never `OK`.** Report it as
   `PARTIAL (parents only, N threads unread)`. **Enforced by
   `node tools/sweep/thread-check.mjs`, which exits non-zero.** Counting a surface as
   covered while its threads are unread is the false confidence this ledger exists to
   prevent, and the coverage arithmetic will otherwise sum clean while it happens.

## Which model does which part (added 11 Aug 2026, measured)

Work here has three kinds and they do not cost the same. Running all three on the
expensive model is the structural waste; running all three on the cheap one loses the
findings that matter.

| Part | Who | Why |
|---|---|---|
| **Reach** a connector (Slack, Jira, Confluence, Drive, Figma) | Claude. Haiku for `normal` surfaces, **Sonnet for anything `critical` or `verbatim`** | Only a Claude agent holds these connectors. Azure cannot see them at all. |
| **Grind**: read what was fetched, extract, classify, cross-reference, draft | **Azure `gpt-4.1` via `tools/sweep/az.mjs`** | No tools needed, just reading. Budget is effectively unlimited, so work that was previously unaffordable (every transcript, the whole Slack history, the 64-meeting doc) is now free. |
| **Judge**: reconcile contradictions, decide what matters, write anything a stakeholder reads | The expensive model, deliberately | This is where every miss in this skill's history happened. |

**The split is measured, not assumed.** On 11 Aug Haiku read 30 Slack surfaces well on
quiet ones (15 of 15 threads on `#triage-product-support`) and **degraded exactly where
content was densest**: 3 of 50 threads on the QA group DM, no thread accounting at all on
the two highest-decision surfaces. It compresses instead of quoting when there is a lot to
read, which inverts the value: the surfaces most worth reading get the shallowest reads.
Azure, asked to classify the same the dev lead reply, correctly returned `fix_type: "data"` —
the distinction that took a full exchange to establish for F-001 — and simultaneously got
the verification nuance wrong. Strong extraction, soft judgment, in one test.

So: cheap for breadth, Sonnet for the surfaces the registry marks critical or verbatim,
Azure for volume, expensive model for the call. A cheap model's output is an input to
judgment, never a finding on its own.

## Reconcile (the core value)

A decision in Slack, a Jira status, a doc claim, and the code about the same thing are ONE reconciled item, resolved to the latest verified state, not four items. Surface contradictions explicitly. Keep tracking the live tensions until they are ratified: the reopened clone model for hand-over, and the North Star framing (module completion versus activation).

**A question asked repeatedly is one unresolved item, not several closed ones.** Counting four askers as four answered rows hides a risk. If the same thing is asked more than once across a call or a channel, it is unresolved regardless of how confidently it was answered, and it gets code-verified before it is reported as settled.

### The join pass (mandatory, added 17 Jul 2026 after two synthesis misses)

Reconciliation failed twice on 17 Jul not because retrieval missed anything but because synthesis reported findings grouped BY SURFACE (Slack bullets, Jira bullets, GitLab bullets) instead of BY OPEN ITEM, so cross-surface connections had no structural home. Both misses had every piece already retrieved: a the engineer DM about "the questions" was filed as housekeeping instead of being joined to the editorial-questions action item sitting in two coupled meeting notes and STATUS itself; a the dev lead DM scope quote was never joined to Dhiraj's own in-session statement or to the commit message ("csv export api for labs and modules") that matched it.

Before writing STATUS, run this explicitly:

1. Build the join list: every open item in STATUS's machine block + every open item in KERNEL.md + every action item from coupled meeting notes of the last 7 days + every decision or instruction Dhiraj gave in the current session + the drafted-but-unposted ledger.
2. For every new finding, ask "which existing item is this about?" and attach it there. A finding may be reported standalone only after it fails to match everything on the join list.
3. Report findings grouped by open item, each item carrying all its surfaces' evidence together (the meeting note that created it, the Slack message that moved it, the ticket that should record it, the commit that built it).
3b. **Never create a Jira ticket without searching Jira first (CLAUDE.md rule 13, added 15 Aug 2026 after this skill's session created JVA-31257 a day after QA had already filed the same bug as JVA-31255).** QA and developers file tickets on their own; a defect this sweep observed may already be theirs. JQL-search by symptom keywords and scan the epic's recent children before any `createJiraIssue`. An existing ticket gets linked and, where our evidence is stronger, its OWN reporter keeps it and the evidence goes to Dhiraj to pass on, never a parallel ticket.
4. An action item from a coupled meeting note is a live object: it stays tracked until completion evidence appears on some surface, and every sweep re-checks each one across ALL surfaces, not just the surface it was born on. "Prepared questions for a meeting" has a lifecycle: asked or not asked at the meeting, if not what happened next, track to done.

### Per-open-item verification (deltas are not enough)

Every sweep enumerates the open items in STATUS's machine block and marks each one: verified-still-open / resolved (evidence) / changed (evidence). An open item that no surface mentioned this window is still explicitly re-verified, not silently carried. Delta-only sweeps let items rot between windows.

### Commit-to-ticket cross-check

Any new commit or MR whose message names a JVA id gets that message (and diff, when cheap) compared against the ticket's current description and the latest decision on record. State the result explicitly: MATCHES the agreed scope / CONTRADICTS it / ticket description lags a decision that exists elsewhere (name where). Never report "code shipped ahead of ticket clarity" without first checking whether the scope was already communicated on another surface.

Read the code from `main` in both `jove.com-ui` and `research-svc`, PLUS every open MR touching `src/labs` or `src/features/JoveLabs`, per the binding rule in the registry (rewritten 12 Aug 2026: Labs merged to main, so `feat/JVA-29725` is frozen at its pre-merge tip, and fixes land on follow-up branches before main — MR !119 carries the JVA-31114 quiz fix that is on neither). Reading `main` alone is not enough.

## Never re-read what has not changed (added 11 Aug 2026)

**Audited 11 Aug: fingerprints were populated on 0 of 39 surfaces.** The field was in the schema from day one and nothing ever wrote it, so every run re-read every document in full regardless of whether it had moved. Cursors were doing all the work, and cursors only help append-only surfaces like Slack. For a sheet or a doc, a cursor tells you nothing.

**Cheap change detection, per kind. Ask this before pulling a body:**

| Kind | Fingerprint | Cost |
|---|---|---|
| gdoc, gsheet, gdrive_folder | Drive `modifiedTime` via `get_file_metadata` | one metadata call |
| confluence | `lastModified` from `getConfluencePage` | **one call, body included** |
| jira | `max(updated)` across the JQL result | already in the search you run |
| git_branch | branch head sha | one `rev-parse` |
| figma | node `lastModified` from metadata | one call |
| slack | not applicable, cursors already cover it | free |

**Correction, verified 11 Aug.** The Confluence row above used to read "`version.number`,
one call, no body". Neither half is true of the tool actually exposed: `getConfluencePage`
never returns `version.number`, and it always returns the full body, so there is no
body-free variant to call. The usable fingerprint is the `lastModified` display string.
The saving on that surface is therefore not bytes on the wire, it is that an unchanged
page needs no re-reading, re-reconciling or re-reporting, which is where the real cost was.

**The rule.** Fetch the fingerprint first. If it matches what state holds, record `OK (no change)`, refresh `last_ok`, and **do not read the body**. If it differs, read, then store the new fingerprint. A surface whose fingerprint is unchanged is fully covered for the ledger's purposes; that is not a skip and needs no reason.

This is also what makes the second account cheap. The whole point of sharing `state.json` is that account B inherits account A's fingerprints and re-reads nothing that A already saw unchanged.

**Storage hygiene.** Run receipts are per-run prose; there are seven. They are working notes, not knowledge: anything durable belongs in the findings ledger below, which is the thing later runs and follow-ups actually read. They are excluded from the semantic mirror for that reason, so they no longer compete with the ledger on the ledger's own questions. Receipts older than the last three runs can be deleted once their findings are in the ledger, and git holds them either way. Do not let receipt count stand in for memory.

## The findings ledger, and why this skill does not end when the run does

**The failure this fixes.** A sweep pulls a great deal, writes it into a prose receipt, and the receipt is never read again. The next question Dhiraj asks gets answered from whatever survived in the chat, which on a fresh session or the other account is nothing. So the same fact gets rediscovered, or worse, contradicted. The skill was producing data and destroying knowledge.

**`.sweep/findings.md` is the durable memory.** Not a narrative of a run, a standing ledger of what is currently believed about Labs, with each item carrying how it is known.

Every finding carries: a stable id, the claim in one line, its **bin**, the evidence, the surfaces that touched it, its status, and when it was last verified.

The bins are load-bearing and must never blur:

- **observed** ran it, read it, counted it. Name the command or the file.
- **derived** follows from observed things, by steps that can be shown.
- **assumed** taken from a status column, someone's summary, a pattern, or an earlier session. Not verified here.

The whole trial-grant episode is one bin error. "The row says Resolved" is **assumed**. It rode in the same confident rhythm as the code reads, which were **observed**, and the report inherited the confidence of the wrong bin. A finding whose bin is `ass

…(truncated)
