scout-loop
/scout-loop
Łączy zbieranie pomysłów z badań i przeglądów z kolejnym etapem studiów, prowadząc cykl od wyszukiwania do zaplanowanego backlogu.
- Autor
- anthony-chaudhary ↗
- Repozytorium
- fak ↗
- Licencja
- Apache-2.0
- Ostatnia zmiana repozytorium
- 13.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
Co robi i kiedy
Łączy zbieranie pomysłów z badań i przeglądów z kolejnym etapem studiów, prowadząc cykl od wyszukiwania do zaplanowanego backlogu.
Oryginalny opis (EN)
The super-loop that closes the research→backlog loop — it chains the outward CRAWLERS (the daily `idea-scout` arXiv/GitHub feed, the industry scans, the RESEARCH/CONCEPT corpus) into the STUDY pipeline (`/study-repo` → `/field-borrow`) and runs the whole thing on a cadence. The crawler surfaces repo-shaped leads into a needs-triage queue and stops; turning any one into scoped, witnessed, license-clean backlog is still a manual pass someone has to remember to run. This skill is that seam, automated: once per pass it CRAWLS. Use when this named workflow matches the task.
Jak działa
- Its place in the family (do not duplicate a sibling)
- Durable monitored-source queue
- The pass — one lead, end to end
- The honesty boundary (do not cross)
- What "done" proves (per pass)
- Anti-patterns
- When NOT to use
- Honest limits
Podgląd SKILL.md
--- name: scout-loop description: "The super-loop that closes the research→backlog loop — it chains the outward CRAWLERS (the daily `idea-scout` arXiv/GitHub feed, the industry scans, the RESEARCH/CONCEPT corpus) into the STUDY pipeline (`/study-repo` → `/field-borrow`) and runs the whole thing on a cadence. The crawler surfaces repo-shaped leads into a needs-triage queue and stops; turning any one into scoped, witnessed, license-clean backlog is still a manual pass someone has to remember to run. This skill is that seam, automated: once per pass it CRAWLS. Use when this named workflow matches the task." allowed-tools: Read, Bash, Write metadata: generated-by: fak project-assets sync canonical: ../../../.claude/skills/scout-loop/SKILL.md opencode: claude-only # the commit-by-explicit-path, honesty-boundary, no-monolith, and scratch-only-clone discipline are load-bearing and not portable per-skill --- # /scout-loop — crawl the field, study the best lead, file witnessed backlog > **The research→backlog super-loop.** fak already has an outward crawler > (`fak idea-scout` plans deduped `idea-scout` triage issues from arXiv, GitHub, > Hacker News, and Reddit; `--live` is the separate mutation gate) and a study pipeline (`/study-repo` reads a repo at a pinned `@sha` and > decomposes it; `/field-borrow` witnesses one capability against fak and files it > grounded). Nothing connects them: leads pile up in a triage queue and the deep > study→witness→file pass waits for a human to remember it. `scout-loop` is that > seam — it drives the tools we already have, in order, one lead per pass, and can > run unattended on a cadence. This is a **meta-skill**: it re-implements none of the crawlers or study skills. It orders them and holds the discipline the raw pieces assume — **PLAN/witness first, one lead per pass, no monolith, and a crawl is never a ship.** ## Its place in the family (do not duplicate a sibling) | Skill / tool | Starts from | Mechanism | Terminal action | |---|---|---|---| | `fak idea-scout` | an outward **feed** | dry-run arXiv/GitHub/HN/Reddit scan + filed-stamp dedup | plans raw triage issues; `--live` files | | [`/study-repo`](../study-repo/SKILL.md) | one **repo URL** | clone → read the code → decompose | files many small witnessed leaves | | [`/field-borrow`](../field-borrow/SKILL.md) | one **named capability** | dogfood `fak_feature_query`/`fak-dev index` | files one grounded issue | | [`/industry-score`](../industry-score/SKILL.md) | the **field taxonomy** | coverage + parity-debt scorecard | a scorecard (files nothing) | | [`/super-loop`](../super-loop/SKILL.md) | the **ready backlog** | launch N detached `/goal` workers | resolves leaves (witnessed ancestry) | | **`/scout-loop`** (this) | **the crawler output** | **crawl → select → study → witness → file**, cadenced | **runs the study pass unattended, one lead per pass** | `scout-loop` is to `idea-scout`+`study-repo` what `/super-loop` is to a single `/dos-dispatch`: the durable, cadenced front door that runs the proven unit repeatedly and safely. If you were handed **one specific repo**, skip straight to `/study-repo`. If you already have a **named capability** to check, use `/field-borrow`. Reach for `scout-loop` when the job is *"keep finding new leads and converting them"* — the loop, not a single pass. ## Durable monitored-source queue Start each pass from [`docs/research/monitored-repositories.json`](../../../docs/research/monitored-repositories.json), rendered with: ```powershell fak study-monitor --due-days 14 ``` Prefer the highest-priority due `candidate` or `watch` row before opening a fresh outward search. Exact `owner/name` is the deduplication key. When outward discovery finds a stronger untracked lead, register its checked revision and `last_checked` before deep study; after study, update the same row and link its `study_note`. This makes “most recently checked” queryable rather than recoverable only from filenames or session memory. ## The pass — one lead, end to end ### 1 — CRAWL: capture the first-class scout plan Run the Go front door from the repo root. Dry-run is the mandatory default: ```bash fak idea-scout --json > idea-scout-plan.json ``` Inspect candidates, scores, source revisions, dedupe evidence, and planned issue contracts. For a pinned replay or unavailable network, use `--candidates FILE`. Direct `python tools/idea_scout.py` use is a legacy/debug comparison only. Issue creation is a separate explicit gate and requires operator mutation intent: ```bash fak idea-scout --json --live ``` Do not infer permission to cross that gate from this skill matching. Validate selected contracts through `fak-dev issue contract` and price any worker launch through `fak dispatch` before execution. ### 2 — SELECT: one highest-value repo-shaped lead (never a batch) From the crawl, pick **one** lead that is **repo-shaped** — a GitHub URL, a paper-with-code link, a named codebase — and where the field signal says the parity-debt or novelty is highest. **Prefer the fresh-lane leads** (a `**Why surfaced**` line marked `trending` / `very fresh` / `actively updated`): a repo that just appeared or is climbing relative to ours is the highest-novelty, most-perishable lead — study it before it's an incumbent everyone already read. One lead per pass is the anti-storm bound (the same discipline as idea-scout's per-run cap). If nothing fresh is repo-shaped, **stop clean** — an empty pass is a valid result; never invent a lead to have something to do. Prefer a lead that is *not already studied*: grep `docs/notes/CONCEPT-STUDY-*` and `gh issue list --search` for its name first, so the loop doesn't re-study a repo a prior pass (or a human) already decomposed. ### 3 — STUDY: hand the lead to `/study-repo` (do not restate it) Require the returned study to expose both the default frontier and the **bounded-superset coverage frontier**. Do not select leads only because they might replace fak's current default; a lead is also high-value when it serves a credible user/job/constraint cohort through an `OPTIONAL-MODULE` or `RECIPE` seam. Deprioritize feature-count novelty, genuinely superseded approaches, and moment-in-time claims without a dated `WATCH` review trigger. This keeps scouting broad in user coverage but bounded by fak's scope and support economics. Invoke [`/study-repo`](../study-repo/SKILL.md) on the selected lead. That skill owns the whole acquisition front-half — shallow-clone **into scratch, never the tree**, pin the commit `@sha`, read the CODE (load-bearing modules + tests + recent commits) not the README pitch, extract candidate borrows each grounded at a real `path:line@sha`, and decide borrow-vs-integrate on the license. Do not re-implement any of that here; drive it. ### 4 — WITNESS + FILE: `/field-borrow`'s witness step, then file small For **each** surviving candidate, run [`/field-borrow`](../field-borrow/SKILL.md)'s witness step — dogfood `fak_feature_query` / `fak-dev index docs|leaves|verbs|claims` (plus a raw `Grep` to guard the lexical ranker's false-ABSENT) → classify **PRESENT / PARTIAL / ABSENT**: - **PRESENT** → fak already has it: drop the candidate, record the card. A witnessed "we already had this" is a real, good result — not a miss. - **PARTIAL / ABSENT** → ground it in the **fak seam** (`path:line` in *fak*), then file a **small independently-shippable leaf** under the right epic, carrying **both** anchors (source `path:line@sha` + fak seam), the dogfood witness, and a first checkable step. Dedup first (`gh issue list --search`). **Never a monolith** — the ship-alone test from `/study-repo` step 5. **Leak-check every body**: no absolute path, host, secret, or PII from the foreign clone. ### 5 — REGISTER: the trail, or it lived only in a transcript Record the pass in a dated `docs/notes/CONCEPT-STUDY-<repo>-<date>.md` (URL + pinned `@sha`, what you read, the borrow · source `path:line@sha` · witness · inspire|integrate · filed # table), add its **`INDEX.md`** line, and commit the docs lane by explicit path with a `(fak docs)` trailer. This registration — not the issues alone — is what makes the research durable and keeps `fak-dev index freshness` clean. ### 6 — CADENCE: set it to run (unattended) One *pass* is above; the *loop* is a cadence of passes. Two shapes: - **In-session (attended).** Run steps 1–5 now for one lead, then stop. Re-run for the next lead when you choose. - **Scheduled (unattended).** `tools/register_scout_loop.ps1` installs a daily Scheduled Task (`FleetScoutLoop`) that fires one pass via a detached `/goal` worker reading `.claude/goal-prompts/scout-and-study-witnessed.md`. **Plan by default** — installed without `-Launch`, the fire runs the launcher in `-PlanOnly` mode and spawns nothing; `-Launch` is the explicit opt-in. Same safe-by-default contract as `register_idea_scout.ps1` and `/super-loop`. ```powershell .\tools\register_scout_loop.ps1 # install, PLAN-mode daily (spawns nothing) .\tools\register_scout_loop.ps1 -Action status .\tools\register_scout_loop.ps1 -Launch -At 10:30 # go live: one detached study pass/day, after the 09:00 idea-scout ``` Because each fire spawns a Claude session, the launch path keeps the `dispatch_preflight.py` no-DoS cap intact (`launch_goal_detached.ps1` re-checks `SPAWN_OK` per spawn) — never route around it with `-SkipPreflight`. ## The honesty boundary (do not cross) - **A crawl is not a borrow; a study is not a ship.** This loop files *triaged, witnessed* backlog. It NEVER reports an issue resolved — ancestry (`Fixes #N` on the trunk) does that. It hands its filed leaves to the dispatch loop / `/super-loop`, which resolve them. - **Every borrow cites a real `path:line@sha`** in an actually-cloned source, never a README claim — the `dos_citation_resolve` fabrication class `/study-repo` exists to catch. - **Witness before file.** A PARTIAL/ABSENT is grounded in a dogfood witness; a PRESENT is dropped, not filed. "fak already has this" is a complete pass. - **Decompose, never a monolith.** No "adopt everything from repo X" leaf — the ship-alone test decides. - **One lead per pass.** The anti-storm bound; the loop's throughput is a cadence, not a batch. - **Clone into scratch, never `C:\work\fak`.** The foreign tree must never be committable (the `*scratchpad*` gitignore is a backstop, not the plan). ## What "done" proves (per pass) - One repo-shaped lead was **cloned and read at a pinned `@sha`**; every filed borrow cites real code. - Each filed leaf carries a **source `path:line@sha`**, a **fak seam**, a **dogfood witness (PRESENT/PARTIAL/ABSENT)**, and a **first checkable step**; PRESENT cases were dropped, not re-filed. - **No monolith** was filed; the work is small independently-shippable leaves under the right epic. - The pass is **registered**: a dated `docs/notes/CONCEPT-STUDY-*` note + its `INDEX.md` line; `fak-dev index freshness` reads clean. - If unattended: the `FleetScoutLoop` fire is witnessed in the loop ledger (`fak loop status`), and no issue was reported "resolved" by the loop. ## Anti-patterns - ❌ Re-implementing the crawl (re-scanning arXiv) or the study (re-reading the clone logic) — drive `idea-scout` / `/study-repo` / `/field-borrow`, don't duplicate them. - ❌ Studying a batch of leads in one pass — one lead, then stop; the cadence is the throughput. - ❌ Filing a borrow you did not locate at a real `path:line@sha`, or the "adopt repo X" monolith. - ❌ Filing a PRESENT capability fak already ships — the witness step exists to drop it. - ❌ Cloning the foreign repo into the fak tree, or leaking an absolute path / host / secret from it into a fak ticket. - ❌ Installing the scheduled task with `-Launch` before a plan-mode fire is witnessed, or passing `-SkipPreflight` to route around the no-DoS cap. - ❌ Reporting a filed leaf as "resolved" — a crawl/study is not a ship; ancestry is. - ❌ Inventing a lead when the crawl is empty — a clean empty pass is the correct result. ## When NOT to use - **You were handed one specific repo.** Go straight to `/study-repo`; the loop is overhead for a single known lead. - **You have a named capability to check.** Use `/field-borrow` directly. - **You want to resolve the backlog, not grow it.** That's `/super-loop` / `/dos-dispatch` — the resolve side of the loop, which consumes what `scout-loop` files. - **The idea-scout queue and the field scans are empty/stale with nothing new.** Nothing to convert — an empty pass, not a forced study. ## Honest limits - **The witness is lexical + a snapshot.** `fak_feature_query`'s ranker is substring matching (false-ABSENT risk) and its verdict is true only as of today — re-witness before acting on an old pass (same caveat as `/field-borrow` / `/study-repo`). - **The crawl is only as fresh as its feeders.** If `FleetIdeaScout` hasn't run, the triage queue is stale; the loop studies what's there, it does not force a re-scan. - **Composes with, does not replace:** `idea-scout` (the feed), `/study-repo` (the acquisition front-half it drives), `/field-borrow` (the witness+file back-half), `/industry-score` (a witnessed PRESENT/PARTIAL/ABSENT is a coverage row it can absorb), `/super-loop` (resolves the leaves this loop files).
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · anthony-chaudhary/fak | 98 | Apache-2.0 |
| anthony-chaudhary/fak | 98 | Apache-2.0 |
Migawka bazy z 13.11.2026 · wersja paczki 1de076d9916d (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100hk-scout-wiki
Przeprowadza falę zwiadu po zewnętrznych źródłach (linki, blogi, popularne repozytoria) do wiki badawczej projektu i destyluje wnioski do pliku pomysłów lub backlogu. - 100ingest-study
Dodaje do rejestru badań otwartą szansę badawczą na podstawie linku z arXiv, DOI, PubMed lub repozytorium, z weryfikacją źródeł.