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. Usepipeline(), notparallel(), 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.jsonand its existing findings fromfindings.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.mdorSTATUS.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
partialrun 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)
- 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.jsonfromslack_list_user_channels(typespublic_channel,private_channel,exclude_archived), every channel as acontainersrow{id, title}.knowledge/jove-labs/.sweep/enum/jira.jsonfromsearchJiraIssuesUsingJqlonproject in (JVA, JPMT) AND (parent = JVA-29512 OR text ~ "\"JoVE Labs\"" OR labels = jove-labs) AND updated >= "2026-07-01", every issue as anitemsrow{id: key, title, modified}and every parent epic as acontainersrow.knowledge/jove-labs/.sweep/enum/granola.jsonfrom Granolalist_meetings(last 30 days), each meeting anitemsrow. Wispr is read fromknowledge/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. EveryUNINGESTED,NEW SURFACEandUNENUMERABLEline 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 isUNENUMERABLE, which is a breach, not a skip. ANEW SURFACEis closed only by registering it (surfaces.yaml, or the Slack registry) or by Dhiraj adding it toknowledge/jove-labs/surfaces-ignored.yamlwith a reason; the sweep proposes, it never self-ignores.
- 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. - 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. - Read
_shared/jove-connectors.mdbefore pulling any live data. 3a. Readknowledge/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 reportedOKwith 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 frontmatterapp:) via WebFetch of itsregister-actionsblock. Apply pertools/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, rerunnode tools/register-app/web/scripts/gen-data.mjsand commit the regeneratedsrc/data/register.jsonso 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, runnode 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 inknowledge/jove-labs/redash-customer-lab-rule.sql; drift is a finding, and--applyrewrites 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):
- One live call against that connector, and paste its result.
slack_read_channelonC0XXXXXXXXX,getAccessibleAtlassianResources,list_issueswith no filter,get_metadataon the Labs file. ABLOCKEDrow whose evidence is a notice rather than a failed call is malformed and does not ship. - 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.
- GitLab reads live via the PAT at
.claude.json→projects/<repo>/mcpServers/gitlab/env/GITLAB_PERSONAL_ACCESS_TOKEN, andtools/jove-code-sync.shfetches the clones over SSH regardless of MCP state.~/.claude/jove-code-sync/last-sync.jsoncarriesremote_shaper 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. - 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_okfor 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
contentFormatfallback silently returning markdown with no anchors, and readingmaininstead offeat/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_ruleon an entry is binding. Read it before pulling that surface. It exists because someone already got this wrong. - A surface with
fidelity: verbatimgets the DM fidelity rule below. - A surface whose
owneris 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: falseorunknownstill gets a row in the ledger every run, with its reason. An unreachable surface is a reported gap, not an absence.critical_nodesis 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'scache. A node whosenameis null has never been resolved by anyone; report it as unresolved and never infer a name from its id.cachefirst, network second. If an entry has acache, 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_forand 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 atknowledge/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 intosurfaces.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:
Two independent cursor storesCLOSED 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 injove-connectors.mdis 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'sslack.registryrollup 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.- Even within this skill's own store, a per-channel file can be current while the parent
rollup entry in
state.jsonis 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 instate.json, never inslack-cursors.json.) - The rule this incident sets.
slack.registryiscadence: 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:
- Any parent with a non-zero reply count gets
slack_read_threadon 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. - A reply outranks its parent. Where they disagree the reply is current state. Quote the reply.
- 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.
- 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. threads_opened < parents_with_repliesisPARTIAL, neverOK. Report it asPARTIAL (parents only, N threads unread). Enforced bynode 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:
- 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.
- 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.
- 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. - 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)