[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-posthog-exploring-scouts":3,"mdc--xno17-key":35,"related-org-posthog-exploring-scouts":4030,"related-repo-posthog-exploring-scouts":4201},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":11,"stars":20,"repoUrl":21,"updatedAt":22,"license":23,"forks":24,"topics":25,"repo":30,"sourceUrl":33,"mdContent":34},"exploring-scouts","explore PostHog Signals scout findings","How to explore and make sense of PostHog Signals scouts — the scheduled agents that scan a project and write reports into the Signals inbox. Use when a user wants to understand what scouts they have, how each one is behaving, and whether the fleet is actually working. Covers surveying the fleet and its schedules, reading recent scout runs and drilling into a single run's reasoning, inspecting the durable scratchpad memory the fleet has built up, tracing a run to the reports it wrote or edited, and assessing a scout's health and performance over time (cadence, success rate, report rate, signal-to-noise). Read-only and exploratory — to write or tune a scout, use `authoring-scouts` instead. Trigger on \"what are my scouts doing\", \"how is my \u003Cx> scout performing\", \"show me recent scout runs\", \"why did this scout find\u002Freport nothing\", \"what has the fleet learned\", \"explore scout run \u003Cid>\", \"is my scout working\".\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},"posthog","PostHog","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Fposthog.png",[12,14,17],{"name":9,"slug":8,"type":13},"tag",{"name":15,"slug":16,"type":13},"Monitoring","monitoring",{"name":18,"slug":19,"type":13},"Analytics","analytics",59,"https:\u002F\u002Fgithub.com\u002FPostHog\u002Fai-plugin","2026-07-28T05:33:43.543894",null,11,[26,27,28,29],"claude-code-plugin","codex-plugin","cursor-plugin","gemini-cli-extension",{"repoUrl":21,"stars":20,"forks":24,"topics":31,"description":32},[26,27,28,29],"Official PostHog plugin for Claude Code, Cursor, Gemini, Codex and other AI coding tools","https:\u002F\u002Fgithub.com\u002FPostHog\u002Fai-plugin\u002Ftree\u002FHEAD\u002Fskills\u002Fexploring-scouts","---\nname: exploring-scouts\ndescription: >\n  How to explore and make sense of PostHog Signals scouts — the scheduled agents that scan a\n  project and write reports into the Signals inbox. Use when a user wants to understand what\n  scouts they have, how each one is behaving, and whether the fleet is actually working. Covers\n  surveying the fleet and its schedules, reading recent scout runs and drilling into a single\n  run's reasoning, inspecting the durable scratchpad memory the fleet has built up, tracing a\n  run to the reports it wrote or edited, and assessing a scout's health and performance over time\n  (cadence, success rate, report rate, signal-to-noise). Read-only and exploratory — to write or\n  tune a scout, use `authoring-scouts` instead. Trigger on \"what are my scouts doing\",\n  \"how is my \u003Cx> scout performing\", \"show me recent scout runs\", \"why did this scout find\u002Freport\n  nothing\", \"what has the fleet learned\", \"explore scout run \u003Cid>\", \"is my scout working\".\nmetadata:\n  owner_team: signals\n---\n\n# Exploring Signals scouts\n\nA **scout** is a scheduled agent that wakes on its own interval, looks at one PostHog project, decides what's genuinely worth surfacing, and either writes it into the Signals inbox as a **report** or closes out empty (a real, valid outcome).\nPostHog ships a fleet of canonical scouts — a cross-product generalist (`signals-scout-general`) plus per-surface specialists (error tracking, logs, AI observability, experiments, feature flags, session replay, web analytics, surveys, and more).\nA project may also have **custom scouts** beyond the canonical fleet — any `signals-scout-*` skill a team authored (e.g. `-brand-mentions`, `-mcp-feedback`) shows up here too, so don't assume a fixed roster: `scout-config-list` is the authoritative roster for a project.\n(One caveat: a just-authored scout has no config row until the coordinator's next tick auto-registers one — or until someone registers it via the write-side `scout-config-create` — so a brand-new scout may briefly be missing from the list.)\n\nThis skill helps you **understand and explore what a project's scouts are doing and how they're performing** — entirely through read-only MCP tools.\nIt is the observability counterpart to the `authoring-scouts` skill (which teaches writing and tuning) and to the `inbox-exploration` skill (which covers the inbox reports scouts feed into).\n(The scout tools were recently renamed from `signals-scout-*` to `scout-*`; if a `scout-*` name comes back unknown, the server may still expose it under the legacy `signals-scout-*` name — search the tool catalog and call whichever name it returns.)\n\n**A scout's output is inbox reports, written 1:1.** Scouts list `emit_report` \u002F `edit_report` in their `allowed_tools` and **author or edit inbox reports directly**; a run's output shows up as **`emitted_report_ids`** (reports it authored) and **`edited_report_ids`** (reports it updated).\nThe run rows also carry `emitted_count` \u002F `emitted_finding_ids` — **legacy fields from the deprecated signal-emitting channel** (weak `emit_signal` findings a pipeline consolidated). On a report-channel scout they stay `0` \u002F empty even on a productive run; a non-zero tally means the run came from a scout still on the legacy channel (an old custom scout, or a canonical scout not yet ported) — real output for that run, not noise. When unsure of a scout's channel, check its `allowed_tools` via `skill-get`.\n**Never read `emitted_count: 0` as \"did nothing\"** — check the report columns and the run summary first.\n\nThere are six things you can observe about the fleet, each with its own tool:\n\n| What you want to know                        | Tool                            | What it tells you                                                                                 |\n| -------------------------------------------- | ------------------------------- | ------------------------------------------------------------------------------------------------- |\n| Which scouts run, how often, in what posture | `scout-config-list`             | One row per scout: schedule, `enabled`, `emit`, `last_run_at`, `description`                      |\n| What the scouts actually did, run by run     | `scout-runs-list` \u002F `-retrieve` | Per-run status, timing, end-of-run summary, `emitted_report_ids` \u002F `edited_report_ids`, deep-link |\n| What the fleet has learned across runs       | `scout-scratchpad-search`       | Durable per-team memory (baselines, noise, allowlists)                                            |\n| What the team has told the fleet             | `scout-notes-list`              | Steering notes humans\u002Fagents left for scouts (per-scout or fleet-wide, newest first)              |\n| Which reports a run wrote or edited          | the run row itself              | `emitted_report_ids` \u002F `edited_report_ids` — resolve each id via `inbox-reports-retrieve`         |\n| What the scouts surfaced to the user         | `inbox-reports-list`            | The scout-written reports, as the user sees them (filter `source_product: \"signals_scout\"`)       |\n\nThe orienting tool is `scout-project-profile-get` — the deterministic snapshot of \"what's true about this project\" that every scout cold-starts from.\nWhen a scout found nothing, this is usually why.\n\n## Output handling: expect to offload to a file\n\nTwo of these tools — `scout-runs-list` and especially `tasks-runs-session-logs-retrieve` — routinely return payloads that **overflow an MCP client's token budget and get spilled to a file**.\nThis is the normal path, not an error.\nPlan for it up front rather than discovering it after a failed call:\n\n- **Keep `limit` small** on `scout-runs-list` (~10–15).\n  Each row carries a long prose `summary`, and runs come back newest-first across the _whole_ fleet, so even a modest page is large.\n- **Session logs are large by nature.** A single run's log is hundreds of KB to a few MB.\n  Fetch it with **`call --json`** (so the saved file is real JSON, not the pretty text format — `jq`-able) and read the saved file with `jq` \u002F a script rather than inline.\n- **Don't hand-parse the session log.** The bundled [`scripts\u002F`](#helper-scripts) do the reconstruction for you — see below.\n\n## Start here: is the fleet even set up?\n\nDon't assume the project has scouts.\nThe fleet only runs on teams enrolled via the `signals-scout` feature flag, and a project may have no configs, all-disabled scouts, or scouts stuck in dry-run.\nRun this first whenever a user asks about their scouts for the first time in a session.\n\n```json\nscout-config-list\n```\n\nRead the result against three cases:\n\nThe config list is unpaginated — it comes back as `{ results: [...] }` (a bare array), with no `count` field.\nRead the result against three cases:\n\n- **Empty (`results: []`)** — no scouts are registered.\n  The project isn't enrolled in the scout fleet (or hasn't ticked yet).\n  Say so plainly; don't go fishing for runs.\n  Point the user at the Signals scout settings \u002F PostHog Desktop onboarding rather than inventing activity.\n- **Configs exist but all `enabled: false`** — the fleet is registered but paused.\n  Nothing is running.\n  Tell the user which scouts exist and that they're all off.\n- **At least one `enabled: true`** — the fleet is registered and that scout is allowed to run.\n  For each enabled scout note its `run_interval_minutes` (cadence), `emit` (false = **dry-run**, runs but writes nothing to the inbox), and `last_run_at`.\n  One caveat before reporting \"it's live\": runs are gated by the `signals-scout` feature flag, not by `enabled`.\n  A project that was enrolled and later drained from the flag keeps its `enabled: true` rows, but the coordinator no longer plans runs for it — so a stale or `null` `last_run_at` on an enabled scout usually means the project is no longer enrolled, not that the scout is idle.\n\n  **`last_run_at` is a _dispatch_ stamp, not proof a run executed.** The coordinator advances it the moment it _enqueues_ a child workflow for a due scout — before any worker picks the run up.\n  Child dispatch is fire-and-forget, so if workers are saturated or down the children just queue and no run ever materializes, yet `last_run_at` keeps marching forward each tick.\n  So a recent `last_run_at` means \"dispatched this tick,\" **not** \"a run is genuinely happening.\"\n  The authoritative liveness signal is the newest actual **run row** in `scout-runs-list`, not the config stamp.\n  Cross-check them: if `last_run_at` is fresh (minutes ago) but no run row has appeared for that scout in well over its `run_interval_minutes`, the fleet is **dispatching but not running** — workers backed up \u002F down, or runs stranded — a real reliability problem, not a live scout.\n  Don't report \"it's running\" off `last_run_at` alone.\n\nA scout that is `enabled: true` but `emit: false` is the most common source of \"my scout isn't doing anything\" confusion: it _is_ running and reasoning every tick, it just isn't allowed to post reports yet.\nAlways surface the `emit` posture when reporting on a scout.\n\nSee [`references\u002Fscout-data-model.md`](references\u002Fscout-data-model.md) for every field on a config, run, and scratchpad entry, the run status values, and how the pieces link together.\n\n## Workflow: survey the fleet\n\n\"What scouts do I have \u002F what are they doing?\" — lead with `config-list`, then enrich with the most recent run per scout so the user sees liveness, not just configuration.\n\n1. `scout-config-list` — the roster.\n2. For each enabled scout, `scout-runs-list` and pick the newest run with a matching `skill_name` (runs come back newest-first across the whole fleet, so a single call usually covers everyone).\n   Report `status` and how long ago it ran.\n\nPresent it as a table the user can scan — scout, cadence, posture, last run, last outcome — and call out anything anomalous (never run, last run errored, stuck in dry-run for a long time).\n\n## Workflow: understand one scout end to end\n\n\"How does my error-tracking scout work \u002F how is it doing?\"\n\n1. **Read its config** — find the row in `config-list` for `signals-scout-error-tracking`: schedule, posture, last run.\n2. **Read its body** — `posthog:skill-get {\"skill_name\": \"signals-scout-error-tracking\"}` returns the team's actual instruction set (which may be a canonical default or a diverged, hand-edited row).\n   This is what the agent is told to do every run — its signal-vs-noise discriminator, explore patterns, and disqualifiers.\n   To understand _why_ a scout behaves the way it does, read its body.\n3. **Read its recent runs** — `runs-list` with `text` set to the skill's domain, or just scan the newest runs and filter to its `skill_name`.\n   The end-of-run `summary` on each run is the scout's own account of what it looked at and decided.\n4. **Read what it remembered** — `scratchpad-search` (see below).\n   The memory entries a scout wrote reveal the baselines and noise it has internalized about this project.\n5. **Read what it was told** — `scout-notes-list {\"skill_name\": \"signals-scout-error-tracking\"}` returns the steering notes humans left for this scout plus the general fleet-wide ones — exactly what its runs read as prior context.\n   A behavior change that doesn't trace to a skill edit or a scratchpad entry often traces to a note.\n   When asked to _steer_ a scout with a note (rather than observe), hand off to the `authoring-scouts` skill, which covers the notes channel's write side.\n\n## Workflow: read recent runs\n\n`scout-runs-list` returns the most recent runs across the whole fleet, newest first (capped at 100).\nUse it to answer \"what happened lately?\"\n\n- **Scope to a window** with `date_from` \u002F `date_to` (ISO-8601; inclusive lower, exclusive upper on `created_at`).\n  Walk backwards by passing an earlier `date_to`.\n- **Search summaries** with `text` — a case-insensitive substring match on each run's end-of-run `summary`.\n  This is how the headless scout dedupes, and it's how you find \"did any run already look at the checkout error spike?\"\n- **Filter by output** with `emitted` — `emitted=true` returns only runs that authored at least one report (or, on legacy runs, emitted a finding), `emitted=false` only the runs that authored nothing.\n  This is the direct way to answer \"which runs actually wrote something?\" without parsing prose.\n  One caveat: a run that only **edited** an existing report doesn't count as `emitted=true` — check `edited_report_ids` before calling such a run quiet.\n\nEach summary row carries `run_id`, `skill_name`, `skill_version`, `status`, `started_at`, `completed_at`, `emitted_report_ids` \u002F `edited_report_ids` (the reports the run wrote or edited — its output), `emitted_count` \u002F `emitted_finding_ids` (the legacy signal-channel tally — `0` \u002F empty on current scouts), `task_url` (a deep-link into the Tasks UI for the full transcript), and the `summary` prose.\nLead with the `summary` when narrating to the user — it's the scout's own plain-language close-out — and always offer the `task_url` for the full reasoning.\n\n## Workflow: drill into a single run\n\nWhen the user wants the full story of one run (or pastes a run id \u002F Tasks URL):\n\n```json\nscout-runs-retrieve\n{ \"id\": \"\u003Cuuid>\" }\n```\n\nNote the field name flip: `runs-list` returns each run's id as `run_id`, but `runs-retrieve` takes it as `id`.\nPass the `run_id` value through as `id`.\n\nReturns the full run: `status`, `started_at` \u002F `completed_at` (compute duration from these), `skill_name` \u002F `skill_version` (what ran, at what body version), the end-of-run `summary`, `emitted_report_ids` \u002F `edited_report_ids`, and `task_url`.\nThe transcript — the actual tool calls and reasoning — lives in the Tasks UI behind `task_url`, not in this payload; hand the user that link when they want to see every step.\nA **failed** run returns an empty `summary` and **no error field** — the payload looks the same as the list row, so to learn _why_ it failed you need the transcript.\n\nYou don't have to open the UI for that: **`tasks-runs-session-logs-retrieve` returns the run's session log (every tool call, message, and reasoning step) as data** — handy when you're diagnosing a failure or want to trace exactly what a run did without leaving the conversation.\nPass the run's `task_run_id` as `id` and its `task_id` (both are on the run row).\n\nThe raw stream is large (hundreds of KB to a few MB) and will overflow inline, so **fetch it with `call --json` and let it spill to a file**, then run it through [`scripts\u002Frender_run_report.py`](#helper-scripts) rather than parsing it by hand.\n\n⚠️ **Do not reach for `exclude_types: \"tool_call_update,…\"` to slim it down.** It is tempting — the stream is dominated by incremental `tool_call_update` chunks — but each tool's **actual input lives only in those chunks**: the base `tool_call` event carries an empty `rawInput`, and the streamed updates build the input (and the final `rawOutput`) token by token.\nExcluding them leaves you with tool _names_ but no idea what the scout actually queried.\nFetch the **full** log and let the script reassemble each call (it groups by `toolCallId`, keeps the richest `rawInput`, and attaches the completion's `rawOutput`\u002F`status`).\n\n**Whether a run wrote anything is a first-class field: `emitted_report_ids` \u002F `edited_report_ids`.** A non-empty `emitted_report_ids` lists the reports the run authored via `emit_report`, in order; `edited_report_ids` lists the reports it mutated via `edit_report` (which can target any inbox report, not just ones a scout authored).\nA productive run typically has one id there and a summary like `Report authored: \u003Cid>`; resolve any id via `inbox-reports-retrieve` to read the report itself.\nDon't parse the prose `summary` for output — a phrase like \"already reported P1 … did not re-file\" describes a _prior_ run, so substring-matching the summary is unreliable; the id columns are the authoritative tally.\n\n**Legacy runs: `emitted_count` \u002F `emitted_finding_ids`.** Runs from the deprecated signal-emitting channel (a scout without the `allowed_tools` opt-in — an old custom scout, or a canonical scout not yet ported) tally their output as `emitted_count` weak findings instead; each `finding_id` maps to a `Signal` with `source_id = run:\u003Crun_id>:finding:\u003Cfinding_id>`.\nFor those runs only, `scout-runs-emission-reports` (pass the `run_id`) maps each emitted finding to the inbox report its signal grouped into (or `null` if it never surfaced).\nOn report-channel scouts these fields are always `0` \u002F empty — don't diagnose off them.\nSee [`references\u002Fscout-data-model.md`](references\u002Fscout-data-model.md) for the full field reference.\n\nA run with `status` complete and an empty-handed summary (\"surface at baseline, nothing to report\") is a **healthy** outcome, not a failure — most runs should close out empty.\nTreat a stream of empty close-outs as the fleet doing its job, not as the fleet being broken.\n\n## Workflow: inspect what the fleet has learned\n\nThe **scratchpad** is the fleet's durable, per-team memory — prose entries scouts write so future runs get smarter and quieter.\nReading it tells you what the fleet believes about this project.\n\n```json\nscout-scratchpad-search\n{ \"text\": \"error_tracking\" }\n```\n\nReturns entries newest-first (capped at 100); `text` matches `content` and `key` case-insensitively.\nOmit `text` to browse everything.\nEach entry's `key` carries a category prefix that tells you _what kind_ of learning it is:\n\n| Prefix        | Meaning                                                                                |\n| ------------- | -------------------------------------------------------------------------------------- |\n| `pattern:`    | A baseline — how this team's data normally shapes                                      |\n| `watch:`      | A live issue being tracked but still below the report bar                              |\n| `noise:`      | A pattern the fleet has decided to ignore (dev-only, single-user…)                     |\n| `addressed:`  | Something the team fixed or moved on from                                              |\n| `dedupe:`     | A gate on re-filing a specific issue \u002F fingerprint                                     |\n| `allowlist:`  | Vetted entities never to re-surface                                                    |\n| `not-in-use:` | A product\u002Fsurface this team doesn't use (close-out memo)                               |\n| `mcp-gap:`    | A tooling gap a scout noticed worth raising later                                      |\n| `improve:`    | A custom scout's suggested change to its own skill body, awaiting owner review         |\n| `reported:`   | A canonical scout's record of a skill gap already fed back upstream to PostHog         |\n| `report:`     | A report a scout authored — stores the `report_id` so later runs edit\u002Fdedup against it |\n| `reviewer:`   | A resolved owner (GitHub login) for an area, cached for `suggested_reviewers` routing  |\n\nThis is the common vocabulary, not a closed set — scouts coin their own prefixes and `\u003Cdomain>` labels as needed (the live fleet uses `watch:` heavily, for example), so treat an unfamiliar prefix as just another category.\nEntries cross-reference each other with `[[key]]` wikilinks.\nKeys follow `\u003Cprefix>:\u003Cdomain>:\u003Centity>` (e.g. `dedupe:error_tracking:019e8375-…`).\n\nWhen a user asks \"why isn't my scout flagging X anymore?\", search the scratchpad for `noise:`, `addressed:`, `dedupe:`, and `allowlist:` entries — the fleet may have deliberately learned to suppress it.\nThe canonical prefix vocabulary and the four-state dedupe classifier the fleet reasons in terms of are documented in the `authoring-scouts` skill (`references\u002Fdedupe-and-memory.md`).\n\n**Custom scouts self-report skill improvements.** A custom (team-authored) scout is invited by the harness to write an `improve:\u003Cskill-name>:\u003Ctopic>` entry when a run produces concrete evidence its own skill body steered it wrong — the suggested change, the evidence, and a dated observed line, re-confirmed in place on later runs.\nA custom scout on the report channel escalates recurring or material suggestions further: it files an inbox report about itself (titled `Scout self-improvement: \u003Cskill-name> – \u003Ctopic>`) and stashes the `report_id` in the `improve:` entry — so the strongest suggestions reach the owner through the inbox like any other report, not only via the scratchpad.\nWhen assessing a custom scout, search `{\"text\": \"improve:\"}` and surface these to the user: an entry re-confirmed across several runs is the highest-signal edit the owner can make.\nReviewing and applying them is a write operation — hand off to the `authoring-scouts` skill.\nCanonical scouts never write `improve:` entries (their skill bodies are synced from PostHog's fleet), so an `improve:` entry under a canonical scout's domain is itself worth flagging.\nInstead, a canonical scout routes skill-content gaps upstream to the PostHog team via the `agent-feedback` MCP tool (`feedback_type: \"scout\"`), generalized so no project data travels, and keeps a `reported:\u003Cskill-name>:\u003Ctopic>` entry as its local record of what it already submitted — so a `reported:` entry tells you a gap has been raised with PostHog, not with this team.\n\n## Workflow: see what scouts have written\n\nScout output reaches the user as inbox reports.\nFilter the inbox to the scout source:\n\n```json\ninbox-reports-list\n{ \"source_product\": \"signals_scout\", \"limit\": 20 }\n```\n\nThis is the direct way to find the reports scouts **authored**.\nEvery report a scout authors carries backing signals tagged `source_product=\"signals_scout\"`, and the inbox filter keeps any report whose contributing signals include that tag — so the result is the set of reports the fleet has authored.\nIt does **not** capture edit-only work: a scout that edits an existing non-scout report (appending a note to a pipeline report, say) adds no `signals_scout` signal, so that report won't match the filter — trace edits through the run rows' `edited_report_ids` instead.\n\nAn empty result means the fleet hasn't authored any reports (yet), **not** that the filter is broken.\nScouts hold a high bar — most runs close out without writing — so on a quiet or newly enrolled project zero scout reports is the normal, expected state.\nNote the inbox only shows **surfaced** reports: a report the safety judge suppressed (or one filed as `not_actionable`) persists with status `SUPPRESSED` but doesn't appear in the default inbox view.\n\nFor the per-run view, work from the runs instead: `scout-runs-list?emitted=true` lists every run that authored a report, and each run's `emitted_report_ids` \u002F `edited_report_ids` name exactly which reports it wrote or updated — resolve them via `inbox-reports-retrieve`.\nThe flip side matters when explaining a gap: a run can narrate \"authored a report\" in its `summary` yet have the write **silently dropped** by a preflight gate (dry-run at the time, the org hasn't approved AI processing, or the `signals_scout` source is disabled) — those leave `emitted_report_ids` empty, so a claimed-but-absent report is itself a diagnostic.\nTo browse the inbox more broadly, use the `inbox-exploration` skill (statuses, suggested reviewers, drilling into a report's underlying signals).\nThe report contract behind each report — the report bar, evidence, actionability, reviewer routing — is documented in the `authoring-scouts` skill (`references\u002Freport-contract.md`).\n\n## Workflow: assess health and performance\n\n\"Is my scout actually working \u002F earning its cost?\"\nThere's no single metric — judge a scout over a window of runs.\nPull the runs (`runs-list` with a `date_from`), then reason across the dimensions below.\nThe full playbook, including how to read each signal and the common failure modes, is in [`references\u002Fassessing-performance.md`](references\u002Fassessing-performance.md).\n\n- **Cadence adherence** — are runs landing roughly every `run_interval_minutes`?\n  Large gaps mean the coordinator is skipping it (disabled, drained from the flag, or capped out on busy ticks) — _or_ it's dispatching but the runs aren't materializing.\n  Tell the two apart with `last_run_at`: if the config's `last_run_at` is also stale, the coordinator stopped planning it; if `last_run_at` is fresh but the newest run row is hours old, it's the dispatch-vs-execution divergence above (workers backed up \u002F down, or runs stranded), which `runs-list` alone hides.\n- **Success rate** — how many runs reach a clean `status` vs. error out?\n  A run of errors is a broken scout, not a quiet one.\n- **Report rate** — what fraction of runs wrote or edited a report vs. closed out empty.\n  Read it straight off `emitted_report_ids` \u002F `edited_report_ids` per run (or split the window with `runs-list?emitted=true` \u002F `?emitted=false`, remembering edit-only runs read as not-emitted).\n  Near-zero over a long window on a live surface can mean the discriminator is too strict (or the surface really is quiet); near-100% usually means it's too noisy.\n  Most healthy scouts write rarely.\n- **Signal-to-noise** — of what it wrote, how much surfaced as actionable inbox reports vs. got suppressed or dismissed?\n  Resolve each run's `emitted_report_ids` via `inbox-reports-retrieve` and read the report statuses — across a window, the share of authored reports that are live and non-suppressed is the scout's hit rate.\n- **Memory growth** — a healthy scout accumulates `pattern:` \u002F `noise:` \u002F `dedupe:` entries over time.\n  A scout with an empty scratchpad after many runs isn't learning.\n\n## Helper scripts\n\nThe skill bundles three **pure formatters** under [`scripts\u002F`](scripts\u002F) for the most common asks.\nThey do **no network I\u002FO** — they are the back half of an \"agent fetches, script formats\" split.\nThe pattern is always the same:\n\n1. Fetch each payload with the MCP using **`call --json`** (raw JSON, not the pretty text format) and save it to a file.\n   For the big ones (`runs-list`, `tasks-runs-session-logs-retrieve`) this is mandatory anyway — they overflow inline and spill to a file you can point the script at.\n2. Run the script over those files.\n\nAll three are stdlib-only Python 3.11+ and print **plain text** to stdout (or `--out`) — designed to read well in a terminal, so save them as `.txt`.\n\n### `scripts\u002Frender_run_report.py` — drill into one run\n\nProduces the kind of detailed write-up you'd want when inspecting a single run: header (status, duration, posture), a **narrated timeline that interleaves the agent's narration with each tool call _and its real input_**, the end-of-run summary, and any scratchpad memory.\n\n```bash\n# fetch (note --json), saving each to a file:\n#   call --json scout-runs-retrieve { \"id\": \"\u003Crun_id>\" }            -> run.json\n#   call --json tasks-runs-session-logs-retrieve { \"id\": \"\u003Ctask_run_id>\", \"task_id\": \"\u003Ctask_id>\", \"offset\": 0 }  -> log.json   (FULL — no exclude_types)\n#   (optional) call --json scout-scratchpad-search { ... }          -> mem.json\n#   (optional) call --json scout-config-list {}                     -> cfg.json\npython scripts\u002Frender_run_report.py --run run.json --log log.json \\\n    --scratchpad mem.json --config cfg.json --out report.txt\n```\n\nModes (`--mode`, default `detailed`):\n\n| Mode       | Contains                                                           | `--log` needed? |\n| ---------- | ------------------------------------------------------------------ | --------------- |\n| `summary`  | header + posture + close-out prose                                 | no              |\n| `detailed` | + narrated timeline with tool **inputs** + tool tally + scratchpad | yes             |\n| `full`     | + each tool call's (truncated) **output** inline                   | yes             |\n\nOther flags: `--show-output` (outputs in detailed mode), `--input-width` \u002F `--output-width` (truncation), `--no-art` (skip the hedgehog banner), `--base-url` (defaults to `us.posthog.com`).\n\n### `scripts\u002Ffleet_survey.py` — survey the whole fleet\n\nOne scannable table — scout, enabled, posture, cadence, last run, last outcome — with a \"worth a look\" section that flags never-run, stuck-in-dry-run, and last-run-failed scouts.\n\n```bash\n#   call --json scout-config-list {}                 -> cfg.json\n#   (optional) call --json scout-runs-list { \"limit\": 30 }  -> runs.json   (small limit!)\npython scripts\u002Ffleet_survey.py --config cfg.json --runs runs.json --now \u003Ccurrent-ISO-time>\n```\n\nPass `--now` (the current time, ISO-8601) to get relative \"ago\" columns; the last-outcome column reads what the run wrote straight off `emitted_report_ids` \u002F `edited_report_ids` on the run row.\n\n### `scripts\u002Fassess_health.py` — health over a window of runs\n\nImplements the \"assess health and performance\" workflow above: a per-scout table (runs, success %, report rate, cadence gap vs interval, adherence, median duration, memory growth) plus a \"worth a look\" section flagging all-failed scouts, timeout-shaped failures, cadence stalls, staleness, and empty scratchpads.\n\n```bash\n#   call --json scout-runs-list { \"limit\": 100, \"date_from\": \"\u003CISO>\" }  -> runs.json\n#   (optional) call --json scout-config-list {}                          -> cfg.json\n#   (optional) call --json scout-scratchpad-search {}                    -> mem.json\npython scripts\u002Fassess_health.py --runs runs.json --config cfg.json \\\n    --scratchpad mem.json --now \u003Ccurrent-ISO-time> [--skill signals-scout-general]\n```\n\n`--config` is what lets it score cadence adherence (the expected interval) and staleness (the authoritative `last_run_at`, which the windowed runs can miss when the 100-row cap truncates the newest runs).\nWithout `--scratchpad` the memory column shows `n\u002Fa` and no memory flags fire.\nThe report rate reads the run rows' `emitted_report_ids` \u002F `edited_report_ids` directly, so it's exact — but it only counts _writes_; judge signal-to-noise by the resulting report statuses via `inbox-reports-list`.\n\n## Tips\n\n- **Always surface the `emit` posture.** \"Running but in dry-run\" is the single most common reason a user thinks a scout is broken when it isn't.\n- **An empty close-out is success.** Most runs should find nothing.\n  Don't report a wall of clean, empty runs as a problem.\n- **What a run wrote is a first-class run field.** Read `emitted_report_ids` \u002F `edited_report_ids` per run (or filter with `runs-list?emitted=true`) to find what was written, without parsing the prose `summary`.\n  The `source_product: \"signals_scout\"` inbox filter lists the _reports_ the fleet surfaced; an empty result there means it hasn't written anything yet (scouts hold a high bar), not that the filter is broken.\n- **`emitted_count: 0` does not mean \"did nothing\".** `emitted_count` \u002F `emitted_finding_ids` are legacy signal-channel fields — they stay `0` \u002F empty on report-channel scouts, productive or not.\n  Judge output by the report columns; a non-zero legacy tally means the run came from a scout still on the legacy channel, and is that run's real output.\n- **A ~30-min run that `failed` is usually a timeout, not a broken scout.** Completed runs finish in a couple of minutes.\n  Most often the scout over-investigated and ran the full budget (the fleet self-corrects by writing \"tight-run recipe\" scratchpad entries) — but some are false timeouts where the scout actually finished in a few minutes and the run then hung on a dropped close-out.\n  The session log (above) tells them apart: real over-investigation shows tool calls right up to the wall; a false timeout goes silent long before it.\n  Don't assume over-investigation from duration alone.\n- **Lead with the run `summary`**, then offer `task_url` for the full transcript — don't dump raw run rows at the user.\n- **`last_run_at: null`** means a scout has never fired — check it's enabled and the project is enrolled before digging further.\n- **To explain a quiet scout, read the project profile.** `scout-project-profile-get` shows whether the surface it watches is even in use — a logs scout on a project with no logs has nothing to do.\n- **This skill is read-only.** To change a scout's schedule, posture, or body, hand off to the `authoring-scouts` skill — it covers `scout-config-update` and the skills-store edit path.\n",{"data":36,"body":39},{"name":4,"description":6,"metadata":37},{"owner_team":38},"signals",{"type":40,"children":41},"root",[42,51,128,185,316,321,553,566,573,600,705,711,724,746,751,772,982,1016,1032,1038,1051,1093,1098,1104,1109,1247,1253,1263,1381,1488,1494,1499,1564,1611,1707,1747,1777,1879,1958,2056,2075,2081,2093,2148,2196,2438,2481,2525,2625,2631,2636,2719,2759,2793,2874,2880,2909,3071,3077,3106,3142,3169,3181,3198,3325,3346,3455,3506,3518,3523,3601,3627,3639,3644,3749,3809,3815,4024],{"type":43,"tag":44,"props":45,"children":47},"element","h1",{"id":46},"exploring-signals-scouts",[48],{"type":49,"value":50},"text","Exploring Signals scouts",{"type":43,"tag":52,"props":53,"children":54},"p",{},[55,57,63,65,70,72,79,81,86,88,94,96,102,104,110,112,118,120,126],{"type":49,"value":56},"A ",{"type":43,"tag":58,"props":59,"children":60},"strong",{},[61],{"type":49,"value":62},"scout",{"type":49,"value":64}," is a scheduled agent that wakes on its own interval, looks at one PostHog project, decides what's genuinely worth surfacing, and either writes it into the Signals inbox as a ",{"type":43,"tag":58,"props":66,"children":67},{},[68],{"type":49,"value":69},"report",{"type":49,"value":71}," or closes out empty (a real, valid outcome).\nPostHog ships a fleet of canonical scouts — a cross-product generalist (",{"type":43,"tag":73,"props":74,"children":76},"code",{"className":75},[],[77],{"type":49,"value":78},"signals-scout-general",{"type":49,"value":80},") plus per-surface specialists (error tracking, logs, AI observability, experiments, feature flags, session replay, web analytics, surveys, and more).\nA project may also have ",{"type":43,"tag":58,"props":82,"children":83},{},[84],{"type":49,"value":85},"custom scouts",{"type":49,"value":87}," beyond the canonical fleet — any ",{"type":43,"tag":73,"props":89,"children":91},{"className":90},[],[92],{"type":49,"value":93},"signals-scout-*",{"type":49,"value":95}," skill a team authored (e.g. ",{"type":43,"tag":73,"props":97,"children":99},{"className":98},[],[100],{"type":49,"value":101},"-brand-mentions",{"type":49,"value":103},", ",{"type":43,"tag":73,"props":105,"children":107},{"className":106},[],[108],{"type":49,"value":109},"-mcp-feedback",{"type":49,"value":111},") shows up here too, so don't assume a fixed roster: ",{"type":43,"tag":73,"props":113,"children":115},{"className":114},[],[116],{"type":49,"value":117},"scout-config-list",{"type":49,"value":119}," is the authoritative roster for a project.\n(One caveat: a just-authored scout has no config row until the coordinator's next tick auto-registers one — or until someone registers it via the write-side ",{"type":43,"tag":73,"props":121,"children":123},{"className":122},[],[124],{"type":49,"value":125},"scout-config-create",{"type":49,"value":127}," — so a brand-new scout may briefly be missing from the list.)",{"type":43,"tag":52,"props":129,"children":130},{},[131,133,138,140,146,148,154,156,161,163,169,171,176,178,183],{"type":49,"value":132},"This skill helps you ",{"type":43,"tag":58,"props":134,"children":135},{},[136],{"type":49,"value":137},"understand and explore what a project's scouts are doing and how they're performing",{"type":49,"value":139}," — entirely through read-only MCP tools.\nIt is the observability counterpart to the ",{"type":43,"tag":73,"props":141,"children":143},{"className":142},[],[144],{"type":49,"value":145},"authoring-scouts",{"type":49,"value":147}," skill (which teaches writing and tuning) and to the ",{"type":43,"tag":73,"props":149,"children":151},{"className":150},[],[152],{"type":49,"value":153},"inbox-exploration",{"type":49,"value":155}," skill (which covers the inbox reports scouts feed into).\n(The scout tools were recently renamed from ",{"type":43,"tag":73,"props":157,"children":159},{"className":158},[],[160],{"type":49,"value":93},{"type":49,"value":162}," to ",{"type":43,"tag":73,"props":164,"children":166},{"className":165},[],[167],{"type":49,"value":168},"scout-*",{"type":49,"value":170},"; if a ",{"type":43,"tag":73,"props":172,"children":174},{"className":173},[],[175],{"type":49,"value":168},{"type":49,"value":177}," name comes back unknown, the server may still expose it under the legacy ",{"type":43,"tag":73,"props":179,"children":181},{"className":180},[],[182],{"type":49,"value":93},{"type":49,"value":184}," name — search the tool catalog and call whichever name it returns.)",{"type":43,"tag":52,"props":186,"children":187},{},[188,193,195,201,203,209,211,217,219,224,226,235,237,246,248,254,255,261,263,268,270,276,278,284,286,291,293,299,301,314],{"type":43,"tag":58,"props":189,"children":190},{},[191],{"type":49,"value":192},"A scout's output is inbox reports, written 1:1.",{"type":49,"value":194}," Scouts list ",{"type":43,"tag":73,"props":196,"children":198},{"className":197},[],[199],{"type":49,"value":200},"emit_report",{"type":49,"value":202}," \u002F ",{"type":43,"tag":73,"props":204,"children":206},{"className":205},[],[207],{"type":49,"value":208},"edit_report",{"type":49,"value":210}," in their ",{"type":43,"tag":73,"props":212,"children":214},{"className":213},[],[215],{"type":49,"value":216},"allowed_tools",{"type":49,"value":218}," and ",{"type":43,"tag":58,"props":220,"children":221},{},[222],{"type":49,"value":223},"author or edit inbox reports directly",{"type":49,"value":225},"; a run's output shows up as ",{"type":43,"tag":58,"props":227,"children":228},{},[229],{"type":43,"tag":73,"props":230,"children":232},{"className":231},[],[233],{"type":49,"value":234},"emitted_report_ids",{"type":49,"value":236}," (reports it authored) and ",{"type":43,"tag":58,"props":238,"children":239},{},[240],{"type":43,"tag":73,"props":241,"children":243},{"className":242},[],[244],{"type":49,"value":245},"edited_report_ids",{"type":49,"value":247}," (reports it updated).\nThe run rows also carry ",{"type":43,"tag":73,"props":249,"children":251},{"className":250},[],[252],{"type":49,"value":253},"emitted_count",{"type":49,"value":202},{"type":43,"tag":73,"props":256,"children":258},{"className":257},[],[259],{"type":49,"value":260},"emitted_finding_ids",{"type":49,"value":262}," — ",{"type":43,"tag":58,"props":264,"children":265},{},[266],{"type":49,"value":267},"legacy fields from the deprecated signal-emitting channel",{"type":49,"value":269}," (weak ",{"type":43,"tag":73,"props":271,"children":273},{"className":272},[],[274],{"type":49,"value":275},"emit_signal",{"type":49,"value":277}," findings a pipeline consolidated). On a report-channel scout they stay ",{"type":43,"tag":73,"props":279,"children":281},{"className":280},[],[282],{"type":49,"value":283},"0",{"type":49,"value":285}," \u002F empty even on a productive run; a non-zero tally means the run came from a scout still on the legacy channel (an old custom scout, or a canonical scout not yet ported) — real output for that run, not noise. When unsure of a scout's channel, check its ",{"type":43,"tag":73,"props":287,"children":289},{"className":288},[],[290],{"type":49,"value":216},{"type":49,"value":292}," via ",{"type":43,"tag":73,"props":294,"children":296},{"className":295},[],[297],{"type":49,"value":298},"skill-get",{"type":49,"value":300},".\n",{"type":43,"tag":58,"props":302,"children":303},{},[304,306,312],{"type":49,"value":305},"Never read ",{"type":43,"tag":73,"props":307,"children":309},{"className":308},[],[310],{"type":49,"value":311},"emitted_count: 0",{"type":49,"value":313}," as \"did nothing\"",{"type":49,"value":315}," — check the report columns and the run summary first.",{"type":43,"tag":52,"props":317,"children":318},{},[319],{"type":49,"value":320},"There are six things you can observe about the fleet, each with its own tool:",{"type":43,"tag":322,"props":323,"children":324},"table",{},[325,349],{"type":43,"tag":326,"props":327,"children":328},"thead",{},[329],{"type":43,"tag":330,"props":331,"children":332},"tr",{},[333,339,344],{"type":43,"tag":334,"props":335,"children":336},"th",{},[337],{"type":49,"value":338},"What you want to know",{"type":43,"tag":334,"props":340,"children":341},{},[342],{"type":49,"value":343},"Tool",{"type":43,"tag":334,"props":345,"children":346},{},[347],{"type":49,"value":348},"What it tells you",{"type":43,"tag":350,"props":351,"children":352},"tbody",{},[353,402,444,466,488,523],{"type":43,"tag":330,"props":354,"children":355},{},[356,362,370],{"type":43,"tag":357,"props":358,"children":359},"td",{},[360],{"type":49,"value":361},"Which scouts run, how often, in what posture",{"type":43,"tag":357,"props":363,"children":364},{},[365],{"type":43,"tag":73,"props":366,"children":368},{"className":367},[],[369],{"type":49,"value":117},{"type":43,"tag":357,"props":371,"children":372},{},[373,375,381,382,388,389,395,396],{"type":49,"value":374},"One row per scout: schedule, ",{"type":43,"tag":73,"props":376,"children":378},{"className":377},[],[379],{"type":49,"value":380},"enabled",{"type":49,"value":103},{"type":43,"tag":73,"props":383,"children":385},{"className":384},[],[386],{"type":49,"value":387},"emit",{"type":49,"value":103},{"type":43,"tag":73,"props":390,"children":392},{"className":391},[],[393],{"type":49,"value":394},"last_run_at",{"type":49,"value":103},{"type":43,"tag":73,"props":397,"children":399},{"className":398},[],[400],{"type":49,"value":401},"description",{"type":43,"tag":330,"props":403,"children":404},{},[405,410,426],{"type":43,"tag":357,"props":406,"children":407},{},[408],{"type":49,"value":409},"What the scouts actually did, run by run",{"type":43,"tag":357,"props":411,"children":412},{},[413,419,420],{"type":43,"tag":73,"props":414,"children":416},{"className":415},[],[417],{"type":49,"value":418},"scout-runs-list",{"type":49,"value":202},{"type":43,"tag":73,"props":421,"children":423},{"className":422},[],[424],{"type":49,"value":425},"-retrieve",{"type":43,"tag":357,"props":427,"children":428},{},[429,431,436,437,442],{"type":49,"value":430},"Per-run status, timing, end-of-run summary, ",{"type":43,"tag":73,"props":432,"children":434},{"className":433},[],[435],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":438,"children":440},{"className":439},[],[441],{"type":49,"value":245},{"type":49,"value":443},", deep-link",{"type":43,"tag":330,"props":445,"children":446},{},[447,452,461],{"type":43,"tag":357,"props":448,"children":449},{},[450],{"type":49,"value":451},"What the fleet has learned across runs",{"type":43,"tag":357,"props":453,"children":454},{},[455],{"type":43,"tag":73,"props":456,"children":458},{"className":457},[],[459],{"type":49,"value":460},"scout-scratchpad-search",{"type":43,"tag":357,"props":462,"children":463},{},[464],{"type":49,"value":465},"Durable per-team memory (baselines, noise, allowlists)",{"type":43,"tag":330,"props":467,"children":468},{},[469,474,483],{"type":43,"tag":357,"props":470,"children":471},{},[472],{"type":49,"value":473},"What the team has told the fleet",{"type":43,"tag":357,"props":475,"children":476},{},[477],{"type":43,"tag":73,"props":478,"children":480},{"className":479},[],[481],{"type":49,"value":482},"scout-notes-list",{"type":43,"tag":357,"props":484,"children":485},{},[486],{"type":49,"value":487},"Steering notes humans\u002Fagents left for scouts (per-scout or fleet-wide, newest first)",{"type":43,"tag":330,"props":489,"children":490},{},[491,496,501],{"type":43,"tag":357,"props":492,"children":493},{},[494],{"type":49,"value":495},"Which reports a run wrote or edited",{"type":43,"tag":357,"props":497,"children":498},{},[499],{"type":49,"value":500},"the run row itself",{"type":43,"tag":357,"props":502,"children":503},{},[504,509,510,515,517],{"type":43,"tag":73,"props":505,"children":507},{"className":506},[],[508],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":511,"children":513},{"className":512},[],[514],{"type":49,"value":245},{"type":49,"value":516}," — resolve each id via ",{"type":43,"tag":73,"props":518,"children":520},{"className":519},[],[521],{"type":49,"value":522},"inbox-reports-retrieve",{"type":43,"tag":330,"props":524,"children":525},{},[526,531,540],{"type":43,"tag":357,"props":527,"children":528},{},[529],{"type":49,"value":530},"What the scouts surfaced to the user",{"type":43,"tag":357,"props":532,"children":533},{},[534],{"type":43,"tag":73,"props":535,"children":537},{"className":536},[],[538],{"type":49,"value":539},"inbox-reports-list",{"type":43,"tag":357,"props":541,"children":542},{},[543,545,551],{"type":49,"value":544},"The scout-written reports, as the user sees them (filter ",{"type":43,"tag":73,"props":546,"children":548},{"className":547},[],[549],{"type":49,"value":550},"source_product: \"signals_scout\"",{"type":49,"value":552},")",{"type":43,"tag":52,"props":554,"children":555},{},[556,558,564],{"type":49,"value":557},"The orienting tool is ",{"type":43,"tag":73,"props":559,"children":561},{"className":560},[],[562],{"type":49,"value":563},"scout-project-profile-get",{"type":49,"value":565}," — the deterministic snapshot of \"what's true about this project\" that every scout cold-starts from.\nWhen a scout found nothing, this is usually why.",{"type":43,"tag":567,"props":568,"children":570},"h2",{"id":569},"output-handling-expect-to-offload-to-a-file",[571],{"type":49,"value":572},"Output handling: expect to offload to a file",{"type":43,"tag":52,"props":574,"children":575},{},[576,578,583,585,591,593,598],{"type":49,"value":577},"Two of these tools — ",{"type":43,"tag":73,"props":579,"children":581},{"className":580},[],[582],{"type":49,"value":418},{"type":49,"value":584}," and especially ",{"type":43,"tag":73,"props":586,"children":588},{"className":587},[],[589],{"type":49,"value":590},"tasks-runs-session-logs-retrieve",{"type":49,"value":592}," — routinely return payloads that ",{"type":43,"tag":58,"props":594,"children":595},{},[596],{"type":49,"value":597},"overflow an MCP client's token budget and get spilled to a file",{"type":49,"value":599},".\nThis is the normal path, not an error.\nPlan for it up front rather than discovering it after a failed call:",{"type":43,"tag":601,"props":602,"children":603},"ul",{},[604,646,682],{"type":43,"tag":605,"props":606,"children":607},"li",{},[608,621,623,628,630,636,638,644],{"type":43,"tag":58,"props":609,"children":610},{},[611,613,619],{"type":49,"value":612},"Keep ",{"type":43,"tag":73,"props":614,"children":616},{"className":615},[],[617],{"type":49,"value":618},"limit",{"type":49,"value":620}," small",{"type":49,"value":622}," on ",{"type":43,"tag":73,"props":624,"children":626},{"className":625},[],[627],{"type":49,"value":418},{"type":49,"value":629}," (~10–15).\nEach row carries a long prose ",{"type":43,"tag":73,"props":631,"children":633},{"className":632},[],[634],{"type":49,"value":635},"summary",{"type":49,"value":637},", and runs come back newest-first across the ",{"type":43,"tag":639,"props":640,"children":641},"em",{},[642],{"type":49,"value":643},"whole",{"type":49,"value":645}," fleet, so even a modest page is large.",{"type":43,"tag":605,"props":647,"children":648},{},[649,654,656,665,667,673,675,680],{"type":43,"tag":58,"props":650,"children":651},{},[652],{"type":49,"value":653},"Session logs are large by nature.",{"type":49,"value":655}," A single run's log is hundreds of KB to a few MB.\nFetch it with ",{"type":43,"tag":58,"props":657,"children":658},{},[659],{"type":43,"tag":73,"props":660,"children":662},{"className":661},[],[663],{"type":49,"value":664},"call --json",{"type":49,"value":666}," (so the saved file is real JSON, not the pretty text format — ",{"type":43,"tag":73,"props":668,"children":670},{"className":669},[],[671],{"type":49,"value":672},"jq",{"type":49,"value":674},"-able) and read the saved file with ",{"type":43,"tag":73,"props":676,"children":678},{"className":677},[],[679],{"type":49,"value":672},{"type":49,"value":681}," \u002F a script rather than inline.",{"type":43,"tag":605,"props":683,"children":684},{},[685,690,692,703],{"type":43,"tag":58,"props":686,"children":687},{},[688],{"type":49,"value":689},"Don't hand-parse the session log.",{"type":49,"value":691}," The bundled ",{"type":43,"tag":693,"props":694,"children":696},"a",{"href":695},"#helper-scripts",[697],{"type":43,"tag":73,"props":698,"children":700},{"className":699},[],[701],{"type":49,"value":702},"scripts\u002F",{"type":49,"value":704}," do the reconstruction for you — see below.",{"type":43,"tag":567,"props":706,"children":708},{"id":707},"start-here-is-the-fleet-even-set-up",[709],{"type":49,"value":710},"Start here: is the fleet even set up?",{"type":43,"tag":52,"props":712,"children":713},{},[714,716,722],{"type":49,"value":715},"Don't assume the project has scouts.\nThe fleet only runs on teams enrolled via the ",{"type":43,"tag":73,"props":717,"children":719},{"className":718},[],[720],{"type":49,"value":721},"signals-scout",{"type":49,"value":723}," feature flag, and a project may have no configs, all-disabled scouts, or scouts stuck in dry-run.\nRun this first whenever a user asks about their scouts for the first time in a session.",{"type":43,"tag":725,"props":726,"children":731},"pre",{"className":727,"code":728,"language":729,"meta":730,"style":730},"language-json shiki shiki-themes material-theme-lighter material-theme material-theme-palenight","scout-config-list\n","json","",[732],{"type":43,"tag":73,"props":733,"children":734},{"__ignoreMap":730},[735],{"type":43,"tag":736,"props":737,"children":740},"span",{"class":738,"line":739},"line",1,[741],{"type":43,"tag":736,"props":742,"children":744},{"style":743},"--shiki-light:#90A4AE;--shiki-default:#EEFFFF;--shiki-dark:#BABED8",[745],{"type":49,"value":728},{"type":43,"tag":52,"props":747,"children":748},{},[749],{"type":49,"value":750},"Read the result against three cases:",{"type":43,"tag":52,"props":752,"children":753},{},[754,756,762,764,770],{"type":49,"value":755},"The config list is unpaginated — it comes back as ",{"type":43,"tag":73,"props":757,"children":759},{"className":758},[],[760],{"type":49,"value":761},"{ results: [...] }",{"type":49,"value":763}," (a bare array), with no ",{"type":43,"tag":73,"props":765,"children":767},{"className":766},[],[768],{"type":49,"value":769},"count",{"type":49,"value":771}," field.\nRead the result against three cases:",{"type":43,"tag":601,"props":773,"children":774},{},[775,792,808],{"type":43,"tag":605,"props":776,"children":777},{},[778,790],{"type":43,"tag":58,"props":779,"children":780},{},[781,783,789],{"type":49,"value":782},"Empty (",{"type":43,"tag":73,"props":784,"children":786},{"className":785},[],[787],{"type":49,"value":788},"results: []",{"type":49,"value":552},{"type":49,"value":791}," — no scouts are registered.\nThe project isn't enrolled in the scout fleet (or hasn't ticked yet).\nSay so plainly; don't go fishing for runs.\nPoint the user at the Signals scout settings \u002F PostHog Desktop onboarding rather than inventing activity.",{"type":43,"tag":605,"props":793,"children":794},{},[795,806],{"type":43,"tag":58,"props":796,"children":797},{},[798,800],{"type":49,"value":799},"Configs exist but all ",{"type":43,"tag":73,"props":801,"children":803},{"className":802},[],[804],{"type":49,"value":805},"enabled: false",{"type":49,"value":807}," — the fleet is registered but paused.\nNothing is running.\nTell the user which scouts exist and that they're all off.",{"type":43,"tag":605,"props":809,"children":810},{},[811,822,824,830,832,837,839,844,846,851,853,858,860,865,867,872,874,880,882,887,889,893,910,912,917,919,924,926,931,933,938,940,945,947,952,954,959,961,966,968,973,975,980],{"type":43,"tag":58,"props":812,"children":813},{},[814,816],{"type":49,"value":815},"At least one ",{"type":43,"tag":73,"props":817,"children":819},{"className":818},[],[820],{"type":49,"value":821},"enabled: true",{"type":49,"value":823}," — the fleet is registered and that scout is allowed to run.\nFor each enabled scout note its ",{"type":43,"tag":73,"props":825,"children":827},{"className":826},[],[828],{"type":49,"value":829},"run_interval_minutes",{"type":49,"value":831}," (cadence), ",{"type":43,"tag":73,"props":833,"children":835},{"className":834},[],[836],{"type":49,"value":387},{"type":49,"value":838}," (false = ",{"type":43,"tag":58,"props":840,"children":841},{},[842],{"type":49,"value":843},"dry-run",{"type":49,"value":845},", runs but writes nothing to the inbox), and ",{"type":43,"tag":73,"props":847,"children":849},{"className":848},[],[850],{"type":49,"value":394},{"type":49,"value":852},".\nOne caveat before reporting \"it's live\": runs are gated by the ",{"type":43,"tag":73,"props":854,"children":856},{"className":855},[],[857],{"type":49,"value":721},{"type":49,"value":859}," feature flag, not by ",{"type":43,"tag":73,"props":861,"children":863},{"className":862},[],[864],{"type":49,"value":380},{"type":49,"value":866},".\nA project that was enrolled and later drained from the flag keeps its ",{"type":43,"tag":73,"props":868,"children":870},{"className":869},[],[871],{"type":49,"value":821},{"type":49,"value":873}," rows, but the coordinator no longer plans runs for it — so a stale or ",{"type":43,"tag":73,"props":875,"children":877},{"className":876},[],[878],{"type":49,"value":879},"null",{"type":49,"value":881}," ",{"type":43,"tag":73,"props":883,"children":885},{"className":884},[],[886],{"type":49,"value":394},{"type":49,"value":888}," on an enabled scout usually means the project is no longer enrolled, not that the scout is idle.",{"type":43,"tag":890,"props":891,"children":892},"br",{},[],{"type":43,"tag":58,"props":894,"children":895},{},[896,901,903,908],{"type":43,"tag":73,"props":897,"children":899},{"className":898},[],[900],{"type":49,"value":394},{"type":49,"value":902}," is a ",{"type":43,"tag":639,"props":904,"children":905},{},[906],{"type":49,"value":907},"dispatch",{"type":49,"value":909}," stamp, not proof a run executed.",{"type":49,"value":911}," The coordinator advances it the moment it ",{"type":43,"tag":639,"props":913,"children":914},{},[915],{"type":49,"value":916},"enqueues",{"type":49,"value":918}," a child workflow for a due scout — before any worker picks the run up.\nChild dispatch is fire-and-forget, so if workers are saturated or down the children just queue and no run ever materializes, yet ",{"type":43,"tag":73,"props":920,"children":922},{"className":921},[],[923],{"type":49,"value":394},{"type":49,"value":925}," keeps marching forward each tick.\nSo a recent ",{"type":43,"tag":73,"props":927,"children":929},{"className":928},[],[930],{"type":49,"value":394},{"type":49,"value":932}," means \"dispatched this tick,\" ",{"type":43,"tag":58,"props":934,"children":935},{},[936],{"type":49,"value":937},"not",{"type":49,"value":939}," \"a run is genuinely happening.\"\nThe authoritative liveness signal is the newest actual ",{"type":43,"tag":58,"props":941,"children":942},{},[943],{"type":49,"value":944},"run row",{"type":49,"value":946}," in ",{"type":43,"tag":73,"props":948,"children":950},{"className":949},[],[951],{"type":49,"value":418},{"type":49,"value":953},", not the config stamp.\nCross-check them: if ",{"type":43,"tag":73,"props":955,"children":957},{"className":956},[],[958],{"type":49,"value":394},{"type":49,"value":960}," is fresh (minutes ago) but no run row has appeared for that scout in well over its ",{"type":43,"tag":73,"props":962,"children":964},{"className":963},[],[965],{"type":49,"value":829},{"type":49,"value":967},", the fleet is ",{"type":43,"tag":58,"props":969,"children":970},{},[971],{"type":49,"value":972},"dispatching but not running",{"type":49,"value":974}," — workers backed up \u002F down, or runs stranded — a real reliability problem, not a live scout.\nDon't report \"it's running\" off ",{"type":43,"tag":73,"props":976,"children":978},{"className":977},[],[979],{"type":49,"value":394},{"type":49,"value":981}," alone.",{"type":43,"tag":52,"props":983,"children":984},{},[985,987,992,994,1000,1002,1007,1009,1014],{"type":49,"value":986},"A scout that is ",{"type":43,"tag":73,"props":988,"children":990},{"className":989},[],[991],{"type":49,"value":821},{"type":49,"value":993}," but ",{"type":43,"tag":73,"props":995,"children":997},{"className":996},[],[998],{"type":49,"value":999},"emit: false",{"type":49,"value":1001}," is the most common source of \"my scout isn't doing anything\" confusion: it ",{"type":43,"tag":639,"props":1003,"children":1004},{},[1005],{"type":49,"value":1006},"is",{"type":49,"value":1008}," running and reasoning every tick, it just isn't allowed to post reports yet.\nAlways surface the ",{"type":43,"tag":73,"props":1010,"children":1012},{"className":1011},[],[1013],{"type":49,"value":387},{"type":49,"value":1015}," posture when reporting on a scout.",{"type":43,"tag":52,"props":1017,"children":1018},{},[1019,1021,1030],{"type":49,"value":1020},"See ",{"type":43,"tag":693,"props":1022,"children":1024},{"href":1023},"references\u002Fscout-data-model.md",[1025],{"type":43,"tag":73,"props":1026,"children":1028},{"className":1027},[],[1029],{"type":49,"value":1023},{"type":49,"value":1031}," for every field on a config, run, and scratchpad entry, the run status values, and how the pieces link together.",{"type":43,"tag":567,"props":1033,"children":1035},{"id":1034},"workflow-survey-the-fleet",[1036],{"type":49,"value":1037},"Workflow: survey the fleet",{"type":43,"tag":52,"props":1039,"children":1040},{},[1041,1043,1049],{"type":49,"value":1042},"\"What scouts do I have \u002F what are they doing?\" — lead with ",{"type":43,"tag":73,"props":1044,"children":1046},{"className":1045},[],[1047],{"type":49,"value":1048},"config-list",{"type":49,"value":1050},", then enrich with the most recent run per scout so the user sees liveness, not just configuration.",{"type":43,"tag":1052,"props":1053,"children":1054},"ol",{},[1055,1065],{"type":43,"tag":605,"props":1056,"children":1057},{},[1058,1063],{"type":43,"tag":73,"props":1059,"children":1061},{"className":1060},[],[1062],{"type":49,"value":117},{"type":49,"value":1064}," — the roster.",{"type":43,"tag":605,"props":1066,"children":1067},{},[1068,1070,1075,1077,1083,1085,1091],{"type":49,"value":1069},"For each enabled scout, ",{"type":43,"tag":73,"props":1071,"children":1073},{"className":1072},[],[1074],{"type":49,"value":418},{"type":49,"value":1076}," and pick the newest run with a matching ",{"type":43,"tag":73,"props":1078,"children":1080},{"className":1079},[],[1081],{"type":49,"value":1082},"skill_name",{"type":49,"value":1084}," (runs come back newest-first across the whole fleet, so a single call usually covers everyone).\nReport ",{"type":43,"tag":73,"props":1086,"children":1088},{"className":1087},[],[1089],{"type":49,"value":1090},"status",{"type":49,"value":1092}," and how long ago it ran.",{"type":43,"tag":52,"props":1094,"children":1095},{},[1096],{"type":49,"value":1097},"Present it as a table the user can scan — scout, cadence, posture, last run, last outcome — and call out anything anomalous (never run, last run errored, stuck in dry-run for a long time).",{"type":43,"tag":567,"props":1099,"children":1101},{"id":1100},"workflow-understand-one-scout-end-to-end",[1102],{"type":49,"value":1103},"Workflow: understand one scout end to end",{"type":43,"tag":52,"props":1105,"children":1106},{},[1107],{"type":49,"value":1108},"\"How does my error-tracking scout work \u002F how is it doing?\"",{"type":43,"tag":1052,"props":1110,"children":1111},{},[1112,1137,1161,1199,1216],{"type":43,"tag":605,"props":1113,"children":1114},{},[1115,1120,1122,1127,1129,1135],{"type":43,"tag":58,"props":1116,"children":1117},{},[1118],{"type":49,"value":1119},"Read its config",{"type":49,"value":1121}," — find the row in ",{"type":43,"tag":73,"props":1123,"children":1125},{"className":1124},[],[1126],{"type":49,"value":1048},{"type":49,"value":1128}," for ",{"type":43,"tag":73,"props":1130,"children":1132},{"className":1131},[],[1133],{"type":49,"value":1134},"signals-scout-error-tracking",{"type":49,"value":1136},": schedule, posture, last run.",{"type":43,"tag":605,"props":1138,"children":1139},{},[1140,1145,1146,1152,1154,1159],{"type":43,"tag":58,"props":1141,"children":1142},{},[1143],{"type":49,"value":1144},"Read its body",{"type":49,"value":262},{"type":43,"tag":73,"props":1147,"children":1149},{"className":1148},[],[1150],{"type":49,"value":1151},"posthog:skill-get {\"skill_name\": \"signals-scout-error-tracking\"}",{"type":49,"value":1153}," returns the team's actual instruction set (which may be a canonical default or a diverged, hand-edited row).\nThis is what the agent is told to do every run — its signal-vs-noise discriminator, explore patterns, and disqualifiers.\nTo understand ",{"type":43,"tag":639,"props":1155,"children":1156},{},[1157],{"type":49,"value":1158},"why",{"type":49,"value":1160}," a scout behaves the way it does, read its body.",{"type":43,"tag":605,"props":1162,"children":1163},{},[1164,1169,1170,1176,1178,1183,1185,1190,1192,1197],{"type":43,"tag":58,"props":1165,"children":1166},{},[1167],{"type":49,"value":1168},"Read its recent runs",{"type":49,"value":262},{"type":43,"tag":73,"props":1171,"children":1173},{"className":1172},[],[1174],{"type":49,"value":1175},"runs-list",{"type":49,"value":1177}," with ",{"type":43,"tag":73,"props":1179,"children":1181},{"className":1180},[],[1182],{"type":49,"value":49},{"type":49,"value":1184}," set to the skill's domain, or just scan the newest runs and filter to its ",{"type":43,"tag":73,"props":1186,"children":1188},{"className":1187},[],[1189],{"type":49,"value":1082},{"type":49,"value":1191},".\nThe end-of-run ",{"type":43,"tag":73,"props":1193,"children":1195},{"className":1194},[],[1196],{"type":49,"value":635},{"type":49,"value":1198}," on each run is the scout's own account of what it looked at and decided.",{"type":43,"tag":605,"props":1200,"children":1201},{},[1202,1207,1208,1214],{"type":43,"tag":58,"props":1203,"children":1204},{},[1205],{"type":49,"value":1206},"Read what it remembered",{"type":49,"value":262},{"type":43,"tag":73,"props":1209,"children":1211},{"className":1210},[],[1212],{"type":49,"value":1213},"scratchpad-search",{"type":49,"value":1215}," (see below).\nThe memory entries a scout wrote reveal the baselines and noise it has internalized about this project.",{"type":43,"tag":605,"props":1217,"children":1218},{},[1219,1224,1225,1231,1233,1238,1240,1245],{"type":43,"tag":58,"props":1220,"children":1221},{},[1222],{"type":49,"value":1223},"Read what it was told",{"type":49,"value":262},{"type":43,"tag":73,"props":1226,"children":1228},{"className":1227},[],[1229],{"type":49,"value":1230},"scout-notes-list {\"skill_name\": \"signals-scout-error-tracking\"}",{"type":49,"value":1232}," returns the steering notes humans left for this scout plus the general fleet-wide ones — exactly what its runs read as prior context.\nA behavior change that doesn't trace to a skill edit or a scratchpad entry often traces to a note.\nWhen asked to ",{"type":43,"tag":639,"props":1234,"children":1235},{},[1236],{"type":49,"value":1237},"steer",{"type":49,"value":1239}," a scout with a note (rather than observe), hand off to the ",{"type":43,"tag":73,"props":1241,"children":1243},{"className":1242},[],[1244],{"type":49,"value":145},{"type":49,"value":1246}," skill, which covers the notes channel's write side.",{"type":43,"tag":567,"props":1248,"children":1250},{"id":1249},"workflow-read-recent-runs",[1251],{"type":49,"value":1252},"Workflow: read recent runs",{"type":43,"tag":52,"props":1254,"children":1255},{},[1256,1261],{"type":43,"tag":73,"props":1257,"children":1259},{"className":1258},[],[1260],{"type":49,"value":418},{"type":49,"value":1262}," returns the most recent runs across the whole fleet, newest first (capped at 100).\nUse it to answer \"what happened lately?\"",{"type":43,"tag":601,"props":1264,"children":1265},{},[1266,1305,1328],{"type":43,"tag":605,"props":1267,"children":1268},{},[1269,1274,1275,1281,1282,1288,1290,1296,1298,1303],{"type":43,"tag":58,"props":1270,"children":1271},{},[1272],{"type":49,"value":1273},"Scope to a window",{"type":49,"value":1177},{"type":43,"tag":73,"props":1276,"children":1278},{"className":1277},[],[1279],{"type":49,"value":1280},"date_from",{"type":49,"value":202},{"type":43,"tag":73,"props":1283,"children":1285},{"className":1284},[],[1286],{"type":49,"value":1287},"date_to",{"type":49,"value":1289}," (ISO-8601; inclusive lower, exclusive upper on ",{"type":43,"tag":73,"props":1291,"children":1293},{"className":1292},[],[1294],{"type":49,"value":1295},"created_at",{"type":49,"value":1297},").\nWalk backwards by passing an earlier ",{"type":43,"tag":73,"props":1299,"children":1301},{"className":1300},[],[1302],{"type":49,"value":1287},{"type":49,"value":1304},".",{"type":43,"tag":605,"props":1306,"children":1307},{},[1308,1313,1314,1319,1321,1326],{"type":43,"tag":58,"props":1309,"children":1310},{},[1311],{"type":49,"value":1312},"Search summaries",{"type":49,"value":1177},{"type":43,"tag":73,"props":1315,"children":1317},{"className":1316},[],[1318],{"type":49,"value":49},{"type":49,"value":1320}," — a case-insensitive substring match on each run's end-of-run ",{"type":43,"tag":73,"props":1322,"children":1324},{"className":1323},[],[1325],{"type":49,"value":635},{"type":49,"value":1327},".\nThis is how the headless scout dedupes, and it's how you find \"did any run already look at the checkout error spike?\"",{"type":43,"tag":605,"props":1329,"children":1330},{},[1331,1336,1337,1343,1344,1350,1352,1358,1360,1365,1367,1372,1374,1379],{"type":43,"tag":58,"props":1332,"children":1333},{},[1334],{"type":49,"value":1335},"Filter by output",{"type":49,"value":1177},{"type":43,"tag":73,"props":1338,"children":1340},{"className":1339},[],[1341],{"type":49,"value":1342},"emitted",{"type":49,"value":262},{"type":43,"tag":73,"props":1345,"children":1347},{"className":1346},[],[1348],{"type":49,"value":1349},"emitted=true",{"type":49,"value":1351}," returns only runs that authored at least one report (or, on legacy runs, emitted a finding), ",{"type":43,"tag":73,"props":1353,"children":1355},{"className":1354},[],[1356],{"type":49,"value":1357},"emitted=false",{"type":49,"value":1359}," only the runs that authored nothing.\nThis is the direct way to answer \"which runs actually wrote something?\" without parsing prose.\nOne caveat: a run that only ",{"type":43,"tag":58,"props":1361,"children":1362},{},[1363],{"type":49,"value":1364},"edited",{"type":49,"value":1366}," an existing report doesn't count as ",{"type":43,"tag":73,"props":1368,"children":1370},{"className":1369},[],[1371],{"type":49,"value":1349},{"type":49,"value":1373}," — check ",{"type":43,"tag":73,"props":1375,"children":1377},{"className":1376},[],[1378],{"type":49,"value":245},{"type":49,"value":1380}," before calling such a run quiet.",{"type":43,"tag":52,"props":1382,"children":1383},{},[1384,1386,1392,1393,1398,1399,1405,1406,1411,1412,1418,1419,1425,1426,1431,1432,1437,1439,1444,1445,1450,1452,1457,1459,1465,1467,1472,1474,1479,1481,1486],{"type":49,"value":1385},"Each summary row carries ",{"type":43,"tag":73,"props":1387,"children":1389},{"className":1388},[],[1390],{"type":49,"value":1391},"run_id",{"type":49,"value":103},{"type":43,"tag":73,"props":1394,"children":1396},{"className":1395},[],[1397],{"type":49,"value":1082},{"type":49,"value":103},{"type":43,"tag":73,"props":1400,"children":1402},{"className":1401},[],[1403],{"type":49,"value":1404},"skill_version",{"type":49,"value":103},{"type":43,"tag":73,"props":1407,"children":1409},{"className":1408},[],[1410],{"type":49,"value":1090},{"type":49,"value":103},{"type":43,"tag":73,"props":1413,"children":1415},{"className":1414},[],[1416],{"type":49,"value":1417},"started_at",{"type":49,"value":103},{"type":43,"tag":73,"props":1420,"children":1422},{"className":1421},[],[1423],{"type":49,"value":1424},"completed_at",{"type":49,"value":103},{"type":43,"tag":73,"props":1427,"children":1429},{"className":1428},[],[1430],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":1433,"children":1435},{"className":1434},[],[1436],{"type":49,"value":245},{"type":49,"value":1438}," (the reports the run wrote or edited — its output), ",{"type":43,"tag":73,"props":1440,"children":1442},{"className":1441},[],[1443],{"type":49,"value":253},{"type":49,"value":202},{"type":43,"tag":73,"props":1446,"children":1448},{"className":1447},[],[1449],{"type":49,"value":260},{"type":49,"value":1451}," (the legacy signal-channel tally — ",{"type":43,"tag":73,"props":1453,"children":1455},{"className":1454},[],[1456],{"type":49,"value":283},{"type":49,"value":1458}," \u002F empty on current scouts), ",{"type":43,"tag":73,"props":1460,"children":1462},{"className":1461},[],[1463],{"type":49,"value":1464},"task_url",{"type":49,"value":1466}," (a deep-link into the Tasks UI for the full transcript), and the ",{"type":43,"tag":73,"props":1468,"children":1470},{"className":1469},[],[1471],{"type":49,"value":635},{"type":49,"value":1473}," prose.\nLead with the ",{"type":43,"tag":73,"props":1475,"children":1477},{"className":1476},[],[1478],{"type":49,"value":635},{"type":49,"value":1480}," when narrating to the user — it's the scout's own plain-language close-out — and always offer the ",{"type":43,"tag":73,"props":1482,"children":1484},{"className":1483},[],[1485],{"type":49,"value":1464},{"type":49,"value":1487}," for the full reasoning.",{"type":43,"tag":567,"props":1489,"children":1491},{"id":1490},"workflow-drill-into-a-single-run",[1492],{"type":49,"value":1493},"Workflow: drill into a single run",{"type":43,"tag":52,"props":1495,"children":1496},{},[1497],{"type":49,"value":1498},"When the user wants the full story of one run (or pastes a run id \u002F Tasks URL):",{"type":43,"tag":725,"props":1500,"children":1502},{"className":727,"code":1501,"language":729,"meta":730,"style":730},"scout-runs-retrieve\n{ \"id\": \"\u003Cuuid>\" }\n",[1503],{"type":43,"tag":73,"props":1504,"children":1505},{"__ignoreMap":730},[1506,1514],{"type":43,"tag":736,"props":1507,"children":1508},{"class":738,"line":739},[1509],{"type":43,"tag":736,"props":1510,"children":1511},{"style":743},[1512],{"type":49,"value":1513},"scout-runs-retrieve\n",{"type":43,"tag":736,"props":1515,"children":1517},{"class":738,"line":1516},2,[1518,1524,1529,1535,1540,1545,1549,1555,1559],{"type":43,"tag":736,"props":1519,"children":1521},{"style":1520},"--shiki-light:#39ADB5;--shiki-default:#89DDFF;--shiki-dark:#89DDFF",[1522],{"type":49,"value":1523},"{",{"type":43,"tag":736,"props":1525,"children":1526},{"style":1520},[1527],{"type":49,"value":1528}," \"",{"type":43,"tag":736,"props":1530,"children":1532},{"style":1531},"--shiki-light:#9C3EDA;--shiki-default:#C792EA;--shiki-dark:#C792EA",[1533],{"type":49,"value":1534},"id",{"type":43,"tag":736,"props":1536,"children":1537},{"style":1520},[1538],{"type":49,"value":1539},"\"",{"type":43,"tag":736,"props":1541,"children":1542},{"style":1520},[1543],{"type":49,"value":1544},":",{"type":43,"tag":736,"props":1546,"children":1547},{"style":1520},[1548],{"type":49,"value":1528},{"type":43,"tag":736,"props":1550,"children":1552},{"style":1551},"--shiki-light:#91B859;--shiki-default:#C3E88D;--shiki-dark:#C3E88D",[1553],{"type":49,"value":1554},"\u003Cuuid>",{"type":43,"tag":736,"props":1556,"children":1557},{"style":1520},[1558],{"type":49,"value":1539},{"type":43,"tag":736,"props":1560,"children":1561},{"style":1520},[1562],{"type":49,"value":1563}," }\n",{"type":43,"tag":52,"props":1565,"children":1566},{},[1567,1569,1574,1576,1581,1583,1589,1591,1596,1598,1603,1605,1610],{"type":49,"value":1568},"Note the field name flip: ",{"type":43,"tag":73,"props":1570,"children":1572},{"className":1571},[],[1573],{"type":49,"value":1175},{"type":49,"value":1575}," returns each run's id as ",{"type":43,"tag":73,"props":1577,"children":1579},{"className":1578},[],[1580],{"type":49,"value":1391},{"type":49,"value":1582},", but ",{"type":43,"tag":73,"props":1584,"children":1586},{"className":1585},[],[1587],{"type":49,"value":1588},"runs-retrieve",{"type":49,"value":1590}," takes it as ",{"type":43,"tag":73,"props":1592,"children":1594},{"className":1593},[],[1595],{"type":49,"value":1534},{"type":49,"value":1597},".\nPass the ",{"type":43,"tag":73,"props":1599,"children":1601},{"className":1600},[],[1602],{"type":49,"value":1391},{"type":49,"value":1604}," value through as ",{"type":43,"tag":73,"props":1606,"children":1608},{"className":1607},[],[1609],{"type":49,"value":1534},{"type":49,"value":1304},{"type":43,"tag":52,"props":1612,"children":1613},{},[1614,1616,1621,1622,1627,1628,1633,1635,1640,1641,1646,1648,1653,1654,1659,1660,1665,1667,1672,1674,1679,1681,1686,1688,1693,1694,1699,1701,1705],{"type":49,"value":1615},"Returns the full run: ",{"type":43,"tag":73,"props":1617,"children":1619},{"className":1618},[],[1620],{"type":49,"value":1090},{"type":49,"value":103},{"type":43,"tag":73,"props":1623,"children":1625},{"className":1624},[],[1626],{"type":49,"value":1417},{"type":49,"value":202},{"type":43,"tag":73,"props":1629,"children":1631},{"className":1630},[],[1632],{"type":49,"value":1424},{"type":49,"value":1634}," (compute duration from these), ",{"type":43,"tag":73,"props":1636,"children":1638},{"className":1637},[],[1639],{"type":49,"value":1082},{"type":49,"value":202},{"type":43,"tag":73,"props":1642,"children":1644},{"className":1643},[],[1645],{"type":49,"value":1404},{"type":49,"value":1647}," (what ran, at what body version), the end-of-run ",{"type":43,"tag":73,"props":1649,"children":1651},{"className":1650},[],[1652],{"type":49,"value":635},{"type":49,"value":103},{"type":43,"tag":73,"props":1655,"children":1657},{"className":1656},[],[1658],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":1661,"children":1663},{"className":1662},[],[1664],{"type":49,"value":245},{"type":49,"value":1666},", and ",{"type":43,"tag":73,"props":1668,"children":1670},{"className":1669},[],[1671],{"type":49,"value":1464},{"type":49,"value":1673},".\nThe transcript — the actual tool calls and reasoning — lives in the Tasks UI behind ",{"type":43,"tag":73,"props":1675,"children":1677},{"className":1676},[],[1678],{"type":49,"value":1464},{"type":49,"value":1680},", not in this payload; hand the user that link when they want to see every step.\nA ",{"type":43,"tag":58,"props":1682,"children":1683},{},[1684],{"type":49,"value":1685},"failed",{"type":49,"value":1687}," run returns an empty ",{"type":43,"tag":73,"props":1689,"children":1691},{"className":1690},[],[1692],{"type":49,"value":635},{"type":49,"value":218},{"type":43,"tag":58,"props":1695,"children":1696},{},[1697],{"type":49,"value":1698},"no error field",{"type":49,"value":1700}," — the payload looks the same as the list row, so to learn ",{"type":43,"tag":639,"props":1702,"children":1703},{},[1704],{"type":49,"value":1158},{"type":49,"value":1706}," it failed you need the transcript.",{"type":43,"tag":52,"props":1708,"children":1709},{},[1710,1712,1722,1724,1730,1732,1737,1739,1745],{"type":49,"value":1711},"You don't have to open the UI for that: ",{"type":43,"tag":58,"props":1713,"children":1714},{},[1715,1720],{"type":43,"tag":73,"props":1716,"children":1718},{"className":1717},[],[1719],{"type":49,"value":590},{"type":49,"value":1721}," returns the run's session log (every tool call, message, and reasoning step) as data",{"type":49,"value":1723}," — handy when you're diagnosing a failure or want to trace exactly what a run did without leaving the conversation.\nPass the run's ",{"type":43,"tag":73,"props":1725,"children":1727},{"className":1726},[],[1728],{"type":49,"value":1729},"task_run_id",{"type":49,"value":1731}," as ",{"type":43,"tag":73,"props":1733,"children":1735},{"className":1734},[],[1736],{"type":49,"value":1534},{"type":49,"value":1738}," and its ",{"type":43,"tag":73,"props":1740,"children":1742},{"className":1741},[],[1743],{"type":49,"value":1744},"task_id",{"type":49,"value":1746}," (both are on the run row).",{"type":43,"tag":52,"props":1748,"children":1749},{},[1750,1752,1764,1766,1775],{"type":49,"value":1751},"The raw stream is large (hundreds of KB to a few MB) and will overflow inline, so ",{"type":43,"tag":58,"props":1753,"children":1754},{},[1755,1757,1762],{"type":49,"value":1756},"fetch it with ",{"type":43,"tag":73,"props":1758,"children":1760},{"className":1759},[],[1761],{"type":49,"value":664},{"type":49,"value":1763}," and let it spill to a file",{"type":49,"value":1765},", then run it through ",{"type":43,"tag":693,"props":1767,"children":1768},{"href":695},[1769],{"type":43,"tag":73,"props":1770,"children":1772},{"className":1771},[],[1773],{"type":49,"value":1774},"scripts\u002Frender_run_report.py",{"type":49,"value":1776}," rather than parsing it by hand.",{"type":43,"tag":52,"props":1778,"children":1779},{},[1780,1782,1795,1797,1803,1805,1810,1812,1818,1820,1826,1828,1834,1836,1841,1843,1848,1850,1856,1858,1863,1865,1870,1872,1877],{"type":49,"value":1781},"⚠️ ",{"type":43,"tag":58,"props":1783,"children":1784},{},[1785,1787,1793],{"type":49,"value":1786},"Do not reach for ",{"type":43,"tag":73,"props":1788,"children":1790},{"className":1789},[],[1791],{"type":49,"value":1792},"exclude_types: \"tool_call_update,…\"",{"type":49,"value":1794}," to slim it down.",{"type":49,"value":1796}," It is tempting — the stream is dominated by incremental ",{"type":43,"tag":73,"props":1798,"children":1800},{"className":1799},[],[1801],{"type":49,"value":1802},"tool_call_update",{"type":49,"value":1804}," chunks — but each tool's ",{"type":43,"tag":58,"props":1806,"children":1807},{},[1808],{"type":49,"value":1809},"actual input lives only in those chunks",{"type":49,"value":1811},": the base ",{"type":43,"tag":73,"props":1813,"children":1815},{"className":1814},[],[1816],{"type":49,"value":1817},"tool_call",{"type":49,"value":1819}," event carries an empty ",{"type":43,"tag":73,"props":1821,"children":1823},{"className":1822},[],[1824],{"type":49,"value":1825},"rawInput",{"type":49,"value":1827},", and the streamed updates build the input (and the final ",{"type":43,"tag":73,"props":1829,"children":1831},{"className":1830},[],[1832],{"type":49,"value":1833},"rawOutput",{"type":49,"value":1835},") token by token.\nExcluding them leaves you with tool ",{"type":43,"tag":639,"props":1837,"children":1838},{},[1839],{"type":49,"value":1840},"names",{"type":49,"value":1842}," but no idea what the scout actually queried.\nFetch the ",{"type":43,"tag":58,"props":1844,"children":1845},{},[1846],{"type":49,"value":1847},"full",{"type":49,"value":1849}," log and let the script reassemble each call (it groups by ",{"type":43,"tag":73,"props":1851,"children":1853},{"className":1852},[],[1854],{"type":49,"value":1855},"toolCallId",{"type":49,"value":1857},", keeps the richest ",{"type":43,"tag":73,"props":1859,"children":1861},{"className":1860},[],[1862],{"type":49,"value":1825},{"type":49,"value":1864},", and attaches the completion's ",{"type":43,"tag":73,"props":1866,"children":1868},{"className":1867},[],[1869],{"type":49,"value":1833},{"type":49,"value":1871},"\u002F",{"type":43,"tag":73,"props":1873,"children":1875},{"className":1874},[],[1876],{"type":49,"value":1090},{"type":49,"value":1878},").",{"type":43,"tag":52,"props":1880,"children":1881},{},[1882,1899,1901,1906,1908,1913,1915,1920,1922,1927,1929,1935,1937,1942,1944,1949,1951,1956],{"type":43,"tag":58,"props":1883,"children":1884},{},[1885,1887,1892,1893,1898],{"type":49,"value":1886},"Whether a run wrote anything is a first-class field: ",{"type":43,"tag":73,"props":1888,"children":1890},{"className":1889},[],[1891],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":1894,"children":1896},{"className":1895},[],[1897],{"type":49,"value":245},{"type":49,"value":1304},{"type":49,"value":1900}," A non-empty ",{"type":43,"tag":73,"props":1902,"children":1904},{"className":1903},[],[1905],{"type":49,"value":234},{"type":49,"value":1907}," lists the reports the run authored via ",{"type":43,"tag":73,"props":1909,"children":1911},{"className":1910},[],[1912],{"type":49,"value":200},{"type":49,"value":1914},", in order; ",{"type":43,"tag":73,"props":1916,"children":1918},{"className":1917},[],[1919],{"type":49,"value":245},{"type":49,"value":1921}," lists the reports it mutated via ",{"type":43,"tag":73,"props":1923,"children":1925},{"className":1924},[],[1926],{"type":49,"value":208},{"type":49,"value":1928}," (which can target any inbox report, not just ones a scout authored).\nA productive run typically has one id there and a summary like ",{"type":43,"tag":73,"props":1930,"children":1932},{"className":1931},[],[1933],{"type":49,"value":1934},"Report authored: \u003Cid>",{"type":49,"value":1936},"; resolve any id via ",{"type":43,"tag":73,"props":1938,"children":1940},{"className":1939},[],[1941],{"type":49,"value":522},{"type":49,"value":1943}," to read the report itself.\nDon't parse the prose ",{"type":43,"tag":73,"props":1945,"children":1947},{"className":1946},[],[1948],{"type":49,"value":635},{"type":49,"value":1950}," for output — a phrase like \"already reported P1 … did not re-file\" describes a ",{"type":43,"tag":639,"props":1952,"children":1953},{},[1954],{"type":49,"value":1955},"prior",{"type":49,"value":1957}," run, so substring-matching the summary is unreliable; the id columns are the authoritative tally.",{"type":43,"tag":52,"props":1959,"children":1960},{},[1961,1978,1980,1985,1987,1992,1994,2000,2002,2008,2009,2015,2017,2023,2025,2030,2032,2037,2039,2044,2046,2054],{"type":43,"tag":58,"props":1962,"children":1963},{},[1964,1966,1971,1972,1977],{"type":49,"value":1965},"Legacy runs: ",{"type":43,"tag":73,"props":1967,"children":1969},{"className":1968},[],[1970],{"type":49,"value":253},{"type":49,"value":202},{"type":43,"tag":73,"props":1973,"children":1975},{"className":1974},[],[1976],{"type":49,"value":260},{"type":49,"value":1304},{"type":49,"value":1979}," Runs from the deprecated signal-emitting channel (a scout without the ",{"type":43,"tag":73,"props":1981,"children":1983},{"className":1982},[],[1984],{"type":49,"value":216},{"type":49,"value":1986}," opt-in — an old custom scout, or a canonical scout not yet ported) tally their output as ",{"type":43,"tag":73,"props":1988,"children":1990},{"className":1989},[],[1991],{"type":49,"value":253},{"type":49,"value":1993}," weak findings instead; each ",{"type":43,"tag":73,"props":1995,"children":1997},{"className":1996},[],[1998],{"type":49,"value":1999},"finding_id",{"type":49,"value":2001}," maps to a ",{"type":43,"tag":73,"props":2003,"children":2005},{"className":2004},[],[2006],{"type":49,"value":2007},"Signal",{"type":49,"value":1177},{"type":43,"tag":73,"props":2010,"children":2012},{"className":2011},[],[2013],{"type":49,"value":2014},"source_id = run:\u003Crun_id>:finding:\u003Cfinding_id>",{"type":49,"value":2016},".\nFor those runs only, ",{"type":43,"tag":73,"props":2018,"children":2020},{"className":2019},[],[2021],{"type":49,"value":2022},"scout-runs-emission-reports",{"type":49,"value":2024}," (pass the ",{"type":43,"tag":73,"props":2026,"children":2028},{"className":2027},[],[2029],{"type":49,"value":1391},{"type":49,"value":2031},") maps each emitted finding to the inbox report its signal grouped into (or ",{"type":43,"tag":73,"props":2033,"children":2035},{"className":2034},[],[2036],{"type":49,"value":879},{"type":49,"value":2038}," if it never surfaced).\nOn report-channel scouts these fields are always ",{"type":43,"tag":73,"props":2040,"children":2042},{"className":2041},[],[2043],{"type":49,"value":283},{"type":49,"value":2045}," \u002F empty — don't diagnose off them.\nSee ",{"type":43,"tag":693,"props":2047,"children":2048},{"href":1023},[2049],{"type":43,"tag":73,"props":2050,"children":2052},{"className":2051},[],[2053],{"type":49,"value":1023},{"type":49,"value":2055}," for the full field reference.",{"type":43,"tag":52,"props":2057,"children":2058},{},[2059,2061,2066,2068,2073],{"type":49,"value":2060},"A run with ",{"type":43,"tag":73,"props":2062,"children":2064},{"className":2063},[],[2065],{"type":49,"value":1090},{"type":49,"value":2067}," complete and an empty-handed summary (\"surface at baseline, nothing to report\") is a ",{"type":43,"tag":58,"props":2069,"children":2070},{},[2071],{"type":49,"value":2072},"healthy",{"type":49,"value":2074}," outcome, not a failure — most runs should close out empty.\nTreat a stream of empty close-outs as the fleet doing its job, not as the fleet being broken.",{"type":43,"tag":567,"props":2076,"children":2078},{"id":2077},"workflow-inspect-what-the-fleet-has-learned",[2079],{"type":49,"value":2080},"Workflow: inspect what the fleet has learned",{"type":43,"tag":52,"props":2082,"children":2083},{},[2084,2086,2091],{"type":49,"value":2085},"The ",{"type":43,"tag":58,"props":2087,"children":2088},{},[2089],{"type":49,"value":2090},"scratchpad",{"type":49,"value":2092}," is the fleet's durable, per-team memory — prose entries scouts write so future runs get smarter and quieter.\nReading it tells you what the fleet believes about this project.",{"type":43,"tag":725,"props":2094,"children":2096},{"className":727,"code":2095,"language":729,"meta":730,"style":730},"scout-scratchpad-search\n{ \"text\": \"error_tracking\" }\n",[2097],{"type":43,"tag":73,"props":2098,"children":2099},{"__ignoreMap":730},[2100,2108],{"type":43,"tag":736,"props":2101,"children":2102},{"class":738,"line":739},[2103],{"type":43,"tag":736,"props":2104,"children":2105},{"style":743},[2106],{"type":49,"value":2107},"scout-scratchpad-search\n",{"type":43,"tag":736,"props":2109,"children":2110},{"class":738,"line":1516},[2111,2115,2119,2123,2127,2131,2135,2140,2144],{"type":43,"tag":736,"props":2112,"children":2113},{"style":1520},[2114],{"type":49,"value":1523},{"type":43,"tag":736,"props":2116,"children":2117},{"style":1520},[2118],{"type":49,"value":1528},{"type":43,"tag":736,"props":2120,"children":2121},{"style":1531},[2122],{"type":49,"value":49},{"type":43,"tag":736,"props":2124,"children":2125},{"style":1520},[2126],{"type":49,"value":1539},{"type":43,"tag":736,"props":2128,"children":2129},{"style":1520},[2130],{"type":49,"value":1544},{"type":43,"tag":736,"props":2132,"children":2133},{"style":1520},[2134],{"type":49,"value":1528},{"type":43,"tag":736,"props":2136,"children":2137},{"style":1551},[2138],{"type":49,"value":2139},"error_tracking",{"type":43,"tag":736,"props":2141,"children":2142},{"style":1520},[2143],{"type":49,"value":1539},{"type":43,"tag":736,"props":2145,"children":2146},{"style":1520},[2147],{"type":49,"value":1563},{"type":43,"tag":52,"props":2149,"children":2150},{},[2151,2153,2158,2160,2166,2167,2173,2175,2180,2182,2187,2189,2194],{"type":49,"value":2152},"Returns entries newest-first (capped at 100); ",{"type":43,"tag":73,"props":2154,"children":2156},{"className":2155},[],[2157],{"type":49,"value":49},{"type":49,"value":2159}," matches ",{"type":43,"tag":73,"props":2161,"children":2163},{"className":2162},[],[2164],{"type":49,"value":2165},"content",{"type":49,"value":218},{"type":43,"tag":73,"props":2168,"children":2170},{"className":2169},[],[2171],{"type":49,"value":2172},"key",{"type":49,"value":2174}," case-insensitively.\nOmit ",{"type":43,"tag":73,"props":2176,"children":2178},{"className":2177},[],[2179],{"type":49,"value":49},{"type":49,"value":2181}," to browse everything.\nEach entry's ",{"type":43,"tag":73,"props":2183,"children":2185},{"className":2184},[],[2186],{"type":49,"value":2172},{"type":49,"value":2188}," carries a category prefix that tells you ",{"type":43,"tag":639,"props":2190,"children":2191},{},[2192],{"type":49,"value":2193},"what kind",{"type":49,"value":2195}," of learning it is:",{"type":43,"tag":322,"props":2197,"children":2198},{},[2199,2215],{"type":43,"tag":326,"props":2200,"children":2201},{},[2202],{"type":43,"tag":330,"props":2203,"children":2204},{},[2205,2210],{"type":43,"tag":334,"props":2206,"children":2207},{},[2208],{"type":49,"value":2209},"Prefix",{"type":43,"tag":334,"props":2211,"children":2212},{},[2213],{"type":49,"value":2214},"Meaning",{"type":43,"tag":350,"props":2216,"children":2217},{},[2218,2235,2252,2269,2286,2303,2320,2337,2354,2371,2388,2413],{"type":43,"tag":330,"props":2219,"children":2220},{},[2221,2230],{"type":43,"tag":357,"props":2222,"children":2223},{},[2224],{"type":43,"tag":73,"props":2225,"children":2227},{"className":2226},[],[2228],{"type":49,"value":2229},"pattern:",{"type":43,"tag":357,"props":2231,"children":2232},{},[2233],{"type":49,"value":2234},"A baseline — how this team's data normally shapes",{"type":43,"tag":330,"props":2236,"children":2237},{},[2238,2247],{"type":43,"tag":357,"props":2239,"children":2240},{},[2241],{"type":43,"tag":73,"props":2242,"children":2244},{"className":2243},[],[2245],{"type":49,"value":2246},"watch:",{"type":43,"tag":357,"props":2248,"children":2249},{},[2250],{"type":49,"value":2251},"A live issue being tracked but still below the report bar",{"type":43,"tag":330,"props":2253,"children":2254},{},[2255,2264],{"type":43,"tag":357,"props":2256,"children":2257},{},[2258],{"type":43,"tag":73,"props":2259,"children":2261},{"className":2260},[],[2262],{"type":49,"value":2263},"noise:",{"type":43,"tag":357,"props":2265,"children":2266},{},[2267],{"type":49,"value":2268},"A pattern the fleet has decided to ignore (dev-only, single-user…)",{"type":43,"tag":330,"props":2270,"children":2271},{},[2272,2281],{"type":43,"tag":357,"props":2273,"children":2274},{},[2275],{"type":43,"tag":73,"props":2276,"children":2278},{"className":2277},[],[2279],{"type":49,"value":2280},"addressed:",{"type":43,"tag":357,"props":2282,"children":2283},{},[2284],{"type":49,"value":2285},"Something the team fixed or moved on from",{"type":43,"tag":330,"props":2287,"children":2288},{},[2289,2298],{"type":43,"tag":357,"props":2290,"children":2291},{},[2292],{"type":43,"tag":73,"props":2293,"children":2295},{"className":2294},[],[2296],{"type":49,"value":2297},"dedupe:",{"type":43,"tag":357,"props":2299,"children":2300},{},[2301],{"type":49,"value":2302},"A gate on re-filing a specific issue \u002F fingerprint",{"type":43,"tag":330,"props":2304,"children":2305},{},[2306,2315],{"type":43,"tag":357,"props":2307,"children":2308},{},[2309],{"type":43,"tag":73,"props":2310,"children":2312},{"className":2311},[],[2313],{"type":49,"value":2314},"allowlist:",{"type":43,"tag":357,"props":2316,"children":2317},{},[2318],{"type":49,"value":2319},"Vetted entities never to re-surface",{"type":43,"tag":330,"props":2321,"children":2322},{},[2323,2332],{"type":43,"tag":357,"props":2324,"children":2325},{},[2326],{"type":43,"tag":73,"props":2327,"children":2329},{"className":2328},[],[2330],{"type":49,"value":2331},"not-in-use:",{"type":43,"tag":357,"props":2333,"children":2334},{},[2335],{"type":49,"value":2336},"A product\u002Fsurface this team doesn't use (close-out memo)",{"type":43,"tag":330,"props":2338,"children":2339},{},[2340,2349],{"type":43,"tag":357,"props":2341,"children":2342},{},[2343],{"type":43,"tag":73,"props":2344,"children":2346},{"className":2345},[],[2347],{"type":49,"value":2348},"mcp-gap:",{"type":43,"tag":357,"props":2350,"children":2351},{},[2352],{"type":49,"value":2353},"A tooling gap a scout noticed worth raising later",{"type":43,"tag":330,"props":2355,"children":2356},{},[2357,2366],{"type":43,"tag":357,"props":2358,"children":2359},{},[2360],{"type":43,"tag":73,"props":2361,"children":2363},{"className":2362},[],[2364],{"type":49,"value":2365},"improve:",{"type":43,"tag":357,"props":2367,"children":2368},{},[2369],{"type":49,"value":2370},"A custom scout's suggested change to its own skill body, awaiting owner review",{"type":43,"tag":330,"props":2372,"children":2373},{},[2374,2383],{"type":43,"tag":357,"props":2375,"children":2376},{},[2377],{"type":43,"tag":73,"props":2378,"children":2380},{"className":2379},[],[2381],{"type":49,"value":2382},"reported:",{"type":43,"tag":357,"props":2384,"children":2385},{},[2386],{"type":49,"value":2387},"A canonical scout's record of a skill gap already fed back upstream to PostHog",{"type":43,"tag":330,"props":2389,"children":2390},{},[2391,2400],{"type":43,"tag":357,"props":2392,"children":2393},{},[2394],{"type":43,"tag":73,"props":2395,"children":2397},{"className":2396},[],[2398],{"type":49,"value":2399},"report:",{"type":43,"tag":357,"props":2401,"children":2402},{},[2403,2405,2411],{"type":49,"value":2404},"A report a scout authored — stores the ",{"type":43,"tag":73,"props":2406,"children":2408},{"className":2407},[],[2409],{"type":49,"value":2410},"report_id",{"type":49,"value":2412}," so later runs edit\u002Fdedup against it",{"type":43,"tag":330,"props":2414,"children":2415},{},[2416,2425],{"type":43,"tag":357,"props":2417,"children":2418},{},[2419],{"type":43,"tag":73,"props":2420,"children":2422},{"className":2421},[],[2423],{"type":49,"value":2424},"reviewer:",{"type":43,"tag":357,"props":2426,"children":2427},{},[2428,2430,2436],{"type":49,"value":2429},"A resolved owner (GitHub login) for an area, cached for ",{"type":43,"tag":73,"props":2431,"children":2433},{"className":2432},[],[2434],{"type":49,"value":2435},"suggested_reviewers",{"type":49,"value":2437}," routing",{"type":43,"tag":52,"props":2439,"children":2440},{},[2441,2443,2449,2451,2456,2458,2464,2466,2472,2474,2480],{"type":49,"value":2442},"This is the common vocabulary, not a closed set — scouts coin their own prefixes and ",{"type":43,"tag":73,"props":2444,"children":2446},{"className":2445},[],[2447],{"type":49,"value":2448},"\u003Cdomain>",{"type":49,"value":2450}," labels as needed (the live fleet uses ",{"type":43,"tag":73,"props":2452,"children":2454},{"className":2453},[],[2455],{"type":49,"value":2246},{"type":49,"value":2457}," heavily, for example), so treat an unfamiliar prefix as just another category.\nEntries cross-reference each other with ",{"type":43,"tag":73,"props":2459,"children":2461},{"className":2460},[],[2462],{"type":49,"value":2463},"[[key]]",{"type":49,"value":2465}," wikilinks.\nKeys follow ",{"type":43,"tag":73,"props":2467,"children":2469},{"className":2468},[],[2470],{"type":49,"value":2471},"\u003Cprefix>:\u003Cdomain>:\u003Centity>",{"type":49,"value":2473}," (e.g. ",{"type":43,"tag":73,"props":2475,"children":2477},{"className":2476},[],[2478],{"type":49,"value":2479},"dedupe:error_tracking:019e8375-…",{"type":49,"value":1878},{"type":43,"tag":52,"props":2482,"children":2483},{},[2484,2486,2491,2492,2497,2498,2503,2504,2509,2511,2516,2518,2524],{"type":49,"value":2485},"When a user asks \"why isn't my scout flagging X anymore?\", search the scratchpad for ",{"type":43,"tag":73,"props":2487,"children":2489},{"className":2488},[],[2490],{"type":49,"value":2263},{"type":49,"value":103},{"type":43,"tag":73,"props":2493,"children":2495},{"className":2494},[],[2496],{"type":49,"value":2280},{"type":49,"value":103},{"type":43,"tag":73,"props":2499,"children":2501},{"className":2500},[],[2502],{"type":49,"value":2297},{"type":49,"value":1666},{"type":43,"tag":73,"props":2505,"children":2507},{"className":2506},[],[2508],{"type":49,"value":2314},{"type":49,"value":2510}," entries — the fleet may have deliberately learned to suppress it.\nThe canonical prefix vocabulary and the four-state dedupe classifier the fleet reasons in terms of are documented in the ",{"type":43,"tag":73,"props":2512,"children":2514},{"className":2513},[],[2515],{"type":49,"value":145},{"type":49,"value":2517}," skill (",{"type":43,"tag":73,"props":2519,"children":2521},{"className":2520},[],[2522],{"type":49,"value":2523},"references\u002Fdedupe-and-memory.md",{"type":49,"value":1878},{"type":43,"tag":52,"props":2526,"children":2527},{},[2528,2533,2535,2541,2543,2549,2551,2556,2558,2563,2565,2571,2573,2578,2580,2585,2587,2592,2594,2600,2602,2608,2610,2616,2618,2623],{"type":43,"tag":58,"props":2529,"children":2530},{},[2531],{"type":49,"value":2532},"Custom scouts self-report skill improvements.",{"type":49,"value":2534}," A custom (team-authored) scout is invited by the harness to write an ",{"type":43,"tag":73,"props":2536,"children":2538},{"className":2537},[],[2539],{"type":49,"value":2540},"improve:\u003Cskill-name>:\u003Ctopic>",{"type":49,"value":2542}," entry when a run produces concrete evidence its own skill body steered it wrong — the suggested change, the evidence, and a dated observed line, re-confirmed in place on later runs.\nA custom scout on the report channel escalates recurring or material suggestions further: it files an inbox report about itself (titled ",{"type":43,"tag":73,"props":2544,"children":2546},{"className":2545},[],[2547],{"type":49,"value":2548},"Scout self-improvement: \u003Cskill-name> – \u003Ctopic>",{"type":49,"value":2550},") and stashes the ",{"type":43,"tag":73,"props":2552,"children":2554},{"className":2553},[],[2555],{"type":49,"value":2410},{"type":49,"value":2557}," in the ",{"type":43,"tag":73,"props":2559,"children":2561},{"className":2560},[],[2562],{"type":49,"value":2365},{"type":49,"value":2564}," entry — so the strongest suggestions reach the owner through the inbox like any other report, not only via the scratchpad.\nWhen assessing a custom scout, search ",{"type":43,"tag":73,"props":2566,"children":2568},{"className":2567},[],[2569],{"type":49,"value":2570},"{\"text\": \"improve:\"}",{"type":49,"value":2572}," and surface these to the user: an entry re-confirmed across several runs is the highest-signal edit the owner can make.\nReviewing and applying them is a write operation — hand off to the ",{"type":43,"tag":73,"props":2574,"children":2576},{"className":2575},[],[2577],{"type":49,"value":145},{"type":49,"value":2579}," skill.\nCanonical scouts never write ",{"type":43,"tag":73,"props":2581,"children":2583},{"className":2582},[],[2584],{"type":49,"value":2365},{"type":49,"value":2586}," entries (their skill bodies are synced from PostHog's fleet), so an ",{"type":43,"tag":73,"props":2588,"children":2590},{"className":2589},[],[2591],{"type":49,"value":2365},{"type":49,"value":2593}," entry under a canonical scout's domain is itself worth flagging.\nInstead, a canonical scout routes skill-content gaps upstream to the PostHog team via the ",{"type":43,"tag":73,"props":2595,"children":2597},{"className":2596},[],[2598],{"type":49,"value":2599},"agent-feedback",{"type":49,"value":2601}," MCP tool (",{"type":43,"tag":73,"props":2603,"children":2605},{"className":2604},[],[2606],{"type":49,"value":2607},"feedback_type: \"scout\"",{"type":49,"value":2609},"), generalized so no project data travels, and keeps a ",{"type":43,"tag":73,"props":2611,"children":2613},{"className":2612},[],[2614],{"type":49,"value":2615},"reported:\u003Cskill-name>:\u003Ctopic>",{"type":49,"value":2617}," entry as its local record of what it already submitted — so a ",{"type":43,"tag":73,"props":2619,"children":2621},{"className":2620},[],[2622],{"type":49,"value":2382},{"type":49,"value":2624}," entry tells you a gap has been raised with PostHog, not with this team.",{"type":43,"tag":567,"props":2626,"children":2628},{"id":2627},"workflow-see-what-scouts-have-written",[2629],{"type":49,"value":2630},"Workflow: see what scouts have written",{"type":43,"tag":52,"props":2632,"children":2633},{},[2634],{"type":49,"value":2635},"Scout output reaches the user as inbox reports.\nFilter the inbox to the scout source:",{"type":43,"tag":725,"props":2637,"children":2639},{"className":727,"code":2638,"language":729,"meta":730,"style":730},"inbox-reports-list\n{ \"source_product\": \"signals_scout\", \"limit\": 20 }\n",[2640],{"type":43,"tag":73,"props":2641,"children":2642},{"__ignoreMap":730},[2643,2651],{"type":43,"tag":736,"props":2644,"children":2645},{"class":738,"line":739},[2646],{"type":43,"tag":736,"props":2647,"children":2648},{"style":743},[2649],{"type":49,"value":2650},"inbox-reports-list\n",{"type":43,"tag":736,"props":2652,"children":2653},{"class":738,"line":1516},[2654,2658,2662,2667,2671,2675,2679,2684,2688,2693,2697,2701,2705,2709,2715],{"type":43,"tag":736,"props":2655,"children":2656},{"style":1520},[2657],{"type":49,"value":1523},{"type":43,"tag":736,"props":2659,"children":2660},{"style":1520},[2661],{"type":49,"value":1528},{"type":43,"tag":736,"props":2663,"children":2664},{"style":1531},[2665],{"type":49,"value":2666},"source_product",{"type":43,"tag":736,"props":2668,"children":2669},{"style":1520},[2670],{"type":49,"value":1539},{"type":43,"tag":736,"props":2672,"children":2673},{"style":1520},[2674],{"type":49,"value":1544},{"type":43,"tag":736,"props":2676,"children":2677},{"style":1520},[2678],{"type":49,"value":1528},{"type":43,"tag":736,"props":2680,"children":2681},{"style":1551},[2682],{"type":49,"value":2683},"signals_scout",{"type":43,"tag":736,"props":2685,"children":2686},{"style":1520},[2687],{"type":49,"value":1539},{"type":43,"tag":736,"props":2689,"children":2690},{"style":1520},[2691],{"type":49,"value":2692},",",{"type":43,"tag":736,"props":2694,"children":2695},{"style":1520},[2696],{"type":49,"value":1528},{"type":43,"tag":736,"props":2698,"children":2699},{"style":1531},[2700],{"type":49,"value":618},{"type":43,"tag":736,"props":2702,"children":2703},{"style":1520},[2704],{"type":49,"value":1539},{"type":43,"tag":736,"props":2706,"children":2707},{"style":1520},[2708],{"type":49,"value":1544},{"type":43,"tag":736,"props":2710,"children":2712},{"style":2711},"--shiki-light:#F76D47;--shiki-default:#F78C6C;--shiki-dark:#F78C6C",[2713],{"type":49,"value":2714}," 20",{"type":43,"tag":736,"props":2716,"children":2717},{"style":1520},[2718],{"type":49,"value":1563},{"type":43,"tag":52,"props":2720,"children":2721},{},[2722,2724,2729,2731,2737,2739,2743,2745,2750,2752,2757],{"type":49,"value":2723},"This is the direct way to find the reports scouts ",{"type":43,"tag":58,"props":2725,"children":2726},{},[2727],{"type":49,"value":2728},"authored",{"type":49,"value":2730},".\nEvery report a scout authors carries backing signals tagged ",{"type":43,"tag":73,"props":2732,"children":2734},{"className":2733},[],[2735],{"type":49,"value":2736},"source_product=\"signals_scout\"",{"type":49,"value":2738},", and the inbox filter keeps any report whose contributing signals include that tag — so the result is the set of reports the fleet has authored.\nIt does ",{"type":43,"tag":58,"props":2740,"children":2741},{},[2742],{"type":49,"value":937},{"type":49,"value":2744}," capture edit-only work: a scout that edits an existing non-scout report (appending a note to a pipeline report, say) adds no ",{"type":43,"tag":73,"props":2746,"children":2748},{"className":2747},[],[2749],{"type":49,"value":2683},{"type":49,"value":2751}," signal, so that report won't match the filter — trace edits through the run rows' ",{"type":43,"tag":73,"props":2753,"children":2755},{"className":2754},[],[2756],{"type":49,"value":245},{"type":49,"value":2758}," instead.",{"type":43,"tag":52,"props":2760,"children":2761},{},[2762,2764,2768,2770,2775,2777,2783,2785,2791],{"type":49,"value":2763},"An empty result means the fleet hasn't authored any reports (yet), ",{"type":43,"tag":58,"props":2765,"children":2766},{},[2767],{"type":49,"value":937},{"type":49,"value":2769}," that the filter is broken.\nScouts hold a high bar — most runs close out without writing — so on a quiet or newly enrolled project zero scout reports is the normal, expected state.\nNote the inbox only shows ",{"type":43,"tag":58,"props":2771,"children":2772},{},[2773],{"type":49,"value":2774},"surfaced",{"type":49,"value":2776}," reports: a report the safety judge suppressed (or one filed as ",{"type":43,"tag":73,"props":2778,"children":2780},{"className":2779},[],[2781],{"type":49,"value":2782},"not_actionable",{"type":49,"value":2784},") persists with status ",{"type":43,"tag":73,"props":2786,"children":2788},{"className":2787},[],[2789],{"type":49,"value":2790},"SUPPRESSED",{"type":49,"value":2792}," but doesn't appear in the default inbox view.",{"type":43,"tag":52,"props":2794,"children":2795},{},[2796,2798,2804,2806,2811,2812,2817,2819,2824,2826,2831,2833,2838,2840,2845,2847,2852,2854,2859,2861,2866,2867,2873],{"type":49,"value":2797},"For the per-run view, work from the runs instead: ",{"type":43,"tag":73,"props":2799,"children":2801},{"className":2800},[],[2802],{"type":49,"value":2803},"scout-runs-list?emitted=true",{"type":49,"value":2805}," lists every run that authored a report, and each run's ",{"type":43,"tag":73,"props":2807,"children":2809},{"className":2808},[],[2810],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":2813,"children":2815},{"className":2814},[],[2816],{"type":49,"value":245},{"type":49,"value":2818}," name exactly which reports it wrote or updated — resolve them via ",{"type":43,"tag":73,"props":2820,"children":2822},{"className":2821},[],[2823],{"type":49,"value":522},{"type":49,"value":2825},".\nThe flip side matters when explaining a gap: a run can narrate \"authored a report\" in its ",{"type":43,"tag":73,"props":2827,"children":2829},{"className":2828},[],[2830],{"type":49,"value":635},{"type":49,"value":2832}," yet have the write ",{"type":43,"tag":58,"props":2834,"children":2835},{},[2836],{"type":49,"value":2837},"silently dropped",{"type":49,"value":2839}," by a preflight gate (dry-run at the time, the org hasn't approved AI processing, or the ",{"type":43,"tag":73,"props":2841,"children":2843},{"className":2842},[],[2844],{"type":49,"value":2683},{"type":49,"value":2846}," source is disabled) — those leave ",{"type":43,"tag":73,"props":2848,"children":2850},{"className":2849},[],[2851],{"type":49,"value":234},{"type":49,"value":2853}," empty, so a claimed-but-absent report is itself a diagnostic.\nTo browse the inbox more broadly, use the ",{"type":43,"tag":73,"props":2855,"children":2857},{"className":2856},[],[2858],{"type":49,"value":153},{"type":49,"value":2860}," skill (statuses, suggested reviewers, drilling into a report's underlying signals).\nThe report contract behind each report — the report bar, evidence, actionability, reviewer routing — is documented in the ",{"type":43,"tag":73,"props":2862,"children":2864},{"className":2863},[],[2865],{"type":49,"value":145},{"type":49,"value":2517},{"type":43,"tag":73,"props":2868,"children":2870},{"className":2869},[],[2871],{"type":49,"value":2872},"references\u002Freport-contract.md",{"type":49,"value":1878},{"type":43,"tag":567,"props":2875,"children":2877},{"id":2876},"workflow-assess-health-and-performance",[2878],{"type":49,"value":2879},"Workflow: assess health and performance",{"type":43,"tag":52,"props":2881,"children":2882},{},[2883,2885,2890,2892,2897,2899,2908],{"type":49,"value":2884},"\"Is my scout actually working \u002F earning its cost?\"\nThere's no single metric — judge a scout over a window of runs.\nPull the runs (",{"type":43,"tag":73,"props":2886,"children":2888},{"className":2887},[],[2889],{"type":49,"value":1175},{"type":49,"value":2891}," with a ",{"type":43,"tag":73,"props":2893,"children":2895},{"className":2894},[],[2896],{"type":49,"value":1280},{"type":49,"value":2898},"), then reason across the dimensions below.\nThe full playbook, including how to read each signal and the common failure modes, is in ",{"type":43,"tag":693,"props":2900,"children":2902},{"href":2901},"references\u002Fassessing-performance.md",[2903],{"type":43,"tag":73,"props":2904,"children":2906},{"className":2905},[],[2907],{"type":49,"value":2901},{"type":49,"value":1304},{"type":43,"tag":601,"props":2910,"children":2911},{},[2912,2964,2981,3019,3042],{"type":43,"tag":605,"props":2913,"children":2914},{},[2915,2920,2922,2927,2929,2934,2936,2941,2943,2948,2950,2955,2957,2962],{"type":43,"tag":58,"props":2916,"children":2917},{},[2918],{"type":49,"value":2919},"Cadence adherence",{"type":49,"value":2921}," — are runs landing roughly every ",{"type":43,"tag":73,"props":2923,"children":2925},{"className":2924},[],[2926],{"type":49,"value":829},{"type":49,"value":2928},"?\nLarge gaps mean the coordinator is skipping it (disabled, drained from the flag, or capped out on busy ticks) — ",{"type":43,"tag":639,"props":2930,"children":2931},{},[2932],{"type":49,"value":2933},"or",{"type":49,"value":2935}," it's dispatching but the runs aren't materializing.\nTell the two apart with ",{"type":43,"tag":73,"props":2937,"children":2939},{"className":2938},[],[2940],{"type":49,"value":394},{"type":49,"value":2942},": if the config's ",{"type":43,"tag":73,"props":2944,"children":2946},{"className":2945},[],[2947],{"type":49,"value":394},{"type":49,"value":2949}," is also stale, the coordinator stopped planning it; if ",{"type":43,"tag":73,"props":2951,"children":2953},{"className":2952},[],[2954],{"type":49,"value":394},{"type":49,"value":2956}," is fresh but the newest run row is hours old, it's the dispatch-vs-execution divergence above (workers backed up \u002F down, or runs stranded), which ",{"type":43,"tag":73,"props":2958,"children":2960},{"className":2959},[],[2961],{"type":49,"value":1175},{"type":49,"value":2963}," alone hides.",{"type":43,"tag":605,"props":2965,"children":2966},{},[2967,2972,2974,2979],{"type":43,"tag":58,"props":2968,"children":2969},{},[2970],{"type":49,"value":2971},"Success rate",{"type":49,"value":2973}," — how many runs reach a clean ",{"type":43,"tag":73,"props":2975,"children":2977},{"className":2976},[],[2978],{"type":49,"value":1090},{"type":49,"value":2980}," vs. error out?\nA run of errors is a broken scout, not a quiet one.",{"type":43,"tag":605,"props":2982,"children":2983},{},[2984,2989,2991,2996,2997,3002,3004,3010,3011,3017],{"type":43,"tag":58,"props":2985,"children":2986},{},[2987],{"type":49,"value":2988},"Report rate",{"type":49,"value":2990}," — what fraction of runs wrote or edited a report vs. closed out empty.\nRead it straight off ",{"type":43,"tag":73,"props":2992,"children":2994},{"className":2993},[],[2995],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":2998,"children":3000},{"className":2999},[],[3001],{"type":49,"value":245},{"type":49,"value":3003}," per run (or split the window with ",{"type":43,"tag":73,"props":3005,"children":3007},{"className":3006},[],[3008],{"type":49,"value":3009},"runs-list?emitted=true",{"type":49,"value":202},{"type":43,"tag":73,"props":3012,"children":3014},{"className":3013},[],[3015],{"type":49,"value":3016},"?emitted=false",{"type":49,"value":3018},", remembering edit-only runs read as not-emitted).\nNear-zero over a long window on a live surface can mean the discriminator is too strict (or the surface really is quiet); near-100% usually means it's too noisy.\nMost healthy scouts write rarely.",{"type":43,"tag":605,"props":3020,"children":3021},{},[3022,3027,3029,3034,3035,3040],{"type":43,"tag":58,"props":3023,"children":3024},{},[3025],{"type":49,"value":3026},"Signal-to-noise",{"type":49,"value":3028}," — of what it wrote, how much surfaced as actionable inbox reports vs. got suppressed or dismissed?\nResolve each run's ",{"type":43,"tag":73,"props":3030,"children":3032},{"className":3031},[],[3033],{"type":49,"value":234},{"type":49,"value":292},{"type":43,"tag":73,"props":3036,"children":3038},{"className":3037},[],[3039],{"type":49,"value":522},{"type":49,"value":3041}," and read the report statuses — across a window, the share of authored reports that are live and non-suppressed is the scout's hit rate.",{"type":43,"tag":605,"props":3043,"children":3044},{},[3045,3050,3052,3057,3058,3063,3064,3069],{"type":43,"tag":58,"props":3046,"children":3047},{},[3048],{"type":49,"value":3049},"Memory growth",{"type":49,"value":3051}," — a healthy scout accumulates ",{"type":43,"tag":73,"props":3053,"children":3055},{"className":3054},[],[3056],{"type":49,"value":2229},{"type":49,"value":202},{"type":43,"tag":73,"props":3059,"children":3061},{"className":3060},[],[3062],{"type":49,"value":2263},{"type":49,"value":202},{"type":43,"tag":73,"props":3065,"children":3067},{"className":3066},[],[3068],{"type":49,"value":2297},{"type":49,"value":3070}," entries over time.\nA scout with an empty scratchpad after many runs isn't learning.",{"type":43,"tag":567,"props":3072,"children":3074},{"id":3073},"helper-scripts",[3075],{"type":49,"value":3076},"Helper scripts",{"type":43,"tag":52,"props":3078,"children":3079},{},[3080,3082,3087,3089,3097,3099,3104],{"type":49,"value":3081},"The skill bundles three ",{"type":43,"tag":58,"props":3083,"children":3084},{},[3085],{"type":49,"value":3086},"pure formatters",{"type":49,"value":3088}," under ",{"type":43,"tag":693,"props":3090,"children":3091},{"href":702},[3092],{"type":43,"tag":73,"props":3093,"children":3095},{"className":3094},[],[3096],{"type":49,"value":702},{"type":49,"value":3098}," for the most common asks.\nThey do ",{"type":43,"tag":58,"props":3100,"children":3101},{},[3102],{"type":49,"value":3103},"no network I\u002FO",{"type":49,"value":3105}," — they are the back half of an \"agent fetches, script formats\" split.\nThe pattern is always the same:",{"type":43,"tag":1052,"props":3107,"children":3108},{},[3109,3137],{"type":43,"tag":605,"props":3110,"children":3111},{},[3112,3114,3122,3124,3129,3130,3135],{"type":49,"value":3113},"Fetch each payload with the MCP using ",{"type":43,"tag":58,"props":3115,"children":3116},{},[3117],{"type":43,"tag":73,"props":3118,"children":3120},{"className":3119},[],[3121],{"type":49,"value":664},{"type":49,"value":3123}," (raw JSON, not the pretty text format) and save it to a file.\nFor the big ones (",{"type":43,"tag":73,"props":3125,"children":3127},{"className":3126},[],[3128],{"type":49,"value":1175},{"type":49,"value":103},{"type":43,"tag":73,"props":3131,"children":3133},{"className":3132},[],[3134],{"type":49,"value":590},{"type":49,"value":3136},") this is mandatory anyway — they overflow inline and spill to a file you can point the script at.",{"type":43,"tag":605,"props":3138,"children":3139},{},[3140],{"type":49,"value":3141},"Run the script over those files.",{"type":43,"tag":52,"props":3143,"children":3144},{},[3145,3147,3152,3154,3160,3162,3168],{"type":49,"value":3146},"All three are stdlib-only Python 3.11+ and print ",{"type":43,"tag":58,"props":3148,"children":3149},{},[3150],{"type":49,"value":3151},"plain text",{"type":49,"value":3153}," to stdout (or ",{"type":43,"tag":73,"props":3155,"children":3157},{"className":3156},[],[3158],{"type":49,"value":3159},"--out",{"type":49,"value":3161},") — designed to read well in a terminal, so save them as ",{"type":43,"tag":73,"props":3163,"children":3165},{"className":3164},[],[3166],{"type":49,"value":3167},".txt",{"type":49,"value":1304},{"type":43,"tag":3170,"props":3171,"children":3173},"h3",{"id":3172},"scriptsrender_run_reportpy-drill-into-one-run",[3174,3179],{"type":43,"tag":73,"props":3175,"children":3177},{"className":3176},[],[3178],{"type":49,"value":1774},{"type":49,"value":3180}," — drill into one run",{"type":43,"tag":52,"props":3182,"children":3183},{},[3184,3186,3196],{"type":49,"value":3185},"Produces the kind of detailed write-up you'd want when inspecting a single run: header (status, duration, posture), a ",{"type":43,"tag":58,"props":3187,"children":3188},{},[3189,3191],{"type":49,"value":3190},"narrated timeline that interleaves the agent's narration with each tool call ",{"type":43,"tag":639,"props":3192,"children":3193},{},[3194],{"type":49,"value":3195},"and its real input",{"type":49,"value":3197},", the end-of-run summary, and any scratchpad memory.",{"type":43,"tag":725,"props":3199,"children":3203},{"className":3200,"code":3201,"language":3202,"meta":730,"style":730},"language-bash shiki shiki-themes material-theme-lighter material-theme material-theme-palenight","# fetch (note --json), saving each to a file:\n#   call --json scout-runs-retrieve { \"id\": \"\u003Crun_id>\" }            -> run.json\n#   call --json tasks-runs-session-logs-retrieve { \"id\": \"\u003Ctask_run_id>\", \"task_id\": \"\u003Ctask_id>\", \"offset\": 0 }  -> log.json   (FULL — no exclude_types)\n#   (optional) call --json scout-scratchpad-search { ... }          -> mem.json\n#   (optional) call --json scout-config-list {}                     -> cfg.json\npython scripts\u002Frender_run_report.py --run run.json --log log.json \\\n    --scratchpad mem.json --config cfg.json --out report.txt\n","bash",[3204],{"type":43,"tag":73,"props":3205,"children":3206},{"__ignoreMap":730},[3207,3216,3224,3233,3242,3251,3291],{"type":43,"tag":736,"props":3208,"children":3209},{"class":738,"line":739},[3210],{"type":43,"tag":736,"props":3211,"children":3213},{"style":3212},"--shiki-light:#90A4AE;--shiki-light-font-style:italic;--shiki-default:#546E7A;--shiki-default-font-style:italic;--shiki-dark:#676E95;--shiki-dark-font-style:italic",[3214],{"type":49,"value":3215},"# fetch (note --json), saving each to a file:\n",{"type":43,"tag":736,"props":3217,"children":3218},{"class":738,"line":1516},[3219],{"type":43,"tag":736,"props":3220,"children":3221},{"style":3212},[3222],{"type":49,"value":3223},"#   call --json scout-runs-retrieve { \"id\": \"\u003Crun_id>\" }            -> run.json\n",{"type":43,"tag":736,"props":3225,"children":3227},{"class":738,"line":3226},3,[3228],{"type":43,"tag":736,"props":3229,"children":3230},{"style":3212},[3231],{"type":49,"value":3232},"#   call --json tasks-runs-session-logs-retrieve { \"id\": \"\u003Ctask_run_id>\", \"task_id\": \"\u003Ctask_id>\", \"offset\": 0 }  -> log.json   (FULL — no exclude_types)\n",{"type":43,"tag":736,"props":3234,"children":3236},{"class":738,"line":3235},4,[3237],{"type":43,"tag":736,"props":3238,"children":3239},{"style":3212},[3240],{"type":49,"value":3241},"#   (optional) call --json scout-scratchpad-search { ... }          -> mem.json\n",{"type":43,"tag":736,"props":3243,"children":3245},{"class":738,"line":3244},5,[3246],{"type":43,"tag":736,"props":3247,"children":3248},{"style":3212},[3249],{"type":49,"value":3250},"#   (optional) call --json scout-config-list {}                     -> cfg.json\n",{"type":43,"tag":736,"props":3252,"children":3254},{"class":738,"line":3253},6,[3255,3261,3266,3271,3276,3281,3286],{"type":43,"tag":736,"props":3256,"children":3258},{"style":3257},"--shiki-light:#E2931D;--shiki-default:#FFCB6B;--shiki-dark:#FFCB6B",[3259],{"type":49,"value":3260},"python",{"type":43,"tag":736,"props":3262,"children":3263},{"style":1551},[3264],{"type":49,"value":3265}," scripts\u002Frender_run_report.py",{"type":43,"tag":736,"props":3267,"children":3268},{"style":1551},[3269],{"type":49,"value":3270}," --run",{"type":43,"tag":736,"props":3272,"children":3273},{"style":1551},[3274],{"type":49,"value":3275}," run.json",{"type":43,"tag":736,"props":3277,"children":3278},{"style":1551},[3279],{"type":49,"value":3280}," --log",{"type":43,"tag":736,"props":3282,"children":3283},{"style":1551},[3284],{"type":49,"value":3285}," log.json",{"type":43,"tag":736,"props":3287,"children":3288},{"style":743},[3289],{"type":49,"value":3290}," \\\n",{"type":43,"tag":736,"props":3292,"children":3294},{"class":738,"line":3293},7,[3295,3300,3305,3310,3315,3320],{"type":43,"tag":736,"props":3296,"children":3297},{"style":1551},[3298],{"type":49,"value":3299},"    --scratchpad",{"type":43,"tag":736,"props":3301,"children":3302},{"style":1551},[3303],{"type":49,"value":3304}," mem.json",{"type":43,"tag":736,"props":3306,"children":3307},{"style":1551},[3308],{"type":49,"value":3309}," --config",{"type":43,"tag":736,"props":3311,"children":3312},{"style":1551},[3313],{"type":49,"value":3314}," cfg.json",{"type":43,"tag":736,"props":3316,"children":3317},{"style":1551},[3318],{"type":49,"value":3319}," --out",{"type":43,"tag":736,"props":3321,"children":3322},{"style":1551},[3323],{"type":49,"value":3324}," report.txt\n",{"type":43,"tag":52,"props":3326,"children":3327},{},[3328,3330,3336,3338,3344],{"type":49,"value":3329},"Modes (",{"type":43,"tag":73,"props":3331,"children":3333},{"className":3332},[],[3334],{"type":49,"value":3335},"--mode",{"type":49,"value":3337},", default ",{"type":43,"tag":73,"props":3339,"children":3341},{"className":3340},[],[3342],{"type":49,"value":3343},"detailed",{"type":49,"value":3345},"):",{"type":43,"tag":322,"props":3347,"children":3348},{},[3349,3376],{"type":43,"tag":326,"props":3350,"children":3351},{},[3352],{"type":43,"tag":330,"props":3353,"children":3354},{},[3355,3360,3365],{"type":43,"tag":334,"props":3356,"children":3357},{},[3358],{"type":49,"value":3359},"Mode",{"type":43,"tag":334,"props":3361,"children":3362},{},[3363],{"type":49,"value":3364},"Contains",{"type":43,"tag":334,"props":3366,"children":3367},{},[3368,3374],{"type":43,"tag":73,"props":3369,"children":3371},{"className":3370},[],[3372],{"type":49,"value":3373},"--log",{"type":49,"value":3375}," needed?",{"type":43,"tag":350,"props":3377,"children":3378},{},[3379,3400,3428],{"type":43,"tag":330,"props":3380,"children":3381},{},[3382,3390,3395],{"type":43,"tag":357,"props":3383,"children":3384},{},[3385],{"type":43,"tag":73,"props":3386,"children":3388},{"className":3387},[],[3389],{"type":49,"value":635},{"type":43,"tag":357,"props":3391,"children":3392},{},[3393],{"type":49,"value":3394},"header + posture + close-out prose",{"type":43,"tag":357,"props":3396,"children":3397},{},[3398],{"type":49,"value":3399},"no",{"type":43,"tag":330,"props":3401,"children":3402},{},[3403,3411,3423],{"type":43,"tag":357,"props":3404,"children":3405},{},[3406],{"type":43,"tag":73,"props":3407,"children":3409},{"className":3408},[],[3410],{"type":49,"value":3343},{"type":43,"tag":357,"props":3412,"children":3413},{},[3414,3416,3421],{"type":49,"value":3415},"+ narrated timeline with tool ",{"type":43,"tag":58,"props":3417,"children":3418},{},[3419],{"type":49,"value":3420},"inputs",{"type":49,"value":3422}," + tool tally + scratchpad",{"type":43,"tag":357,"props":3424,"children":3425},{},[3426],{"type":49,"value":3427},"yes",{"type":43,"tag":330,"props":3429,"children":3430},{},[3431,3439,3451],{"type":43,"tag":357,"props":3432,"children":3433},{},[3434],{"type":43,"tag":73,"props":3435,"children":3437},{"className":3436},[],[3438],{"type":49,"value":1847},{"type":43,"tag":357,"props":3440,"children":3441},{},[3442,3444,3449],{"type":49,"value":3443},"+ each tool call's (truncated) ",{"type":43,"tag":58,"props":3445,"children":3446},{},[3447],{"type":49,"value":3448},"output",{"type":49,"value":3450}," inline",{"type":43,"tag":357,"props":3452,"children":3453},{},[3454],{"type":49,"value":3427},{"type":43,"tag":52,"props":3456,"children":3457},{},[3458,3460,3466,3468,3474,3475,3481,3483,3489,3491,3497,3499,3505],{"type":49,"value":3459},"Other flags: ",{"type":43,"tag":73,"props":3461,"children":3463},{"className":3462},[],[3464],{"type":49,"value":3465},"--show-output",{"type":49,"value":3467}," (outputs in detailed mode), ",{"type":43,"tag":73,"props":3469,"children":3471},{"className":3470},[],[3472],{"type":49,"value":3473},"--input-width",{"type":49,"value":202},{"type":43,"tag":73,"props":3476,"children":3478},{"className":3477},[],[3479],{"type":49,"value":3480},"--output-width",{"type":49,"value":3482}," (truncation), ",{"type":43,"tag":73,"props":3484,"children":3486},{"className":3485},[],[3487],{"type":49,"value":3488},"--no-art",{"type":49,"value":3490}," (skip the hedgehog banner), ",{"type":43,"tag":73,"props":3492,"children":3494},{"className":3493},[],[3495],{"type":49,"value":3496},"--base-url",{"type":49,"value":3498}," (defaults to ",{"type":43,"tag":73,"props":3500,"children":3502},{"className":3501},[],[3503],{"type":49,"value":3504},"us.posthog.com",{"type":49,"value":1878},{"type":43,"tag":3170,"props":3507,"children":3509},{"id":3508},"scriptsfleet_surveypy-survey-the-whole-fleet",[3510,3516],{"type":43,"tag":73,"props":3511,"children":3513},{"className":3512},[],[3514],{"type":49,"value":3515},"scripts\u002Ffleet_survey.py",{"type":49,"value":3517}," — survey the whole fleet",{"type":43,"tag":52,"props":3519,"children":3520},{},[3521],{"type":49,"value":3522},"One scannable table — scout, enabled, posture, cadence, last run, last outcome — with a \"worth a look\" section that flags never-run, stuck-in-dry-run, and last-run-failed scouts.",{"type":43,"tag":725,"props":3524,"children":3526},{"className":3200,"code":3525,"language":3202,"meta":730,"style":730},"#   call --json scout-config-list {}                 -> cfg.json\n#   (optional) call --json scout-runs-list { \"limit\": 30 }  -> runs.json   (small limit!)\npython scripts\u002Ffleet_survey.py --config cfg.json --runs runs.json --now \u003Ccurrent-ISO-time>\n",[3527],{"type":43,"tag":73,"props":3528,"children":3529},{"__ignoreMap":730},[3530,3538,3546],{"type":43,"tag":736,"props":3531,"children":3532},{"class":738,"line":739},[3533],{"type":43,"tag":736,"props":3534,"children":3535},{"style":3212},[3536],{"type":49,"value":3537},"#   call --json scout-config-list {}                 -> cfg.json\n",{"type":43,"tag":736,"props":3539,"children":3540},{"class":738,"line":1516},[3541],{"type":43,"tag":736,"props":3542,"children":3543},{"style":3212},[3544],{"type":49,"value":3545},"#   (optional) call --json scout-runs-list { \"limit\": 30 }  -> runs.json   (small limit!)\n",{"type":43,"tag":736,"props":3547,"children":3548},{"class":738,"line":3226},[3549,3553,3558,3562,3566,3571,3576,3581,3586,3591,3596],{"type":43,"tag":736,"props":3550,"children":3551},{"style":3257},[3552],{"type":49,"value":3260},{"type":43,"tag":736,"props":3554,"children":3555},{"style":1551},[3556],{"type":49,"value":3557}," scripts\u002Ffleet_survey.py",{"type":43,"tag":736,"props":3559,"children":3560},{"style":1551},[3561],{"type":49,"value":3309},{"type":43,"tag":736,"props":3563,"children":3564},{"style":1551},[3565],{"type":49,"value":3314},{"type":43,"tag":736,"props":3567,"children":3568},{"style":1551},[3569],{"type":49,"value":3570}," --runs",{"type":43,"tag":736,"props":3572,"children":3573},{"style":1551},[3574],{"type":49,"value":3575}," runs.json",{"type":43,"tag":736,"props":3577,"children":3578},{"style":1551},[3579],{"type":49,"value":3580}," --now",{"type":43,"tag":736,"props":3582,"children":3583},{"style":1520},[3584],{"type":49,"value":3585}," \u003C",{"type":43,"tag":736,"props":3587,"children":3588},{"style":1551},[3589],{"type":49,"value":3590},"current-ISO-tim",{"type":43,"tag":736,"props":3592,"children":3593},{"style":743},[3594],{"type":49,"value":3595},"e",{"type":43,"tag":736,"props":3597,"children":3598},{"style":1520},[3599],{"type":49,"value":3600},">\n",{"type":43,"tag":52,"props":3602,"children":3603},{},[3604,3606,3612,3614,3619,3620,3625],{"type":49,"value":3605},"Pass ",{"type":43,"tag":73,"props":3607,"children":3609},{"className":3608},[],[3610],{"type":49,"value":3611},"--now",{"type":49,"value":3613}," (the current time, ISO-8601) to get relative \"ago\" columns; the last-outcome column reads what the run wrote straight off ",{"type":43,"tag":73,"props":3615,"children":3617},{"className":3616},[],[3618],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":3621,"children":3623},{"className":3622},[],[3624],{"type":49,"value":245},{"type":49,"value":3626}," on the run row.",{"type":43,"tag":3170,"props":3628,"children":3630},{"id":3629},"scriptsassess_healthpy-health-over-a-window-of-runs",[3631,3637],{"type":43,"tag":73,"props":3632,"children":3634},{"className":3633},[],[3635],{"type":49,"value":3636},"scripts\u002Fassess_health.py",{"type":49,"value":3638}," — health over a window of runs",{"type":43,"tag":52,"props":3640,"children":3641},{},[3642],{"type":49,"value":3643},"Implements the \"assess health and performance\" workflow above: a per-scout table (runs, success %, report rate, cadence gap vs interval, adherence, median duration, memory growth) plus a \"worth a look\" section flagging all-failed scouts, timeout-shaped failures, cadence stalls, staleness, and empty scratchpads.",{"type":43,"tag":725,"props":3645,"children":3647},{"className":3200,"code":3646,"language":3202,"meta":730,"style":730},"#   call --json scout-runs-list { \"limit\": 100, \"date_from\": \"\u003CISO>\" }  -> runs.json\n#   (optional) call --json scout-config-list {}                          -> cfg.json\n#   (optional) call --json scout-scratchpad-search {}                    -> mem.json\npython scripts\u002Fassess_health.py --runs runs.json --config cfg.json \\\n    --scratchpad mem.json --now \u003Ccurrent-ISO-time> [--skill signals-scout-general]\n",[3648],{"type":43,"tag":73,"props":3649,"children":3650},{"__ignoreMap":730},[3651,3659,3667,3675,3707],{"type":43,"tag":736,"props":3652,"children":3653},{"class":738,"line":739},[3654],{"type":43,"tag":736,"props":3655,"children":3656},{"style":3212},[3657],{"type":49,"value":3658},"#   call --json scout-runs-list { \"limit\": 100, \"date_from\": \"\u003CISO>\" }  -> runs.json\n",{"type":43,"tag":736,"props":3660,"children":3661},{"class":738,"line":1516},[3662],{"type":43,"tag":736,"props":3663,"children":3664},{"style":3212},[3665],{"type":49,"value":3666},"#   (optional) call --json scout-config-list {}                          -> cfg.json\n",{"type":43,"tag":736,"props":3668,"children":3669},{"class":738,"line":3226},[3670],{"type":43,"tag":736,"props":3671,"children":3672},{"style":3212},[3673],{"type":49,"value":3674},"#   (optional) call --json scout-scratchpad-search {}                    -> mem.json\n",{"type":43,"tag":736,"props":3676,"children":3677},{"class":738,"line":3235},[3678,3682,3687,3691,3695,3699,3703],{"type":43,"tag":736,"props":3679,"children":3680},{"style":3257},[3681],{"type":49,"value":3260},{"type":43,"tag":736,"props":3683,"children":3684},{"style":1551},[3685],{"type":49,"value":3686}," scripts\u002Fassess_health.py",{"type":43,"tag":736,"props":3688,"children":3689},{"style":1551},[3690],{"type":49,"value":3570},{"type":43,"tag":736,"props":3692,"children":3693},{"style":1551},[3694],{"type":49,"value":3575},{"type":43,"tag":736,"props":3696,"children":3697},{"style":1551},[3698],{"type":49,"value":3309},{"type":43,"tag":736,"props":3700,"children":3701},{"style":1551},[3702],{"type":49,"value":3314},{"type":43,"tag":736,"props":3704,"children":3705},{"style":743},[3706],{"type":49,"value":3290},{"type":43,"tag":736,"props":3708,"children":3709},{"class":738,"line":3244},[3710,3714,3718,3722,3726,3730,3734,3739,3744],{"type":43,"tag":736,"props":3711,"children":3712},{"style":1551},[3713],{"type":49,"value":3299},{"type":43,"tag":736,"props":3715,"children":3716},{"style":1551},[3717],{"type":49,"value":3304},{"type":43,"tag":736,"props":3719,"children":3720},{"style":1551},[3721],{"type":49,"value":3580},{"type":43,"tag":736,"props":3723,"children":3724},{"style":1520},[3725],{"type":49,"value":3585},{"type":43,"tag":736,"props":3727,"children":3728},{"style":1551},[3729],{"type":49,"value":3590},{"type":43,"tag":736,"props":3731,"children":3732},{"style":743},[3733],{"type":49,"value":3595},{"type":43,"tag":736,"props":3735,"children":3736},{"style":1520},[3737],{"type":49,"value":3738},">",{"type":43,"tag":736,"props":3740,"children":3741},{"style":743},[3742],{"type":49,"value":3743}," [--skill ",{"type":43,"tag":736,"props":3745,"children":3746},{"style":1551},[3747],{"type":49,"value":3748},"signals-scout-general]\n",{"type":43,"tag":52,"props":3750,"children":3751},{},[3752,3758,3760,3765,3767,3773,3775,3781,3783,3788,3789,3794,3796,3801,3803,3808],{"type":43,"tag":73,"props":3753,"children":3755},{"className":3754},[],[3756],{"type":49,"value":3757},"--config",{"type":49,"value":3759}," is what lets it score cadence adherence (the expected interval) and staleness (the authoritative ",{"type":43,"tag":73,"props":3761,"children":3763},{"className":3762},[],[3764],{"type":49,"value":394},{"type":49,"value":3766},", which the windowed runs can miss when the 100-row cap truncates the newest runs).\nWithout ",{"type":43,"tag":73,"props":3768,"children":3770},{"className":3769},[],[3771],{"type":49,"value":3772},"--scratchpad",{"type":49,"value":3774}," the memory column shows ",{"type":43,"tag":73,"props":3776,"children":3778},{"className":3777},[],[3779],{"type":49,"value":3780},"n\u002Fa",{"type":49,"value":3782}," and no memory flags fire.\nThe report rate reads the run rows' ",{"type":43,"tag":73,"props":3784,"children":3786},{"className":3785},[],[3787],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":3790,"children":3792},{"className":3791},[],[3793],{"type":49,"value":245},{"type":49,"value":3795}," directly, so it's exact — but it only counts ",{"type":43,"tag":639,"props":3797,"children":3798},{},[3799],{"type":49,"value":3800},"writes",{"type":49,"value":3802},"; judge signal-to-noise by the resulting report statuses via ",{"type":43,"tag":73,"props":3804,"children":3806},{"className":3805},[],[3807],{"type":49,"value":539},{"type":49,"value":1304},{"type":43,"tag":567,"props":3810,"children":3812},{"id":3811},"tips",[3813],{"type":49,"value":3814},"Tips",{"type":43,"tag":601,"props":3816,"children":3817},{},[3818,3835,3845,3896,3930,3947,3969,3983,3999],{"type":43,"tag":605,"props":3819,"children":3820},{},[3821,3833],{"type":43,"tag":58,"props":3822,"children":3823},{},[3824,3826,3831],{"type":49,"value":3825},"Always surface the ",{"type":43,"tag":73,"props":3827,"children":3829},{"className":3828},[],[3830],{"type":49,"value":387},{"type":49,"value":3832}," posture.",{"type":49,"value":3834}," \"Running but in dry-run\" is the single most common reason a user thinks a scout is broken when it isn't.",{"type":43,"tag":605,"props":3836,"children":3837},{},[3838,3843],{"type":43,"tag":58,"props":3839,"children":3840},{},[3841],{"type":49,"value":3842},"An empty close-out is success.",{"type":49,"value":3844}," Most runs should find nothing.\nDon't report a wall of clean, empty runs as a problem.",{"type":43,"tag":605,"props":3846,"children":3847},{},[3848,3853,3855,3860,3861,3866,3868,3873,3875,3880,3882,3887,3889,3894],{"type":43,"tag":58,"props":3849,"children":3850},{},[3851],{"type":49,"value":3852},"What a run wrote is a first-class run field.",{"type":49,"value":3854}," Read ",{"type":43,"tag":73,"props":3856,"children":3858},{"className":3857},[],[3859],{"type":49,"value":234},{"type":49,"value":202},{"type":43,"tag":73,"props":3862,"children":3864},{"className":3863},[],[3865],{"type":49,"value":245},{"type":49,"value":3867}," per run (or filter with ",{"type":43,"tag":73,"props":3869,"children":3871},{"className":3870},[],[3872],{"type":49,"value":3009},{"type":49,"value":3874},") to find what was written, without parsing the prose ",{"type":43,"tag":73,"props":3876,"children":3878},{"className":3877},[],[3879],{"type":49,"value":635},{"type":49,"value":3881},".\nThe ",{"type":43,"tag":73,"props":3883,"children":3885},{"className":3884},[],[3886],{"type":49,"value":550},{"type":49,"value":3888}," inbox filter lists the ",{"type":43,"tag":639,"props":3890,"children":3891},{},[3892],{"type":49,"value":3893},"reports",{"type":49,"value":3895}," the fleet surfaced; an empty result there means it hasn't written anything yet (scouts hold a high bar), not that the filter is broken.",{"type":43,"tag":605,"props":3897,"children":3898},{},[3899,3909,3910,3915,3916,3921,3923,3928],{"type":43,"tag":58,"props":3900,"children":3901},{},[3902,3907],{"type":43,"tag":73,"props":3903,"children":3905},{"className":3904},[],[3906],{"type":49,"value":311},{"type":49,"value":3908}," does not mean \"did nothing\".",{"type":49,"value":881},{"type":43,"tag":73,"props":3911,"children":3913},{"className":3912},[],[3914],{"type":49,"value":253},{"type":49,"value":202},{"type":43,"tag":73,"props":3917,"children":3919},{"className":3918},[],[3920],{"type":49,"value":260},{"type":49,"value":3922}," are legacy signal-channel fields — they stay ",{"type":43,"tag":73,"props":3924,"children":3926},{"className":3925},[],[3927],{"type":49,"value":283},{"type":49,"value":3929}," \u002F empty on report-channel scouts, productive or not.\nJudge output by the report columns; a non-zero legacy tally means the run came from a scout still on the legacy channel, and is that run's real output.",{"type":43,"tag":605,"props":3931,"children":3932},{},[3933,3945],{"type":43,"tag":58,"props":3934,"children":3935},{},[3936,3938,3943],{"type":49,"value":3937},"A ~30-min run that ",{"type":43,"tag":73,"props":3939,"children":3941},{"className":3940},[],[3942],{"type":49,"value":1685},{"type":49,"value":3944}," is usually a timeout, not a broken scout.",{"type":49,"value":3946}," Completed runs finish in a couple of minutes.\nMost often the scout over-investigated and ran the full budget (the fleet self-corrects by writing \"tight-run recipe\" scratchpad entries) — but some are false timeouts where the scout actually finished in a few minutes and the run then hung on a dropped close-out.\nThe session log (above) tells them apart: real over-investigation shows tool calls right up to the wall; a false timeout goes silent long before it.\nDon't assume over-investigation from duration alone.",{"type":43,"tag":605,"props":3948,"children":3949},{},[3950,3960,3962,3967],{"type":43,"tag":58,"props":3951,"children":3952},{},[3953,3955],{"type":49,"value":3954},"Lead with the run ",{"type":43,"tag":73,"props":3956,"children":3958},{"className":3957},[],[3959],{"type":49,"value":635},{"type":49,"value":3961},", then offer ",{"type":43,"tag":73,"props":3963,"children":3965},{"className":3964},[],[3966],{"type":49,"value":1464},{"type":49,"value":3968}," for the full transcript — don't dump raw run rows at the user.",{"type":43,"tag":605,"props":3970,"children":3971},{},[3972,3981],{"type":43,"tag":58,"props":3973,"children":3974},{},[3975],{"type":43,"tag":73,"props":3976,"children":3978},{"className":3977},[],[3979],{"type":49,"value":3980},"last_run_at: null",{"type":49,"value":3982}," means a scout has never fired — check it's enabled and the project is enrolled before digging further.",{"type":43,"tag":605,"props":3984,"children":3985},{},[3986,3991,3992,3997],{"type":43,"tag":58,"props":3987,"children":3988},{},[3989],{"type":49,"value":3990},"To explain a quiet scout, read the project profile.",{"type":49,"value":881},{"type":43,"tag":73,"props":3993,"children":3995},{"className":3994},[],[3996],{"type":49,"value":563},{"type":49,"value":3998}," shows whether the surface it watches is even in use — a logs scout on a project with no logs has nothing to do.",{"type":43,"tag":605,"props":4000,"children":4001},{},[4002,4007,4009,4014,4016,4022],{"type":43,"tag":58,"props":4003,"children":4004},{},[4005],{"type":49,"value":4006},"This skill is read-only.",{"type":49,"value":4008}," To change a scout's schedule, posture, or body, hand off to the ",{"type":43,"tag":73,"props":4010,"children":4012},{"className":4011},[],[4013],{"type":49,"value":145},{"type":49,"value":4015}," skill — it covers ",{"type":43,"tag":73,"props":4017,"children":4019},{"className":4018},[],[4020],{"type":49,"value":4021},"scout-config-update",{"type":49,"value":4023}," and the skills-store edit path.",{"type":43,"tag":4025,"props":4026,"children":4027},"style",{},[4028],{"type":49,"value":4029},"html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"items":4031,"total":4200},[4032,4049,4061,4074,4087,4102,4116,4133,4147,4162,4172,4190],{"slug":4033,"name":4033,"fn":4034,"description":4035,"org":4036,"tags":4037,"stars":4046,"repoUrl":4047,"updatedAt":4048},"analyzing-expensive-users","analyze expensive users in AI observability","Analyze the most expensive users in AI observability and explain why they cost so much. Use when the user asks about top spenders, expensive users, per-user LLM cost, user-level cost drivers, or patterns behind high AI observability spend.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4038,4039,4042,4045],{"name":18,"slug":19,"type":13},{"name":4040,"slug":4041,"type":13},"Cost Optimization","cost-optimization",{"name":4043,"slug":4044,"type":13},"Observability","observability",{"name":9,"slug":8,"type":13},35568,"https:\u002F\u002Fgithub.com\u002FPostHog\u002Fposthog","2026-07-28T05:34:11.117757",{"slug":4050,"name":4050,"fn":4051,"description":4052,"org":4053,"tags":4054,"stars":4046,"repoUrl":4047,"updatedAt":4060},"auditing-endpoints","audit PostHog project endpoints","Audit every endpoint in a PostHog project for staleness, failed materialisations, and unused materialised versions. Use when the user asks \"what endpoints can I clean up?\", \"are any of my endpoints broken?\", \"which materialised versions are still being called?\", or wants a one-shot cleanup pass over the Endpoints product. Produces a prioritised report grouped by issue type, with recommended actions but does not modify anything without explicit confirmation.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4055,4056,4059],{"name":18,"slug":19,"type":13},{"name":4057,"slug":4058,"type":13},"Audit","audit",{"name":9,"slug":8,"type":13},"2026-06-08T08:08:33.693989",{"slug":4062,"name":4062,"fn":4063,"description":4064,"org":4065,"tags":4066,"stars":4046,"repoUrl":4047,"updatedAt":4073},"auditing-warehouse-source-health","audit PostHog data warehouse source health","Audit the health of a PostHog project's data warehouse sources and syncs — find every broken or degraded source connection, sync schema, and webhook channel. Use when the user asks \"why are my imports failing?\", \"what's broken with my sources?\", \"why is my warehouse data stale?\", or wants a one-shot triage of source\u002Fsync health before deciding where to dig in. Produces a prioritized report grouped by severity, with recommended next steps. For materialized-view health use `auditing-warehouse-view-health`; for a single failing sync use `diagnosing-failed-warehouse-syncs`.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4067,4068,4071,4072],{"name":4057,"slug":4058,"type":13},{"name":4069,"slug":4070,"type":13},"Data Warehouse","data-warehouse",{"name":4043,"slug":4044,"type":13},{"name":9,"slug":8,"type":13},"2026-06-18T08:22:57.67984",{"slug":4075,"name":4075,"fn":4076,"description":4077,"org":4078,"tags":4079,"stars":4046,"repoUrl":4047,"updatedAt":4086},"auditing-warehouse-view-health","audit PostHog materialized view health","Audit the health of a PostHog project's materialized views (saved queries) — find every failed materialization and flag unused or stale materialized views that cost storage and compute. Use when the user asks \"which of my views are broken?\", \"why is this materialized view failing?\", \"are any of my views wasting compute?\", or wants a one-shot triage of view health. For source\u002Fsync health use `auditing-warehouse-source-health`.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4080,4081,4082,4085],{"name":4057,"slug":4058,"type":13},{"name":4069,"slug":4070,"type":13},{"name":4083,"slug":4084,"type":13},"Performance","performance",{"name":9,"slug":8,"type":13},"2026-06-18T08:25:10.936787",{"slug":4088,"name":4088,"fn":4089,"description":4090,"org":4091,"tags":4092,"stars":4046,"repoUrl":4047,"updatedAt":4101},"authoring-error-tracking-alerts","author PostHog error tracking alerts","Author error tracking alerts that fire when an issue is created, reopened, or starts spiking. Use when the user asks to set up error notifications, route exceptions to Slack\u002Fwebhook\u002FLinear, or evaluate which error events are worth alerting on. Covers trigger-event selection, integration choice, dedup against existing alerts, and shipping with the canonical message body shape.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4093,4096,4099,4100],{"name":4094,"slug":4095,"type":13},"Alerting","alerting",{"name":4097,"slug":4098,"type":13},"Debugging","debugging",{"name":4043,"slug":4044,"type":13},{"name":9,"slug":8,"type":13},"2026-06-18T08:24:40.318583",{"slug":4103,"name":4103,"fn":4104,"description":4105,"org":4106,"tags":4107,"stars":4046,"repoUrl":4047,"updatedAt":4115},"authoring-log-alerts","author log alerts in PostHog","Author useful, low-noise log alerts on services in a PostHog project. Use when the user asks to set up alerts for their logs, suggest alerts they should add, or evaluate whether a service is worth monitoring. Covers service triage, baseline characterisation, threshold drafting, back-testing via simulate, and shipping with a notification destination.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4108,4109,4110,4111,4114],{"name":18,"slug":19,"type":13},{"name":15,"slug":16,"type":13},{"name":4043,"slug":4044,"type":13},{"name":4112,"slug":4113,"type":13},"Operations","operations",{"name":9,"slug":8,"type":13},"2026-07-18T05:10:54.430898",{"slug":4117,"name":4117,"fn":4118,"description":4119,"org":4120,"tags":4121,"stars":4046,"repoUrl":4047,"updatedAt":4132},"building-workflows","build and edit PostHog workflows","Build, edit, test, enable, and monitor PostHog workflows over MCP. Author the action\u002Fedge graph so it runs and opens cleanly in the visual editor, then change drafts surgically with patch operations. Use when asked to build, set up, automate, change, fix, or debug a workflow, campaign, broadcast, drip sequence, or event-triggered automation in the workflows product.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4122,4125,4128,4129],{"name":4123,"slug":4124,"type":13},"Automation","automation",{"name":4126,"slug":4127,"type":13},"MCP","mcp",{"name":9,"slug":8,"type":13},{"name":4130,"slug":4131,"type":13},"Workflow Automation","workflow-automation","2026-07-28T05:34:12.167015",{"slug":4134,"name":4134,"fn":4135,"description":4136,"org":4137,"tags":4138,"stars":4046,"repoUrl":4047,"updatedAt":4146},"check-posthog-loading","inspect PostHog SDK loading across URLs","Inspect how the PostHog JavaScript SDK is loaded across a list of URLs. Use to confirm consistent installation across pages, find pages missing the snippet, detect mismatched API keys or hosts between pages, and verify the load method (head snippet vs deferred vs array.js).\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4139,4140,4141,4144,4145],{"name":18,"slug":19,"type":13},{"name":4097,"slug":4098,"type":13},{"name":4142,"slug":4143,"type":13},"Frontend","frontend",{"name":4043,"slug":4044,"type":13},{"name":9,"slug":8,"type":13},"2026-05-07T05:56:19.828048",{"slug":4148,"name":4148,"fn":4149,"description":4150,"org":4151,"tags":4152,"stars":4046,"repoUrl":4047,"updatedAt":4161},"consuming-endpoints-from-client-code","integrate PostHog endpoints into client applications","Wire a PostHog endpoint into a client app or SDK. Covers fetching the OpenAPI spec, generating a typed client with openapi-generator or @hey-api\u002Fopenapi-ts, sending the right auth header, shaping the variables payload (HogQL code_name vs insight breakdown property), handling rate-limit and materialised-endpoint error responses. Use when the user says \"how do I call my endpoint\", \"generate a client for this\", or \"what auth header do I use\".\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4153,4156,4157,4158],{"name":4154,"slug":4155,"type":13},"API Development","api-development",{"name":4142,"slug":4143,"type":13},{"name":9,"slug":8,"type":13},{"name":4159,"slug":4160,"type":13},"SDK","sdk","2026-06-08T08:08:34.929454",{"slug":4163,"name":4163,"fn":4164,"description":4165,"org":4166,"tags":4167,"stars":4046,"repoUrl":4047,"updatedAt":4171},"copying-endpoints-across-projects","copy PostHog endpoints across projects","Copy a PostHog endpoint (a saved HogQL\u002Finsight query exposed as an API route) to another project in the same organization, or duplicate it under a new name in the same project. Use when the user wants to duplicate an endpoint, promote an endpoint from staging to production, replicate an endpoint's query\u002Fvariables\u002Ffreshness config in another workspace, or clone an endpoint to iterate on it. Unlike feature flags and experiments, endpoints have NO native cross-project copy tool — this skill covers the read-then-recreate flow (endpoint-get then endpoint-create), the active-project switching it requires, name-collision checks, and the safe defaults (land unmaterialised in the target, verify with endpoint-run). Does not cover editing endpoint versions (see managing-endpoint-versions) or authoring a brand-new endpoint from scratch (see creating-an-endpoint).\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4168,4169,4170],{"name":4154,"slug":4155,"type":13},{"name":4112,"slug":4113,"type":13},{"name":9,"slug":8,"type":13},"2026-07-15T05:29:58.442727",{"slug":4173,"name":4173,"fn":4174,"description":4175,"org":4176,"tags":4177,"stars":4046,"repoUrl":4047,"updatedAt":4189},"creating-ai-subscription","schedule recurring AI-generated PostHog reports","Create a recurring AI-generated PostHog report — schedule a free-text prompt to run on a cron, with the LLM-synthesized markdown delivered to email or Slack on each tick. Use when the user wants a recurring AI summary of X on any cadence (daily, weekly, monthly, yearly) rather than a one-off report. (To attach an AI summary to an existing insight\u002Fdashboard subscription instead of a free-text prompt, see `managing-subscriptions` and its `summary_enabled` option.)\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4178,4179,4182,4183,4186],{"name":4123,"slug":4124,"type":13},{"name":4180,"slug":4181,"type":13},"Email","email",{"name":9,"slug":8,"type":13},{"name":4184,"slug":4185,"type":13},"Reporting","reporting",{"name":4187,"slug":4188,"type":13},"Slack","slack","2026-06-09T07:32:27.935712",{"slug":4191,"name":4191,"fn":4192,"description":4193,"org":4194,"tags":4195,"stars":4046,"repoUrl":4047,"updatedAt":4199},"creating-an-endpoint","create PostHog API endpoints","Create a PostHog endpoint with the right shape on the first try — covers query kind choice, name conventions, what to expose as variables (HogQL code_name vs insight breakdown), data_freshness_seconds, and whether to materialise on day one. Use when the user says \"create an endpoint\", \"expose this query as an API\", \"turn this insight into an endpoint\", or asks for help structuring a new endpoint. Steers away from common mistakes: materialising a query with cohort breakdowns or compare mode, inline-only variables on a materialised endpoint, unbounded date ranges, ambiguous names.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4196,4197,4198],{"name":18,"slug":19,"type":13},{"name":4154,"slug":4155,"type":13},{"name":9,"slug":8,"type":13},"2026-06-08T08:08:29.624498",231,{"items":4202,"total":4307},[4203,4218,4234,4249,4261,4273,4291],{"slug":4204,"name":4204,"fn":4205,"description":4206,"org":4207,"tags":4208,"stars":20,"repoUrl":21,"updatedAt":4217},"analyzing-experiment-session-replays","analyze session replays for PostHog experiments","Analyze session replay patterns across experiment variants to understand user behavior differences. Use when the user wants to see how users interact with different experiment variants, identify usability issues, compare behavior patterns between control and test groups, or get qualitative insights to complement quantitative experiment results.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4209,4210,4213,4214],{"name":18,"slug":19,"type":13},{"name":4211,"slug":4212,"type":13},"Design","design",{"name":9,"slug":8,"type":13},{"name":4215,"slug":4216,"type":13},"User Research","user-research","2026-04-06T18:44:38.291781",{"slug":4219,"name":4219,"fn":4220,"description":4221,"org":4222,"tags":4223,"stars":20,"repoUrl":21,"updatedAt":4233},"assessing-heatmaps","analyze page heatmaps and suggest improvements","Assesses what a page's heatmap is telling you and recommends concrete changes. Pulls click \u002F rageclick \u002F scroll-depth data for a URL, names the hot elements by cross-referencing autocapture events on the same page, and can create a saved heatmap the user opens in PostHog, then summarizes the behavior and proposes improvements.\nTRIGGER when: user asks what a heatmap shows, why people aren't clicking something, where users rage-click, how far they scroll, what to change on a page based on heatmap\u002Fclick data, or to 'analyze\u002Fassess\u002Freview the heatmap' for a URL.\nDO NOT TRIGGER when: the user only wants to create a saved heatmap screenshot with no analysis (use heatmaps-saved-create directly), or is asking about session replay in general (use investigating-replay).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4224,4225,4226,4227,4230],{"name":18,"slug":19,"type":13},{"name":4142,"slug":4143,"type":13},{"name":9,"slug":8,"type":13},{"name":4228,"slug":4229,"type":13},"Product Management","product-management",{"name":4231,"slug":4232,"type":13},"UX Design","ux-design","2026-06-05T07:40:43.37798",{"slug":4235,"name":4235,"fn":4236,"description":4237,"org":4238,"tags":4239,"stars":20,"repoUrl":21,"updatedAt":4248},"auditing-experiments-flags","audit PostHog experiments and feature flags","Audit PostHog experiments and feature flags for configuration issues, staleness, and best-practice violations. Read when the user asks to audit, health-check, or review experiments or feature flags, check flag hygiene, or verify experiment setup.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4240,4241,4244,4245],{"name":4057,"slug":4058,"type":13},{"name":4242,"slug":4243,"type":13},"Feature Flags","feature-flags",{"name":9,"slug":8,"type":13},{"name":4246,"slug":4247,"type":13},"QA","qa","2026-04-06T18:44:30.657553",{"slug":145,"name":145,"fn":4250,"description":4251,"org":4252,"tags":4253,"stars":20,"repoUrl":21,"updatedAt":4260},"author and edit PostHog Signals scouts","How to author, edit, and adapt PostHog Signals scouts — the scheduled agents that scan a project and write reports into the Signals inbox. Use when a user wants to customize a canonical scout for their own setup (narrow its scope, retune its thresholds, add disqualifiers), tweak a scout's schedule or dry-run posture, or write a brand-new scout from scratch for a specific use case (a custom event, a product surface no canonical scout covers), or steer a scout without editing it at all by leaving it a note. Covers the scout SKILL.md anatomy, the report contract, the dedupe + scratchpad-memory conventions, the scout-notes steering channel, the per-team skills-store path vs the canonical in-repo path, and the write-and-inspect test loop (with dry-run as an optional safety net). Trigger on \"write\u002Fedit\u002Fcustomize a signals scout\", \"new scout for X\", \"tune my scout schedule\", \"make a scout that watches \u003Cevent>\", \"leave a note for \u002F give feedback to a scout\", \"tell the scouts about X\".\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4254,4257,4258,4259],{"name":4255,"slug":4256,"type":13},"Agents","agents",{"name":4123,"slug":4124,"type":13},{"name":4043,"slug":4044,"type":13},{"name":9,"slug":8,"type":13},"2026-07-28T05:33:45.509154",{"slug":4262,"name":4262,"fn":4263,"description":4264,"org":4265,"tags":4266,"stars":20,"repoUrl":21,"updatedAt":4272},"building-a-dashboard","build and update PostHog dashboards","Build a new dashboard, or update an existing one, from a set of insights — the same job the in-app assistant does with its upsert-dashboard tool, but over MCP. Use when a user asks to create a dashboard, put several metrics\u002Fcharts together on one page, assemble a dashboard for a topic (product analytics, retention, revenue, activation, etc.), or add\u002Fremove\u002Freplace insights on a dashboard they already have. Covers deciding create vs update, reusing existing insights vs creating new ones, and using PostHog's vetted dashboard templates as reference for what a strong dashboard on a topic looks like.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4267,4268,4271],{"name":18,"slug":19,"type":13},{"name":4269,"slug":4270,"type":13},"Dashboards","dashboards",{"name":4126,"slug":4127,"type":13},"2026-07-21T06:07:38.060598",{"slug":4274,"name":4274,"fn":4275,"description":4276,"org":4277,"tags":4278,"stars":20,"repoUrl":21,"updatedAt":4290},"checking-deploy-timing","correlate PostHog deployments with GitHub commits","Determine when a PostHog code change reached a given environment by reading the hidden GIT deploy annotations in the project and correlating them with the merge commit on GitHub. Use when PostHog staff ask \"when was X deployed\", \"is my change live in the US\u002FEU yet\", \"has my PR shipped\", \"did the fix roll out to prod-us\", or otherwise want to know whether\u002Fwhen a commit, PR, or feature went out to a region. Do not answer deploy-timing questions from event\u002Fdata volume alone — that only shows when data changed, not when code shipped.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4279,4282,4285,4288,4289],{"name":4280,"slug":4281,"type":13},"Deployment","deployment",{"name":4283,"slug":4284,"type":13},"Git","git",{"name":4286,"slug":4287,"type":13},"GitHub","github",{"name":4043,"slug":4044,"type":13},{"name":9,"slug":8,"type":13},"2026-06-28T07:46:59.53536",{"slug":4292,"name":4292,"fn":4293,"description":4294,"org":4295,"tags":4296,"stars":20,"repoUrl":21,"updatedAt":4306},"choosing-trend-or-slope-view","visualize trends and growth over time","Clarify how to visualize change over a time range before building a trend. Use whenever the user asks how much something changed, grew, dropped, improved, or regressed between two points or periods — \"how much did X change from A to B\", \"before vs after\", \"start vs end\", \"week over week\", \"compare this month to last\", \"change over time\" — or mentions a \"slope chart\" \u002F \"slopegraph\". Two readings of \"change\" need different charts: the whole trend (a line, every interval) versus just the two endpoints (a slope, start vs end). Ask which they want, then render it. Not for choosing a saved insight ChartDisplayType in the insight editor.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[4297,4298,4301,4304,4305],{"name":18,"slug":19,"type":13},{"name":4299,"slug":4300,"type":13},"Charts","charts",{"name":4302,"slug":4303,"type":13},"Data Visualization","data-visualization",{"name":9,"slug":8,"type":13},{"name":4184,"slug":4185,"type":13},"2026-06-18T08:18:57.960157",56]