build-observability

Normalize agentic execution into runs, events, and commands for operator dashboards.

Updated Apr 20, 2026
One-click install
npx skills add https://github.com/thistleknot/skills --skill build-observability
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: build-observability
Source: https://github.com/thistleknot/skills/tree/main/build-observability
Command: npx skills add https://github.com/thistleknot/skills --skill build-observability

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Build observability for agentic systems is often missing at the exact moment operators need it most, leaving you with only raw logs and no reliable way to answer what is running, what changed, what artifacts exist, and how the run ended.

Core Features & Use Cases

  • Normalized runs/events/commands contract: Projects long-running execution into stable, query-friendly tables for run status, timeline facts, and command lifecycles.
  • Operator-focused dashboard surface: Exposes current stage, major event timeline, command activity, changed files, artifacts, sub-agent hierarchy, and deploy outcomes.
  • Runtime collector projection pattern: Adapts local agent runtime artifacts (files, transcripts, logs, session metadata) into the canonical schema without hard-coding foreign layouts.
  • Trace enrichment for memory/decision layers: Adds decision context so observability can become episodic inputs for memory and context-graph systems.
  • Storage policy for local-first and shared access: Defaults to SQLite for local harnesses and uses Postgres when shared/remote readers are needed.

Quick Start

Use the build-observability skill to instrument your agent runtime by projecting its session/transcript artifacts into the normalized runs/events/commands schema and wiring the dashboard to those projections.

Frequently Asked Questions about build-observability

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I build observability dashboards for long-running agentic coding tasks?

Build observability for agentic coding by projecting runtime session artifacts into normalized runs, events, and commands tables. This creates stable, query-friendly schemas that power operator-ready dashboards showing current stage, timeline, and command lifecycle.

What is trace enrichment for agent observability and when do I need it?

Trace enrichment for agent observability adds decision context to normalized execution events. You need it when transforming raw run tracking data into episodic inputs for memory and context-graph systems, ensuring observability captures why decisions were made, not just what executed.

Can I use SQLite for local agent run tracking and switch to Postgres for shared access?

Yes, this observability approach defaults to SQLite for local harnesses and supports optional Postgres for shared or remote readers. The storage policy enables local-first run tracking with seamless escalation to shared dashboard access when multiple operators need visibility.

How do I normalize agent runtime logs and transcripts into queryable dashboard data?

Normalize agent runtime logs by applying a collector adapter pattern that maps local session transcripts, files, and metadata into a canonical runs, events, and commands schema. This avoids hard-coding foreign layouts while projecting artifacts into query-friendly dashboard tables.

What's the best way to track file changes and command lifecycles across multi-stage agent runs?

Track file changes and command lifecycles by projecting multi-stage agent execution into normalized tables that capture command activity, changed files, artifacts, and deploy outcomes. This provides operator-focused dashboard visibility without parsing raw logs manually.

Do I need a runtime collector adapter to instrument my agent for observability dashboards?

Yes, a runtime collector adapter is required to adapt your specific agent runtime artifacts into the normalized schema. It bridges local session formats and the canonical runs, events, and commands projections needed for operator-ready dashboard visibility.