Checkit

checkit — ingest an artifact, integrate it, act on it

Someone drops a URL / repo / paper / file / image with a terse directive — "check this out", "lets research this", "wdyt". The intent is real but unstated by design: they're delegating the articulation, not just the work.

checkit infers the real request from a fully-contextualized frame and acts on it — without asking back for read/research steps — then runs an ingest-and-integrate pipeline so the artifact becomes durable knowledge + a ranked next step, not a throwaway summary.

It is a composition skill: it fires existing research, search, and note-taking tools in sequence; it does not reimplement them.

Portability. The pipeline below is self-contained and works in any agent environment. It is most powerful inside a bstack workspace (broomva/bstack), where it composes with the checkit role/x lens (request-shape routing) and the bstack primitives named below (P15 snapshot, P6 proactive docs, P18 format). Outside bstack, treat the primitive names as the plain behaviors they describe — the full portable contract is bundled in references/checkit-lens.md.

The one rule

Never ask "what do you want me to do with this?" for read/research steps.

The user shared the artifact because they didn't want to articulate the ask. Infer the intent, state it in one line, and execute. Carve-out: proceeding-on-inference covers reversible, low-cost steps; for costly/irreversible ones (an expensive multi-agent deep-research fan-out, mutating existing saved notes, filing a ticket) do the cheap version first and surface the expensive option as a ranked next step — you still never ask, you defer.

Pipeline (what /checkit <artifact> does)

1. Infer + declare intent — one line: "Reading this as: <inferred ask> (artifact type: X; relevant to: <active work>)." Then proceed.

   • Use the artifact-type → intent taxonomy in references/checkit-lens.md. Default for a builder/researcher: evaluate-against-our-stack, not a neutral summary.

2. Contextualize first (bstack: P15 + knowledge-graph load) — snapshot what's active (branch, open PRs, recent work) and search existing notes/knowledge for the topic before going external. Surface what's already known. Knowledge-first prevents re-researching solved problems.

3. Deep research — traverse to the primitives. Pick the engine by artifact type (general web research / academic-paper search / single-page fetch), then read the primary source verbatim — a WebFetch/search answer over a landing page is discovery (it routes you to what to read), never the citation source. Depth floor by type: repo → walk the full tree (gh api repos/<o>/<r>/git/trees/<ref>?recursive=1 or clone) and read the canonical files (SPEC.md / README / key sources) verbatim; docs site → follow the doc tree (many pages), not one; paper → read the mechanism-bearing sections, not the abstract; long file → read it, not the first screen; social-network link → use the validated path, do not improvise a pipeline. Two shapes, each with a dogfooded route:

   • Video (YouTube / Shorts / TikTok / IG Reel / hosted mp4) → run the tested tool, not a hand-rolled ffmpeg loop: python3 scripts/video_ingest.py '<url>' --query '<the question you inferred>' (from the broomva workspace; from any other cwd use the absolute ~/broomva/scripts/video_ingest.py). Single-quote the URL and the query — both are untrusted external input, so a hostile link's shell metacharacters must never reach the shell unescaped (the script itself takes argv, shell=False). It is BRO-1979 — self-degrading (scenedetect/imagehash optional → falls back to ffmpeg + Pillow) and prints a JSON manifest to stdout (also written to <outdir>/manifest.json — pass --outdir DIR to pin the location, else it's a temp dir echoed as manifest.outdir). Then Read manifest.contact_sheet (ONE cheap vision Read of the whole visual arc — title cards, diagrams, on-screen text the audio skips), Read manifest.transcript_path only when it is non-null (it's null for no-speech frames-mandatory clips — skip the Read then), and follow manifest.recommendation.mode: transcript-only (speech-dense, no signal) · escalate-frames (deixis / high scene-rate / on-screen text → Read the per-window frames) · frames-mandatory (no speech). For login-gated IG/FB, add --cookies-from-browser chrome, or drive Interceptor on real logged-in Chrome (interceptor open '<url>') — this reads your own local browser session to reach your own gated content; the cookies stay local (video_ingest writes only the manifest + frames — never logs or uploads them), so use it only on content you're authorized to access. If the script is somehow absent, the manual recipe it automates: yt-dlp acquire → transcript-first → sample on change not a clock (ffmpeg select='gt(scene,0.3)', one frame per distinct visual state) → montage contact sheet → escalate only unresolved windows; never uniform-poll per second (drowns talking heads, aliases fast screencasts). Spec: research/entities/pattern/adaptive-video-ingest.md.
   • Thread / image post (X/Twitter thread, IG photo post, FB) → text is only half the artifact; pull the pixels too — a markdown extractor silently drops the images (the modality gap). Browser-screenshot→Read + in-browser image fetch (WebFetch 402s on x.com; agent-browser/Interceptor loads it, then fetch the CDN-signed og:image in-session). Faster reads when you don't need the full reply tree: twitterapi.io or FxTwitter (X, no login), Jina Reader x-with-generated-alt (inline VLM image captions). Spec: research/entities/pattern/full-fidelity-content-ingest.md. Verify every external URL — hallucinated links are a catastrophic failure. Provenance honesty: a [HIGH] tag names the artifact actually read verbatim; a landing-page/search summary is [MED] at most, labeled as a summary — never tag a claim "spec/repo-verified" against a source you did not open. Exhaustion check before filing: "what canonical material have I not opened?" (linked spec, referenced files, sub-pages, cited sources). Scale depth to stakes, but never below reading the source's own primitives.

4. Analyze the sources — extract the mechanism / claim / result. What's novel? load-bearing? confirms or contradicts what you already knew? Tag every external claim HIGH / MED / LOW confidence.

5. Connect + enrich — make ≥1 explicit link to existing knowledge. If the artifact confirms or contradicts a prior note, say which (mutating an existing note is gated by the costly/irreversible carve-out above).

6. Document the finding (bstack: P6 proactive bookkeeping) — write the note / entity / summary without asking permission, then report what was filed in one line. Provenance traces back to the artifact.

7. Suggest next steps — ranked and tied to active work: build-vs-reuse decision · a follow-up research thread · a ticket · a doc. The artifact must end up metabolized into action.

8. Format for the reader (bstack: P18) — markdown for knowledge substrate; a richer human-read brief only when the finding is a decision artifact.

Composition map

Step	Composes (bstack-native names; generic behavior in parens)
Infer intent, no ask-back	the checkit role/x lens (P17) + persona context (who is asking)
Contextualize	P15 state snapshot + knowledge-graph load (search existing notes)
Deep research	a research/search skill (web / academic / fetch), depth-scaled
Analyze + tag confidence	source verification + HIGH/MED/LOW tagging
Connect + enrich	knowledge-graph edges (link to existing notes)
Document the finding	P6 proactive bookkeeping (file first, report after)
Next steps	goal-formation (turn gaps into ranked next actions)
Format	P18 format-follows-audience

Anti-rationalization

Excuse	Reality
"It's vague — I should ask what they want."	The vagueness is intentional delegation. Infer + state + proceed. Asking is the failure this skill exists to kill.
"A quick summary is enough."	A summary evaporates. checkit produces durable notes + links + ranked next steps, or it didn't run.
"I'll research it but skip writing it down."	Research-without-integration leaves knowledge cold; next session re-solves it. Filing is not optional.
"Should I create a note for this?"	Never ask — file proactively, report after.
"I'll trust my training data on this repo/paper."	Verify with live research; training data is stale. Verify every URL.
"A WebFetch/search summary of the page is enough."	A summary is discovery, not the source. Traverse to the primitives — read the spec / README / key files / doc tree / paper sections verbatim before any [HIGH] claim.
"I confirmed the repo/page exists — that's verification."	Existence ≠ contents. [HIGH] requires reading the canonical text; a tag naming a source you didn't open is false provenance.
"This artifact isn't obviously about our work."	For a focused builder/researcher it almost always is — find the link to active work before defaulting to a neutral read.
"Let me just kick off the deep multi-agent run on this guess."	Costly/irreversible on an inference → surface it as a next step instead (the carve-out).

Scope

• In scope: any artifact (URL, repo, paper, file, image, pasted doc, or a bare topic string) shared with an under-specified directive.
• Out of scope: fully-specified artifact asks (answer directly); retrospective "what have I been doing repeatedly" (a discovery/look-back task).

Validation (skill self-test)

A /checkit run is complete iff: an inferred-intent line appears before any research and no bounce-back question was asked for read/research steps; any costly/irreversible step was surfaced as a ranked next step (not run on a guess); existing knowledge was searched first; the primary source was traversed to its primitives and read verbatim (not a landing-page/search summary), with every [HIGH] claim tracing to that verbatim read; deep research ran with every URL verified; ≥1 link to existing knowledge was made; ≥1 finding was filed proactively; and a ranked next-steps list ties the finding to active work. (Full checklist: references/checkit-lens.md.)

References

• references/checkit-lens.md — the portable no-ask-back contract, the artifact-type → intent taxonomy, the artifact-gate, and the full procedure + self-test. Read this for the complete behavior.
• In a bstack workspace: the request-shape routing lens is roles/checkit.md (a status: candidate lens — reached today via this skill + reasoning; auto-fire pending the role-x phrase-scorer fix, BRO-1338); the crystallization record is research/entities/pattern/bstack-engine.md (§2026-06-02). checkit composes there with P15 / P6 / P17 / P18.