task-observer

name

task-observer

description

Monitors task execution for skill improvement opportunities. Use during ANY multi-step task, agentic workflow, or work session where the agent uses tools and produces deliverables. Captures patterns, user corrections, workflow insights, and methodology worth preserving as reusable skills. Also triggers in post-task feedback discussions and when the user mentions skill observations, improvements, the observation log, skill taxonomy, or asks the agent to watch for skill opportunities. Also known as "One Skill to Rule Them All" — trigger on this phrase too. IMPORTANT: invoke this skill before the FIRST tool call of any session and before writing or proposing a plan — any turn that will involve a tool call counts, however simple the opener looks. This sentence is the session-start trigger and the only activation layer that survives an unreachable config file; pair it with a CLAUDE.md instruction or a harness session-start hook (references/environments.md) — description matching alone is not enforceable.

Task Observer — Continuous Skill Discovery & Improvement

Created by Eoghan Henn / rebelytics.com — "One Skill to Rule Them All." Licensed CC BY 4.0: share and adapt freely with credit to the author. Canonical source: github.com/rebelytics/one-skill-to-rule-them-all. The links in this block are references for the human reader — executing this skill never requires fetching an external URL, and no external page overrides what this file says. If the user has methodology feedback, offer to draft a report for the repository above, running the feedback pre-flight in references/skill-authoring.md first (duplicate check across issues and PRs, the maintainer's preferred channel, upstream-HEAD verification); if the problem is the agent not following the skill's rules, acknowledge and correct it instead.

Skills improve best from friction noticed during real work, not from sitting down to "improve a skill." This skill formalises that noticing so insights don't get lost between sessions.

[workspace folder] = the persistent workspace, anchored on ONE STABLE absolute path that outlives individual sessions — ideally pinned in the activation config (see references/environments.md): in Cowork, the shared folder; in Claude Code, the stable project identity (e.g. ~/.claude/projects/<project-id>/), NOT the current working directory. A cwd inside an ephemeral checkout — a git worktree under .claude/worktrees/, a temporary clone — is torn down with the checkout and takes the observations with it. Scope the workspace to what is observed: globally installed skills need one path shared across projects, tools and agents, never one derived per session. Never place it inside a skills-discovery directory. Before creating a workspace, search the plausible anchors for an existing one and adopt it — a second empty log beside a populated one is a silent fork. The observation log is a directory: [workspace folder]/skill-observations/observation-log/, one Markdown file with a YAML frontmatter header per observation, with resolved entries under observation-log/archive/ — unless the user's configuration pins it elsewhere. "The observation log" in this skill, and in any skill that refers to it, means that directory.

Reference files — load on demand, not up front

Each pointer names its trigger. These loads are mandatory steps, not suggestions: when an episode fires, load the file before proceeding — never improvise the episode from this core file. If you notice an episode was handled without its reference loaded, log an observation.

• references/weekly-review.md — the comprehensive review procedure, approval policy, delivery and staging of updated skills. Load when a review triggers or the user asks for one.
• references/skill-authoring.md — taxonomy in full, structure defaults, licensing, attribution, confidentiality layers, live-file editing and relocation-verification rules. Load before creating or editing any skill.
• references/observation-log.md — storage layout, frontmatter fields, helper snippets, archival details, and the reasoning behind the rules. Load when setting up the log for the first time, when archiving, when an id or frontmatter looks wrong, or before changing how anything reads the log.
• references/signals.md — the full catalogue of what is and isn't worth logging. Load when unsure whether something is an observation, or when sorting many candidates.
• references/environments.md — activation and config setup, compaction behaviour, bundle manifest, handoff-doc mode for storage-less environments. Load for setup questions, after compaction, or when there is no filesystem.
• references/migration.md — the one-time scripted conversion of a pre-3.0 single-file log.md. Load only when the Session Start Protocol detects a legacy log. Fresh installs never read it.

Session Start Protocol

1. Storage. If skill-observations/observation-log/ (with its archive/ subdirectory) or skill-observations/cross-cutting-principles.md don't exist, create them (principles template: references/skill-authoring.md). Create skill-observations/last-review-date.txt containing the literal value never if it doesn't exist — never write a date into it at setup; a date means a review actually ran. If a legacy single-file skill-observations/log.md exists and observation-log/ does not, this is an upgrade from a pre-3.0 install: load references/migration.md and run the scripted conversion before writing anything else. Before creating or writing anything: if the resolved workspace folder sits under an ephemeral path (e.g. .claude/worktrees/, a temporary clone), warn the user and re-anchor on the stable project path first — state written to an ephemeral checkout is lost at teardown.

2. Scan. Read only the frontmatter of each file in observation-log/ — the header block between the first two --- lines, never the bodies — and build awareness from status, skill, proposes_skill and title; also read the active principles. Hold them in awareness, don't surface unprompted. Frontmatter-only is the whole point of the per-file format: the scan stays cheap once hundreds of observations exist.

   An empty scan in a log known to be non-empty is a broken command until proven otherwise, never the finding "no relevant observations". Count the files independently of the parse — a literal path, not the variable the loop uses — and halt if files exist but nothing parsed. Re-derive every path inside the same tool call: shell state does not carry between calls in most harnesses, and a path variable that silently resolves to empty turns a filter into a match-nothing glob rather than an error.

   d=skill-observations/observation-log                                # re-derive in EVERY call
   n=$(ls skill-observations/observation-log/*.md 2>/dev/null | wc -l) # literal path: independent of $d
   parsed=0
   for f in "$d"/*.md; do
     [ -e  ] || 
     hdr=$(awk  )
     [ -n  ] && parsed=$(( parsed +  ))
       
   
   [  -gt 0 ] && [  -eq 0 ] && \
     {  ;  1; }
   

When to Observe

Active for the entire task session — execution, post-task feedback, review discussion, meta-discussion about skills or methodology, and strategy conversations about how work should be done. The observation mindset does not deactivate when the conversation shifts from doing the work to discussing it; review-phase feedback is often the highest-signal input. Inactive only for casual conversation and quick factual questions with no tools or deliverables involved.

What to Watch For

New skill: a reusable multi-step workflow, a methodology the user explains that no skill captures, a recurring task type, a process the user describes as "I always do it this way". Improve a skill: the agent violates a documented rule (the skill needs enforcement, not louder rules); a user correction reveals a missing rule or edge case; a better workflow or technique emerges than the skill recommends; a wrong assumption; new tooling obsoletes a step; a principle that applies to other skills too. Simplify a skill: a section never relevant across many sessions, a rule from a single unvalidated observation, contradictory rules, a rule the agent consistently fails to follow — convert to structural enforcement or remove. Full catalogue with examples: references/signals.md.

Do NOT log: one-off corrections that don't generalise; preferences already captured in a skill; tool bugs unrelated to methodology; observations that would need proprietary client information to be useful in an open-source skill (unless an internal skill is the right home). The generalisability test, when unsure: would this still make sense in another project, and for another task using the same skill? Does it name a missing rule, step or principle rather than fix this task? Is it likely to recur? Mostly no → task context, not an observation. Before minting a proposes_skill name, check the existing candidates and reuse a fitting one — independently logged proposals for one skill rarely share a name.

Validate the target at write time. A name in skill: must be a skill that exists now; if it doesn't, the observation proposes a skill instead. Checking is cheap at write time and expensive forty entries later.

Check the target's siblings at write time, and record that you did. Libraries accumulate families — several skills implementing one methodology for different tools, one structure for different subjects, one companion pattern for different base skills. An insight found while using one member usually applies to the rest, but nothing in the workflow asks, so skill: collapses to a single entry and the family silently diverges. Before writing, resolve the target against the family registry (skill-observations/skill-families.md; spec, coherence models and the no-registry fallback in references/observation-log.md), and for each sibling either add it to skill: or state in the body why it does not apply. Fast test: could this sentence survive having the tool's or subject's name removed? If yes it belongs to every sibling — and a rule that declares itself generic inside one artefact ("this applies to any file-writing script, not just X") is the cheapest possible propagation signal, so treat that phrasing as an automatic multi-skill flag. Then record the outcome in the mandatory siblings_checked: frontmatter field, including the verdict "checked — instance-specific, no propagation": a one-entry skill: list is byte-identical whether the siblings were evaluated or never considered, and only the recorded field makes the absence of the judgement visible to a review or a drift audit.

How to Log

Write the observation file silently, within the same turn or the next — never batch mentally for later; the act of writing is the enforcement mechanism.

Mandatory checkpoint after every 3rd completed todo item. After marking the 3rd, 6th, 9th (etc.) item complete, you must write to disk — not merely ask yourself whether anything is pending. Either write any pending observation files, or, if genuinely none have accumulated, append a one-line no observations acknowledgement to skill-observations/checkpoints.log. The required action is a concrete write; a remembered "ask whether" is not enforcement. The count need not be precise; roughly every third completion is the rule. (Exception: where the workspace is a shared hosted document store in which every write is priced and invalidates other sessions' context, suppress the empty marker and keep only the check — see references/environments.md.)

A denied or failed write is not a read-only log. Retry once before concluding the workspace is unwritable, and try a second tool that reaches the same path — a permission classifier can deny one interface while allowing another, and consecutive denials from a probabilistic gatekeeper are noise, not a wall. Report "failed N times", never "cannot be done", unless retries and alternate interfaces are actually exhausted; otherwise observations are silently lost for the rest of the session.

Deliverable-event flush. Whenever you present or render a major deliverable — a file handed to the user, a deck or PDF render, a staged skill file — or complete a task/todo batch, write any pending observation files at that moment, before moving on. These checkpoints already involve a tool call; piggy-backing the flush onto them makes the write a side effect of work you were doing anyway. (Why both checkpoints are writes rather than questions: references/observation-log.md.)

Two gaps this pairing still leaves — both observed across full working days in which nothing was logged at all.

1. A session can contain no todo items whatsoever. The 3rd-completion checkpoint is bound to ONE tool; work driven entirely through direct tool calls and shell commands never trips it. It is armed only in sessions that happen to use todos, so it is not a safety net that is always present. When a session runs without them, the deliverable flush is the only enforcement left and must be applied deliberately.
2. "Is this a major deliverable?" is a self-assessment, and self-assessment is what fails under load. Prefer triggers unmistakable in the tool record over ones needing a judgement call. In particular, treat any project-completing command — a deploy, release, publish, or push — as a flush point: it is a concrete tool call, as hard a trigger as a completed todo, and it reliably marks the end of a unit of work where insights have accumulated.

The rule behind both: an enforcement trigger must hang on an event objectively visible in the tool record, never on the agent noticing that a moment qualifies. And a counter bound to a single tool is silently inert in every session that does not use it — such triggers always need a second, independent path.

Id and filename. Each observation is NNNN-short-slug.md (zero-padded id + a kebab-case slug from the title). The id is the highest of three values, plus one: the highest numeric prefix in observation-log/, the highest in observation-log/archive/, and the number in observation-log/archive/.id-floor (the highest id ever issued — update it whenever you issue an id above it, so the counter can never restart from 1 when the active directory is empty):

d=skill-observations/observation-log
hi=$( { ls "$d" "$d/archive" 2>/dev/null | grep -oE '^[0-9]+'; cat "$d/archive/.id-floor" 2>/dev/null; } \
     | sort -n | tail -1); : "${hi:=0}"
[ "$hi" -eq 0 ] && [ -n "$(ls "$d"/*.md 2>/dev/null)" ] && { echo "ID COMMAND BROKEN — log is non-empty but no ids extracted"; exit 1; }
next_id=$(( hi + 1 )); echo "$next_id" > "$d/archive/.id-floor"

The guard line distinguishes "the log says zero" from "I could not read the log": a command that fails to empty rather than to error would otherwise propose id 1 in a populated log. A new file never touches another entry's bytes, so it cannot truncate, overwrite or renumber anyone else's work. If two parallel sessions pick the same id, two files share a number — harmless; the next review renumbers one and logs a meta-observation.

Batch writes: resolve each id at its own write time. When logging more than one observation in a session that may overlap a scheduled review or another writer, run the id snippet before EACH file — never pre-compute a range and hardcode sequential numbers into a batch. A batch append is N separate races, not one; pre-baked numbers collapse N independent max-checks into a single stale read (observed: a hardcoded id collided with one a parallel review issued between the check and the write).

A structural probe that comes back empty where content existed before is a stop signal, not a create. If the directory or file you logged to earlier in the session is suddenly missing, or the id check returns empty in a log you know is populated, HALT and re-probe the structure (is there an observation-log/? a log.md.migrated?) — a parallel session may have migrated or reorganised the storage. Never let an append silently recreate a missing target: that converts a migration signal into corruption (observed: a stale session recreated the retired log.md with a fresh "Observation 1" after the per-file migration renamed it).

File format. YAML frontmatter (the metadata every scan reads) followed by the Issue → Improvement → Principle body. The frontmatter is mandatory; always write status: open and a non-empty siblings_checked: at creation time — an observation without a status field is treated as OPEN by reviews, never as nonexistent, and one without siblings_checked: counts as logged without a sibling check.

---
id: [N]
title: [Short descriptive title]
status: open            # open | actioned | declined | superseded | parked
type: open-source       # open-source | internal
skill: [list of existing skills this improves — always a list, even with
       one entry; first entry is primary; may be empty]
proposes_skill: [list of new skills this argues for, by working name;
       may be empty — an observation can fill either list or both]
siblings_checked: [MANDATORY, never blank: the family name and the members
       evaluated, plus the verdict — e.g. "family-name: a, b — shared, both
       added" or "family-name: a, b — instance-specific, no propagation";
       the literal `none` only where the target belongs to no family]
area: [which part of the skill or workflow]
date: [YYYY-MM-DD]
session_context: [what task was being worked on]
parked_until:           # MANDATORY when status is parked, empty otherwise:
                        #   one line naming the condition that unparks it
resolved:               # date resolved; leave empty while OPEN
resolution:             # what was done — set only when actioned/declined
reference:              # optional: path to saved session-local evidence
---

**Issue:** [What happened — specific enough to understand weeks later
without the original conversation.]

**Suggested improvement:** [Concrete change. For existing skills, name the
section or rule; for new skills, scope and key components.]

**Principle:** [The generalisable takeaway — the most important field.]

parked means decided, not pending. Use it when an observation is sound but cannot be acted on until an external precondition is met — the scheduled task that produced it is disabled, the tool it describes is out of use, a dependency has not landed. A parked entry is OUT of the work queue: reviews must not re-escalate it, and the decision belongs in status:, not in a free-text note beside a status: open (a note nothing classifies on leaves the entry in the queue and it gets re-raised at every review). It is not resolved either, so it never archives — archival needs a resolved status plus a resolved: date. It stays in observation-log/ indefinitely until either its parked_until: condition is met — set it back to open and queue it — or it is genuinely resolved. parked_until: is mandatory whenever status is parked: one line stating the condition, phrased so a later session can actually answer whether it has happened.

Context preservation: if an observation depends on session-local data (uploads, API output), save that context into the workspace first and set reference: to its path — an observation whose evidence dies with the session is incomplete.

Confidentiality at logging time: for type: open-source observations, the Issue/Improvement fields may reference specifics for context, but the Principle must be fully generalised — no client names, domains, or details traceable to a real project. Full confidentiality layers: references/skill-authoring.md.

Changing an existing observation: re-read that one file, edit only the frontmatter fields you are changing (status, parked_until, resolved, resolution), never batch-rewrite the directory. Archival is a plain mv (below).

Referencing Observations

Cite an observation by the id field in its frontmatter (= the NNNN- filename prefix). Never cite a grep -n line number as if it were the id — search-tool line numbers are positional metadata, not identifiers. A cited id must fall within the range that exists across observation-log/, archive/ and .id-floor; a number far outside it is almost certainly a line number misread as an id.

Taxonomy (quick version)

Open-source — client-agnostic, methodology-driven, useful to other practitioners. Internal — contains user/client/project specifics or personal preferences. Default to open-source when it could go either way, stripping specifics. The boundary is also a confidentiality boundary, and the two errors are not symmetric: over-classifying as internal costs only reach, under-classifying can leak — when genuinely uncertain, prefer internal and promote later. Full requirements (attribution, licensing, structure): references/skill-authoring.md.

Archival on Write

On every write, first mv already-resolved files from observation-log/ to observation-log/archive/. "Already resolved" is read from the file's own frontmatter: status: actioned, declined or superseded AND a resolved: date before today. Files resolved today stay until the next day, whichever session resolved them — the grace period lives in the file, never in session memory. A resolved file with no readable resolved: date gets today's date written to that field instead of being archived. One file per mv; no rewrite of anything else. Helper and rationale: references/observation-log.md.

Surfacing Protocol

Default: at end of session, as a grouped summary — improvements grouped by skill, new-skill candidates listed separately; for each, one sentence plus suggested type; ask which to act on. Surface earlier when an observation needs user input to be complete, when a skill is actively producing wrong output, or when observations cluster on one skill.

Deferral wears a second disguise: not a promise, but an argument. "Let's wait until this has seen a few days of real use", "we should gather more data first" — this reads as diligence, which is exactly why it goes unchallenged, including by the person saying it. It is not an announcement, so a rule about executing rather than announcing does not catch it. So before writing any "later" into a recommendation, name two things: which specific observation would change the decision, and when it could realistically arrive. If you cannot name one, the evidence is either already conclusive (act now) or waiting adds nothing (act now). Then ask what the delay costs — if a known-defective state stays live meanwhile, the burden of proof is on deferring, not on acting. A deferral is a decision and needs the same justification as acting; "more evidence would be better" is not one, because the question is whether more evidence could change the OUTCOME.

Default to log-and-defer. Surfacing an observation is not an invitation to act on it: state that it is logged for the next review, and stop. Reserve in-session application strictly for the triggers under "Acting on Observations". Do NOT routinely offer a binary "apply now vs leave for next review" choice; for users who run regular reviews that offer is unwanted friction, and if a user has said they always defer, suppress it entirely.

Self-check before surfacing: observations were logged throughout the whole session (including discussion phases); logged silently; each follows Issue → Improvement → Principle; each is typed; existing-skill items name the section; no open-source Principle contains client-identifying info; every observation file carries status: (status: open at write time) and a non-empty siblings_checked: — if any lacks one, do the sibling check now and record it rather than back-filling the field with none.

Acting on Observations

Act only in three contexts: (1) the comprehensive review (load references/weekly-review.md); (2) an explicit user request ("update X skill", "act on observation #N"); (3) in-session correction when a skill is producing wrong output the user should know about. Otherwise: log, don't act.

Read the full body before resolving, dismissing, fixing, or citing. A tracked item's title (observation, GitHub issue, ticket) is an index entry, not its content — it compresses away the failure story, the reporter's context, and often the proposed fix. Dismissal is the path with no downstream checkpoint: a resolved or cited item gets reviewed later, a dismissed one silently disappears. Harvest fix designs from issue bodies — reporters frequently include the correct solution, which also settles attribution. When a parallel agent logs a finding that appears to duplicate your own, diff the two bodies, not the titles: two entries about the same mechanism can carry opposite operational conclusions, and the second is often the refinement, not the echo. Apparent agreement suppresses verification more effectively than disagreement does, so this rule binds hardest exactly where it feels least necessary.

When acting: small, clearly-additive, low-risk changes (a new rule, a clarification, a factual fix) may be applied without waiting for the next review — "directly" means now, not in place: the edit is still made on a staged copy based on a fresh read of the live file and handed to the user to install, in every environment and every context. Staging-only has no interactive exception; an exception the user has to remember is a gate that eventually gets left open. Substantial changes (restructuring, new capabilities, changed methodology) and all new-skill creation: load references/skill-authoring.md first and follow its editing and staging rules. A principle that applies to skills generally goes to the cross-cutting principles file (same reference).

Set the status in the same turn you act. An observation acted on in-session must have its frontmatter updated — status: actioned, resolved: YYYY-MM-DD, resolution: what was done — before the turn ends. The work and the bookkeeping are two acts, and the second is the one that gets dropped; a stale open entry then invites redoing finished work over a section that has since moved on. The write is the enforcement, exactly as it is for logging.

Quick Reference

Question	Answer
When do I observe?	The whole session, including feedback and reflection phases
How do I log?	Silently, immediately, as one file per observation named NNNN-slug.md; id = max(active, archive, .id-floor) + 1
When do I surface?	End of session, or earlier if needed
Status field?	Mandatory status: open frontmatter on every new observation; reviews treat a missing status as OPEN, never as nonexistent. Five values: open, actioned, declined, superseded, parked — parked = decided but blocked on an external precondition, so it leaves the queue, requires parked_until:, and never archives
Does the target skill have siblings?	Resolve it against skill-observations/skill-families.md BEFORE writing; add every sibling the insight applies to to skill:, and record the verdict in the mandatory siblings_checked: field — including "checked, no propagation"
A scan or query came back empty?	Two possibilities, only one is a finding: guard every retrieval meant to prevent duplicate work with an independent existence check, and treat empty output over known content as a broken command
Citing an observation number?	From the id: frontmatter field (= the NNNN- filename prefix); never a grep -n line number; sanity-check against the known id range
Open-source or internal?	Default open-source; the boundary is confidential
Small fix or substantial?	Additive → apply directly; restructuring/new skill → references/skill-authoring.md
Changing an observation (status/archival)?	Re-read that one file, edit only its frontmatter, or mv it to observation-log/archive/ — no shared-file rewrite
Upgrading from a single-file log.md?	Scripted, once — references/migration.md
Weekly review?	Trigger check at session start; procedure in