---
name: "skill-task-health"
type: skill
license: CC BY-NC-SA 4.0
description: >-
  Verify the scheduled layer is healthy on three axes — behaviour (each task still
  produces its expected output), deployment parity (every canon task/routine artefact
  has a live schedule that fires on its cadence, and every schedule maps back to an artefact), and config parity
  (each live config is a one-line loader, so the task runs current canon rather than a
  stale pasted prompt). Use when running the task-health check, or when asked whether
  the scheduled tasks still do what their canon says, whether everything that should
  be scheduled is, or whether a saved canon change reached the running system. Keeps a
  registry of task, expected output, cadence and whether an empty run is legitimate;
  reconciles the canon set against live schedules, reads each config body, and flags
  gaps via skill-issue-capture. Propose-only — never restarts or edits a task or its
  config. Owned by Pulse; sibling to skill-ops-sync (canon and repo text parity) —
  this checks behaviour, wiring, and whether the wiring loads canon at all.
---

# task-health

A health check for the scheduled layer. `skill-ops-sync` confirms a task's *text* matches between Claude canon and the repo; this confirms the deployed task still *does* what that text describes, that everything which should be deployed actually is, **and that what runs is the canon rather than a copy of it**. Five things are independent and each fails silently: text can be in parity while behaviour has regressed; behaviour can be fine on the tasks that exist while a canon task was never wired at all; a schedule can be wired and mapped yet never fire on its cadence; a stale schedule can linger with no canon artefact behind it; and a live config can be a *pasted copy* of an artefact rather than a loader for it, so the task runs wording nobody has read for a month while every other check passes green. This skill checks the latter three — behaviour, deployment parity, and config parity. Propose-only: it flags a gap, never restarts, edits, or wires anything.

## Trigger

Scheduled (Pulse), daily or on the ops cadence; or on demand ("are the scheduled tasks still working?", "is everything that should be scheduled actually scheduled?"). Linear connector, the scheduled-tasks list, plus read access to whatever surface a checked task writes to.

## Behaviour

### Pass A — Behaviour (does each task still do its job)

1. **Read the registry** — the small set of scheduled tasks that have a *clear, observable* output, each with its expected output, a cadence window, and **whether an empty run is legitimate**. Only tasks with an unambiguous signal belong here; verifying everything is explicitly not the goal.
2. **Check the task ran at all** — via its last-run marker, which is named per surface in the registry (a write on the surface the task posts to; for a repo workflow, its run history *and* the commit it makes). A task that did not run is a *missing-run* finding, and it is a different finding from a missing output. A third case sits between them: a run that **started and stopped on a missing connector** (a loader's fail-closed rule firing on "no Linear tools") is a **failed run**, not an empty one — name it as its own class beside *missing-run* and *skipped firing* (APP-812), because its only trace is the session report and the day's pass is otherwise lost until a person re-runs it (the 2026-09-02 `task-pulse-refine` run — APP-1075). Before filing it, confirm the connector was genuinely absent and not merely UUID-prefixed and unsurfaced (`convention-linear`, *Reading Linear safely*). Establish this first, because it decides which of the two questions below is even worth asking.
3. **Then ask the question the registry's empty-legitimate column selects.** Pass A answers two different questions, and using the wrong instrument is how a real miss gets waited out:
   - **Empty legitimate = yes** — the task acts only when there is input (a sweep on an empty inbox), so doing nothing can be healthy. Ask *has the signal appeared within its window?* A task that ran and correctly produced nothing is **green**; only a window with no signal and no legitimate empty is a finding.
   - **Empty legitimate = no** — the task's canon guarantees an output on **every** run. Ask *did the last run produce its output?* **Flag on the first miss, with no window tolerance.** The window is the wrong instrument here: it is built to tolerate exactly the miss that should be flagged, and a 24–48h window on a task that should post daily will sit green through a lapse for days.
4. **Name which of the three cases you found** — *didn't run* / *ran and correctly did nothing* / **ran and should have produced something but didn't**. The third case is the one the window-only shape could not express, and it is the case the skill was built for: the worked case that justified building this check is `task-daily-report` lapsing ~5 days unnoticed. (Worked case: 2026-07-15, `task-daily-report` ran at 08:01Z and posted zero of its four guaranteed initiative updates, while the previous day's four sat ~27h old — inside the 24–48h window. The letter of the check said green and the run could only report an amber watch item, though its canon is unambiguous that a silent run is out of spec: *"If a whole team has no started projects, still post a short initiative update saying so in one line."* — APP-545.)
5. **Flag a confirmed regression** — via `skill-issue-capture` (a Backlog ticket in Apps / os.Claude), naming the task, the expected output, which of the three cases it is, and when the output was last seen. One flag per regressed task; dedupe against any open flag.

### Pass B — Deployment parity (is everything wired, firing, and nothing orphaned)

6. **List both sides.** Enumerate the **canon** scheduled artefacts — every `task-*` and `routine-*` in the skills store — and the **live** deployments: the Cowork scheduled tasks (via the scheduled-tasks list) and the Cloud Routines (Claude Code surface). **Every live schedule has a canon `task-*` / `routine-*` artefact — no exceptions** (`core-operating-model`, Layer 2): a config pointing straight at a `skill-*`, with the skill's § Setup describing its own deployment, is not a legitimate second shape, it is a missing artefact. So a `skill-*` never stands in for its loader in this enumeration. **Scope is the agent scheduled layer and only that** — a cron living inside a delivery repo (a GitHub Actions workflow such as `funding-capture`) is application infrastructure shipped by a delivery ticket, not an agent schedule, so it stays out of this enumeration even where Pass A watches its output; see the registry note.

   **The live-side enumeration source is unreliable — `list_scheduled_tasks` silently omits live, enabled tasks.** The tool has returned an enumeration missing a task that was toggled Active, on a live cadence, with runs visible in its own History panel — no error, just a short list. So *absence from `list_scheduled_tasks` is not evidence a schedule is missing*: it is indistinguishable from a schedule the tool simply didn't return. Treat the list as a floor, not a census. Where the parity check turns on the presence of a specific schedule, corroborate before trusting the absence — cross-check the scheduled-tasks UI by hand, or read a last-run marker on the surface the task writes to — and where corroboration isn't available in the run, downgrade the finding per step 7 rather than asserting a gap the source can't support. (Worked case: `task-aide-loop` absent from `list_scheduled_tasks` on 2026-07-20 and again 2026-07-22 despite being live and having run that morning; the incomplete list also meant the run could not tell whether `task-bottrader-operator-loop` was genuinely unwired or merely hidden the same way — APP-597, APP-648.)

   **The Cloud-Routine enumeration source is `list_triggers` — and it overflows, so read the spool rather than shrinking the page.** The Cowork half of this step has a named tool; the Cloud-Routine half had none, so the pass has been enumerating half its live set with no documented read form. The tool is `list_triggers`, and it is another member of the silent-overflow family `convention-linear` *Reading Linear safely* records and `convention-agent-runtime` *Isolation* extends to sub-agent returns. **Expect the direct call to overflow above roughly 30 schedules.** Every row carries its full prompt, so the payload is large **per row, not per page**: re-fetching at a smaller `limit` trades one overflow for several and still cannot bring the whole fleet into context. When the call errors and spools its payload to a file, **read the spooled file and parse out only the fields this pass needs** — id, name, cron, `enabled`, last run, and the prompt body Pass C reads — rather than re-issuing the call. Where the spool cannot be read or parsed, the enumeration is a floor and not a census, exactly as an incomplete `list_scheduled_tasks` is: downgrade the finding per step 7 rather than asserting a gap the source cannot support. (Worked case: `list_triggers(limit: 100, recurring: true)` errored at 166,494 characters and spooled on 2026-09-10; the spooled file parsed cleanly to 33 triggers — APP-1225.)

   **Wiring is not firing — check both.** A schedule that exists and maps to its artefact has passed only the *wiring* test; it has not been shown to actually *run*. So for every wired schedule, confirm it fired within its cadence window — that its expected output was produced on time — by reading the last-run marker (the surface write, the posted output, or the schedule's own run history) against the cadence. A schedule that is wired and mapped but has gone a full cadence period past its due fire with no run is a distinct gap from a schedule that was never wired at all. **Read `enabled` before the firing test.** `list_scheduled_tasks` returns an explicit `enabled` field per task, and `update_scheduled_task.enabled: false` is the documented pause; a task with `enabled: false` is **paused** — reported as such, with its `lastRunAt`, in its own list — and is neither a skipped fire nor a missing deployment. From the firing fields alone a deliberate pause and a stall are identical (last fire in the past, next run in the past, last status `SUCCEEDED`), which is how a Cowork session filed an Urgent stall bug against `delivery-loop` and `Morning brief` on 2026-09-01 while the Owner had paused the layer for leave, and how a delivery-loop run repeated the same conclusion a day later from a ticket comment without reading the record at all (APP-1065, APP-1074). The field lives in the local store only; a Cloud Routine's pause state is unknown from this surface (see step 7 and APP-837).

   **No visible schedule record is UNKNOWN, not MISSING.** The firing check reads a local schedule record — a last-run marker, a run-history entry. Where that record is simply *unreadable* from the run's surface (the schedule store did not load, the history panel returned nothing, the marker surface was unreachable), the schedule's firing state is **unknown, not missing**: report it as unknown and name what could not be read, exactly as an absence from `list_scheduled_tasks` is a candidate rather than a confirmed gap. Never convert a blind read into a skipped-firing or missing-deployment finding — a false gap raised from an unreadable source is itself friction the operator has to chase down and dismiss.

   **The artefact side takes the same reading — an artefact a pass cannot see is UNKNOWN, not MISSING.** The canon-side enumeration in this step reads the **local skills store** and nothing else. So the rule the schedule side already carries applies in the other direction too: an artefact not found is a floor on what this run could see, not a finding. **State which store the run read**, and report a suspected absence as **unconfirmed** unless the run can name the store it checked and say the artefact was not in it. This direction is the more expensive one to get wrong: an unconfirmed missing-deployment finding costs the operator a UI cross-check, while an unconfirmed missing-artefact finding sends the Pulse drain to author an artefact that already exists. (Worked case: the 2026-09-09 Pass B reported `task-strategy-review` as absent from the skills store; on 2026-09-10 it is present — 16,904 bytes, 129 lines, listed in `manifest.json` — APP-1219.)
7. **Reconcile, both directions.**
   - **Missing deployment** — a canon `task-*`/`routine-*` artefact with *no* live schedule at all. This is the gap that let a saved artefact never actually run (worked case: `task-bara-operator-loop` and `skill-task-health` both existed as canon with no schedule until 2026-07-01). **Because the live-side source is incomplete (step 6), a missing-deployment finding resting only on absence from `list_scheduled_tasks` is a *candidate* gap, not a confirmed one:** file it as needing a manual scheduled-tasks UI cross-check, and say in the flag that the enumeration source may have hidden a live schedule. Only a gap corroborated by the UI (or by no last-run marker ever appearing) is a confirmed missing deployment.
   - **Missing artefact** — a live schedule with no canon `task-*`/`routine-*` behind it. The inverse gap, and the one that blinds this pass to itself: an unenumerable schedule is also absent from the agents site and has nothing for `skill-ops-sync` to diff (worked case: `task-health` and `task-optimisation-review`, 13 of 15 schedules having an artefact and the two that did not being Pulse's own — 2026-07-15, APP-544).
   - **Skipped firing (dormant schedule)** — a schedule that exists and maps to a canon artefact but has *not* fired within its cadence window: its expected output was not produced on time. Distinct from a *missing deployment* (no schedule at all) and from a Pass A behaviour miss (a schedule that fired but produced the wrong or empty output) — here the wiring is present and correct, and the cadence simply did not run when it was due. **Resolve the cadence before filing it:** a schedule that *appears* to have skipped may instead be hand-triggered, with the artefact's cadence line overstating a cadence the schedule never had — in which case the fix is the artefact's cadence claim, not a missing or dormant schedule. Name that as an Owner question rather than asserting a skip (worked case: `task-content-drain`'s weekly cadence appeared to skip on 2026-08-14, and whether it is weekly-scheduled or hand-triggered is the open Owner question — APP-812). And where the firing record was merely unreadable, the state is unknown, not skipped (step 6).
   - **Paused** — a schedule that exists, maps to its artefact, and carries `enabled: false`. Not a gap: report it with its `lastRunAt` and, where the store records one, the reason and expected resume. Where the pause has outlived any stated resume date, name it as an Owner question, never as a stall (APP-1065).
   - **Orphan schedule** — a live scheduled task/routine pointing at a canon artefact that no longer exists (cf. the `skill-delivery-loop` orphan, 2026-06-23). Distinct from *missing artefact*: an orphan is a cleanup proposal, a missing artefact is an authoring one.
   - **Loader drift** — a live config whose loader line does not point at the artefact it claims to run. Note this pass sees only the *mapping*; whether the config is a loader **at all** is Pass C, which reads the body. This clause existed before Pass C did, which is exactly why the drift went uncaught: it describes the finding without any step that opens a config to find it (APP-549).
8. **Flag each gap** — via `skill-issue-capture`, one flag per gap, naming the artefact and the side it is missing from. A missing deployment is a wiring proposal for the operator (the schedule is the operator's to create); a skipped firing is a wiring-and-cadence question for the operator (is the schedule live and firing, or is the artefact's cadence claim the thing that is wrong?); a missing artefact is canon intake for the Pulse drain (`FRICTION:` on `agent:PUL-5E`, since the deliverable is a saved `.skill`); an orphan is a cleanup proposal. Never wire, disable, or edit a schedule — that is the operator's call.

**Named-artefact existence check — assert that every artefact canon names actually exists.** The reconciliation above runs between schedules and artefacts. It never tests the other kind of reference: an artefact that *names* another artefact as an input. So for **every operator profile** — `operator-a1`, `operator-apps`, `operator-bara`, `operator-bottrader`, `operator-mrp` — read its **Mandate** and **State sources** fields and assert that each artefact they name actually exists **and sits on the parent canon names**: a Linear document by title *and* by the surface the naming artefact specifies — an initiative, a project — and a skills-store artefact by directory. The parent is the load-bearing half for a Linear document, because one created on a plausible but wrong parent answers an existence check cleanly while every read keyed on the canon location finds nothing, so the defect surfaces only when a consumer goes quiet. It costs one field on a read this pass already makes. (Worked case: `bottrader.health-digest` is named as a document on the bot.Trader **initiative** in `operator-bottrader` *Surface* and *State sources* and in `task-bottrader-operator-loop` step 1, and was created on the bot.Trader-B **project** on 2026-09-11 by APP-1157 — the ticket whose purpose was to give the publisher a confirmed location to write to — after which APP-1123's acceptance criteria hard-linked the wrong location by URL. The 2026-09-14 operator loop reparented it at no cost only because it was still an empty placeholder; `task-bottrader-watch` reads it by the canon location — APP-1434.) **Report each absence, and each misplacement, naming the profile that names it**, so the finding lands on the artefact carrying the dangling reference rather than on an abstraction. A missing named artefact is an authoring gap — canon intake for the Pulse drain where the deliverable is a saved artefact, an Owner item where it is a business document (step 8's routing) — and is never created from this pass. (Worked cases: on 2026-09-10 a workspace-wide document search for *mandate* returned exactly one document, `tc.mrp-operator-mandate-edge`, and no `<vertical>.mandate` document existed for any vertical, while `skill-operating-loop` step 1, `convention-artefact-format` (*operator*, APP-1064), `operator-bara` (*Mandate*) and `skill-unit-economics` all name it correctly — the names were right and the documents were absent. The same check would have caught the five `.standup` documents that did not exist until 2026-09-09. APP-1211.)

### Pass C — Config parity (does the live config load canon, or copy it)

Pass B checks that a schedule *exists* and *maps* to an artefact. It does not read what the schedule actually runs. This pass does, because the wrapper model in `core-operating-model` (Layer 2) only holds if the config is a loader: **the `task-*` artefact holds the behaviour; the config does nothing but read the artefact and follow it verbatim — the dual-form loader line of `core-operating-model`(*The loader line — one form*): the artefact **by name**, with its`.claude/skills/<artefact>/SKILL.md `path as the fallback, plus the two standing clauses.**** Where a config instead carries a pasted copy of the artefact, it becomes a second source of truth, and every canon save after that paste silently fails to reach the running system. **This pass reads the local store only.** `list_scheduled_tasks` enumerates the Cowork tasks on this machine, each with a `path` to its prompt; it never sees a Cloud Routine config. So a clean Pass C means "no drift in the store I can see", never "no config drift" — cloud-store configs are unassessed, and their absence from the list is not evidence (APP-837). Say which store the result covers.

9. **Read each live config body** — for every live schedule, not only the ones with a registry entry. Classify it:
   - **Loader** — the body is (essentially) the canonical loader line defined in `core-operating-model` (*The loader line — one form*), optionally with its two standing clauses. Green.
   - **Pasted** — the body is a copy of the artefact's content, or its own prose version of the behaviour. **Finding**, regardless of whether it currently agrees with canon: agreement today is not the property being checked, loading-canon is.
   - **Hybrid** — a loader line plus additional inlined instruction. **Finding**, and read the inlined part: additions that *contradict or weaken* canon are the severe case.
   - **Dialect** — a loader that carries no behaviour but does not use the canonical **dual** form: a **path-only** loader, a **name-only** loader, or one omitting the supersedes / stop-if-unreadable clauses. Grade it by the surface it runs on, because the two halves resolve on different surfaces (APP-1101): a path-only loader on a **cloud Cowork task** is not mild — there is no`.claude/skills/ `at that surface's working directory and the run cannot load canon at all, so it is graded **severe**, the same as a missing loader; a name-only loader on a **Cloud Routine** is the same failure in the other direction. A dialect that does resolve on its surface (path-only on a local task or a routine, name-only on any Cowork task) is the mildest finding: it works today and is worth naming because it is not portable across the three surfaces, and a config without the supersedes clause gives a stale-config run no instruction to prefer canon. Since the connector-only layer moved to cloud Cowork tasks on 2026-09-03 (APP-1100), the by-name half is the load-bearing one for most of the live set — the pre-migration reading, which treated by-name as the lesser variant, is inverted on that surface.
10. **For each Pasted or Hybrid config, diff the intent against the live artefact** and grade the finding, so the operator can triage rather than face a flat list:
   - **Severe** — the config **inverts, weakens, or omits** a canon rule (a guardrail dropped, an "always" turned into a "never", a whole pass missing). Name the specific rule and both readings.
   - **Divergent** — canon has moved on and the config has not, without inverting anything.
   - **Drifted-but-equivalent** — a paste that still matches canon's intent. Still a finding: it is one save away from being wrong, and nothing would say so.
11. **Flag** via `skill-issue-capture`, carrying the classification, the grade, and the specific divergences. **Severe and divergent findings keep one flag each** — each carries its own reading of the rule and its own remediation, so it needs a distinct note the operator can triage in isolation. **The drifted-but-equivalent grade is batched into a single consolidated flag per run**, listing every config in that grade rather than opening one note each: it is the mildest finding (a paste that still matches canon's intent — one save from being wrong, but wrong in nothing today), and on an already-overloaded queue N separate low-severity notes crowd out the findings that need attention without adding triage value. This is the producer-side mirror of `skill-ops-retro` step 1d's "drain the mechanical class in bulk" — the same reasoning, applied where the notes are filed rather than where they are drained. Dedupe against any open flag; where a prior run's batch flag is still open, add the newly-drifted configs to it rather than opening a second. **The remediation — rewriting a config to the loader line — is a config action for the operator, on the Cowork / Cloud Routine surface. Name it; never edit a config, and never file it as a canon change.**

**Why this pass has to read bodies, and why nothing else will.** No other check can see this. `skill-ops-sync` audits Claude canon against the claude-ops repo; a Cowork config is neither side of that comparison. Pass A checks output, and a stale config still produces its expected output. Pass B checks existence and mapping, and a pasted config exists and maps. So a drifted config is **green on every other axis while executing wording nobody has read** — it is invisible by construction unless something opens it. That is this pass. (Worked case: 7 of 15 configs pasted and 3 hybrid on 2026-07-15, 6 divergent, 4 severe — `task-coordinate` never sweeping MBN and inverting Pass 2's auto-route rule; `task-daily-report` missing the whole os.Claude canon-sweep exception, which breaks a cross-artefact contract, since `skill-ops-retro` defers a note to Blocked + Urgent *precisely because* "Blocked + Urgent is the signal `task-daily-report` reads" — it never read it, so every canon item surfaced to the Owner was invisible; `task-pulse-retro` missing step 1a and inverting step 4a. The same drift is already the worked case in `core-operating-model` from 2026-06-25, unfixed since — APP-549.)

**A loader that does not resolve is worse than a stale prompt.** Before flagging a pasted config, confirm the loader form actually resolves on that surface — `task-triage`, `task-bara-operator-loop`, `task-strategy-review`, `task-content-drain` and `task-content-review` run as loaders on Cowork, which is the evidence that it does. Where a surface cannot resolve the loader, that is a finding about the *surface*, not the config, and the paste may be a deliberate workaround: say so rather than recommending a rewrite that would break the task.

**Order the remediation so the checker isn't checking from a stale copy.** When several configs need rewriting, the two that run *this* check and *this* drain go last: rewrite `task-health`'s config only once the current version of this skill is saved, and `task-pulse-retro`'s last of all, since it runs the drain that authors the fixes. Rewriting either first means the pass that would catch the rest is itself running from a stale copy.

12. **Report** — a short health summary: behaviour (tasks checked, green, flagged, and which of the three cases each flag is), deployment parity (canon vs live counts, missing deployments — confirmed vs candidate, skipped firings, any firing state left unknown, missing artefacts, orphans), config parity (loader / pasted / hybrid / dialect counts, and each finding by grade — with the drifted-but-equivalent grade as the single batch flag, not one per config), each with its issue link.

## The registry (Pass A)

Maintained here as tasks gain a clear signal — seed set. The **empty-legitimate** column decides which question step 3 asks: *no* means the task's canon guarantees an output every run, so a miss is flagged on sight with no window tolerance; *yes* means the task acts only on input, so the window governs.

| Scheduled task | Expected observable output | Window | Empty legitimate? |
| -- | -- | -- | -- |
| `task-daily-report` | One project status update per started delivery project | per run | **No** — canon guarantees a post every run, including a one-line "nothing moved" note |
| `task-pipeline-sweep` | New Pipeline issues captured from intake, **or** a recorded "no inbound" note | its schedule interval | Yes |
| `task-ops-sync` | A parity report produced (publish tickets raised or an explicit in-sync result) | its schedule interval | Yes |
| `task-pulse-retro` | Friction queue drained — artefacts produced, or an explicit empty-queue result | its schedule interval | Yes |
| `task-a1-operator-loop` | The vertical's weekly headline posted as a status update on its own initiative (`skill-operating-loop` step 7) | weekly | **No** — step 7 guarantees a status update and a deliberate `health` flag every run |
| `task-apps-operator-loop` | As above, on the Apps initiative | weekly | **No** — as above |
| `task-bara-operator-loop` | As above, on the BARA relaunch initiative | weekly | **No** — as above |
| `task-bottrader-operator-loop` | As above, on the bot.Trader initiative | weekly | **No** — as above |
| `task-mrp-operator-loop` | As above, on the Mr Pritchard initiative | weekly | **No** — as above |
| `funding-capture` (bot.Trader, GitHub Actions) | A row appended to `data/funding/financing-history.csv` and `implied-rates-history.csv`, and `DISPERSION.md` regenerated — all committed to `main` | per run (nightly, 22:30 UTC) | **No** — the capture exists because OANDA publishes no archive, so a day not captured is ground truth permanently lost |

Add a row only when a task has an output you can check without ambiguity; leave a task off rather than invent a signal for it. Set **empty legitimate = no** only where the task's own canon says it always produces something — the column records that guarantee, it does not create one.

**The registry is not restricted to the Cowork surface.** A row belongs here when a scheduled producer has an unambiguous output — the surface it runs on does not enter that test, and never did; it was simply unstated while every row happened to be a Cowork task or a Cloud Routine. `funding-capture` is the first row that runs elsewhere: a GitHub Actions cron in the `assoc-one/bot-trader` delivery repo, shipped by APP-747 and on `main` from 2026-08-10. What does change with the surface is **how a run is observed**, so carry the marker with the row:

- **Cowork task / Cloud Routine** — the last-run marker on the surface the task writes to (the Linear write, the posted status, the captured issue).
- **Repo workflow** — the workflow's own run history *and* the commit it makes. Read both: a run present with no commit is *ran and produced nothing*; no run at all is *didn't run*. The two markers are what keep those cases apart here, exactly as step 2 requires.

**A Pass A row does not make a repo workflow a Pass B subject.** Pass B reconciles the *agent* scheduled layer — Cowork tasks and Cloud Routines — against the canon `task-*`/`routine-*` set. A workflow in a delivery repo is application infrastructure shipped by a delivery ticket: it has no canon artefact, it is not meant to have one, and enumerating it as a live schedule would produce a *missing artefact* finding that is wrong in both directions — a canon-intake note for something canon should never hold. Watching a thing's output is not the same as owning its wiring, and only the second is Pass B's.

**`funding-capture` has not yet produced.** At the time this row was written the workflow had zero runs and `data/funding/` held only its `README.md`; the schedule's first fire is 2026-08-10 22:30 UTC, and one manual dispatch plus the two repo secrets are the operator's outstanding setup (APP-747). Until the first successful capture lands, an empty result is a **pending-setup** item, named once for the operator and not re-flagged nightly — the same reading as the Pass B guardrail that a freshly-saved artefact awaiting its first wiring is a wiring flag, not a regression. From the first captured row onward the column governs as written: a miss is flagged on sight, with no window tolerance.

## Guardrails

- **Propose-only** — flag, never restart, never edit a task or its config, never wire, disable, or re-enable a schedule.
- **Clear signals only (Pass A)** — never invent an expected output or chase a task whose success isn't observable.
- **No false alarms, and no waiting out a real miss.** Rule out a legitimate empty *only where the registry says an empty is legitimate*. Where it says otherwise, a run that produced nothing is a finding on the first miss — the empty-legitimate column, not the window, decides. This guardrail exists to stop a false alarm, and must not be read as blanket permission to tolerate a miss the task's canon forbids (APP-545).
- **Pass A's subjects are wider than Pass B's** — the registry admits any scheduled producer with an unambiguous output, whatever surface it runs on, including a repo-side workflow; Pass B reconciles only the agent scheduled layer (Cowork tasks and Cloud Routines) against the canon artefact set. Never let a Pass A row drag a delivery-repo cron into Pass B and file it as a missing artefact — canon is not meant to hold one (APP-769).
- **A missing run and a missing output are different findings** — establish which one you have before flagging, and say which in the flag.
- **Parity both directions (Pass B)** — a canon artefact with no schedule and a schedule with no canon artefact are both findings; a freshly-saved artefact awaiting its first wiring is a missing-deployment flag, not a regression.
- **A wired schedule is not a firing one (Pass B)** — a schedule can exist and map to its artefact yet never fire on its cadence; Pass B confirms firing, not just wiring, by reading the last-run marker against the cadence window. Before filing a skipped fire, resolve whether the cadence is real: an apparent skip on a hand-triggered schedule is the artefact's cadence claim to fix, not a missing or dormant schedule — name it as an Owner question (APP-812).
- **No visible schedule record is unknown, not missing (Pass B)** — where the schedule store or a last-run marker is unreadable from the run's surface, the firing state is *unknown*; report it as unknown and name what could not be read. Never file an unreadable source as a skipped fire or a missing deployment — a false gap from a blind read is friction the operator must chase down and dismiss (APP-812).
- **An overdue next-run is a question, not a finding (Pass B).** On an `enabled` task a past `nextRunAt` is put to the Owner before anything is filed against it; on a task with `enabled: false` it is a pause, reported as such. The rule binds on an **inherited** claim as much as on a direct read — a comment or run report asserting "the loop has stalled" is re-tested against the record before it is repeated, never propagated (two independent sessions reached the same false stall inside 24 hours, one of them without reading the record — APP-1065, APP-1074).
- **The live-side enumeration is incomplete — an absence is a candidate, not a confirmed gap.** `list_scheduled_tasks` silently omits live, enabled tasks (worked case: `task-aide-loop`, absent twice while running — APP-597/APP-648). So a missing-deployment finding drawn only from that list is filed as a *candidate* needing a manual UI cross-check, never asserted as confirmed; and a "nothing orphaned / all wired" all-clear is only as complete as an enumeration source the run has corroborated. Say in the report which side of the parity rests on the unreliable list.
- **A config is a loader, not a copy (Pass C)** — a pasted config is a finding *even when it currently agrees with canon*. The property being checked is whether the task loads canon, not whether it happens to match today; a matching paste is one save away from being wrong with nothing to say so.
- **Config remediation is the operator's, on the config surface** — flag the drift and name the rewrite; never edit a config, and never file a config fix as a canon change. Canon saves via the button; the config is a third surface, neither canon nor repo.
- **Batch the mildest config grade (Pass C)** — severe and divergent config findings keep one flag each, because each needs its own triage and its own rewrite; drifted-but-equivalent findings are consolidated into a single per-run flag listing every config in that grade, so the lowest-severity class does not flood an already-deep queue. It is the producer-side of `skill-ops-retro` step 1d's batch-the-cheap-class rule; add newly-drifted configs to an open batch flag rather than opening a second (APP-719).
- **One flag per gap**, deduped against any existing open flag.

## Setup

- Deployed as a **Cowork scheduled task**, Pulse-owned, via the canon loader artefact `task-health`.
- **Connectors:** Linear, the scheduled-tasks list, plus read access to each checked task's output surface.
- **Cadence:** daily, or aligned with the ops sweep.
- **Loader:** the `task-health` artefact holds the loader; its config reads `Read .claude/skills/task-health/SKILL.md and follow it verbatim.`

On finish, run skill-ops-retro capture on this run's friction: **search the Pulse queue first and add the evidence to a same-root note if one exists, otherwise file a new FRICTION note** for the drain pass to assess, in capture step 3's literal shape — team Apps, project os.Claude, `FRICTION:` title, labels `task` + `work:configuration` + `PUL-5E`, Backlog, unassigned — filing the friction, never the run report.
