hoangsonww
- 285 skills
- 0 followers
- 1.2k repo stars
- last month last updated
- ▌ Custom Brief · hoangsonwwDeep-research a specific topic and produce a comprehensive news-focused briefing with optional Notion/Obsidian/Teams/Slack publishing
- ▌ Eval Backfill · hoangsonwwRun the eval harness against every card under example-cards/ in parallel and persist scores to eval/store.sqlite. Use when the user asks to "backfill", "score everything", or "score all cards" for quality eval.
- ▌
- ▌ Daily Briefing · hoangsonwwSearch for today's latest AI news and create/update a comprehensive briefing in Notion, with optional Obsidian vault publishing for graph visualization
- ▌ Eval Dashboard · hoangsonwwBuild the interactive offline eval dashboard (eval/dashboard/index.html) — Chart.js trend, axis radar, composite histogram, per-card stacked bars, sortable card table. Use when the user wants to "see eval results", "open dashboard", "visualize quality", or "compare cards".
- ▌ Eval Regression · hoangsonwwRe-judge every pinned golden card in eval/golden/ and fail if any composite has dropped more than 0.5 points vs its baseline. Use when the user asks to "run regression", "check golden set", or wants CI-style quality gating after a prompt or judge change.
- ▌
- ▌ Analyze Earnings · hoangsonwwSynthesizes a comprehensive financial briefing on a public company using recent earnings calls, SEC filings, and financial news.
- ▌ Analyze Competitors · hoangsonwwConducts deep competitive intelligence on a target product or company, mapping out rivals, feature gaps, and market sentiment.
- ▌ Summarize Podcast · hoangsonwwExtracts transcripts from podcasts or videos and synthesizes actionable takeaways.
- ▌ Plan · hoangsonwwStart a new Flywheel planning round. Produce initial markdown plan, route to competing frontier models, synthesize hybrid, refine 4–5×. Use before any coding begins on a new feature.
- ▌ Verify · hoangsonwwRun Forge's canonical verification chain (format:check + lint + typecheck + build + test). Use before claiming any task done or opening a PR.
- ▌ Landing · hoangsonwwEnd-of-session ritual. Close finished beads, file new ones for remaining work, run verify, commit in logical groupings, push. Work is not complete until git push succeeds.
- ▌ Add Tool · hoangsonwwScaffold a new Forge tool — implementation, registration, permission/risk metadata, sandbox routing, and a unit test. Use when adding anything to src/tools/.
- ▌ Flywheel · hoangsonwwOverview of Forge's Agentic Coding Flywheel methodology. Use to route between plan, bead, and code space. See FLYWHEEL.md at the repo root.
- ▌ Add Agent · hoangsonwwScaffold a new Forge subagent (planner/architect/executor/reviewer/debugger/memory-style).
- ▌ De Slopify · hoangsonwwRemove AI-writing tells from README, docs, and user-facing text. Must be done line-by-line, no regex. Use after agents write any user-visible prose.
- ▌ Debug Loop · hoangsonwwSystematic debugging playbook for the Forge agentic loop (src/core/loop.ts and src/agents/executor.ts). Use when a task is stuck, looping, or emitting wrong tool calls.
- ▌ Fresh Eyes · hoangsonwwReset review context when bead polishing or code review has flatlined. Requires starting a brand-new Claude / Codex session. Use when you're seeing the same small edits round after round.
- ▌ Deep Review · hoangsonwwDeep review — random exploration + cross-agent review, alternating. Finds integration bugs that self-review misses. Run every 30–60 min during active implementation.
- ▌ Idea Wizard · hoangsonww30 → 5 → 15 funnel for brainstorming new features on the existing Forge codebase. Use when adding capability to a mature install, not for greenfield.
- ▌ Polish Beads · hoangsonwwPolishing pass over all open beads. Run 4–6 times. "Check your beads N times, implement once." Use after plan-to-beads and between refinement rounds.
- ▌ Add Provider · hoangsonwwScaffold a new model provider for Forge — class, registry wiring, providerEnum entry, local-catalog classification, router check, and a unit test with mocked transport.
- ▌ Dedupe Beads · hoangsonwwMerge duplicate or excessively overlapping beads in .beads/beads.jsonl into canonical ones. Run after any batch where 20+ new beads were created.
- ▌ Plan To Beads · hoangsonwwTranslate a polished markdown plan into self-contained beads in .beads/beads.jsonl. Every bead must be executable without reopening the plan. Use after the plan has converged.
- ▌ Reality Check · hoangsonwwBreak the spell of local productivity. Ask whether completing all open beads actually closes the gap to the project goal. Use at milestones or when busy agents feel directionally off.
- ▌ Release Check · hoangsonwwPre-release checklist for Forge — verify, version bump, changelog, docs, docker build, smoke test. Run before tagging v*.
- ▌ Plan Synthesize · hoangsonwwSynthesize competing plans from multiple frontier models into a single best-of-all-worlds hybrid. Use after /plan has produced 2+ competing plans in .flywheel/plans/.
- ▌ Delegation Audit · hoangsonww bundleAudit model delegation and subagent effectiveness for a session — which models handled which subagent types, per-type success rates and average durations, and wasted delegations (heavy models on trivial work or types that consistently fail) — using the Agent Monitor workflow intelligence API. Use when reviewing how a session delegated work across models and subagents.
- ▌ Monthly Review · hoangsonww bundleCompile a month-over-month retrospective from Agent Monitor data — sessions, cost, token volumes, completion rate, top projects by working directory, and notable shifts versus the prior month. Uses daily_sessions/daily_events (365d) from analytics, the session list, and the pricing cost breakdown. Use when doing a monthly retrospective or planning the month ahead.
- ▌ Sprint Summary · hoangsonww bundleSummarize a sprint's worth of Claude Code activity — sessions grouped by project (cwd), per-model cost breakdown, token efficiency (cache hit rate, compaction baselines), subagent effectiveness from workflow API, velocity metrics (turn_count, turn_duration_ms), and tool diversity across the sprint.
- ▌ Error Propagation · hoangsonww bundleTrace error propagation through a multi-agent session by agent depth — where failures originated, the depth at which they appeared, and how they cascaded up to parent agents — using the Agent Monitor workflow intelligence API and the session event stream. Use when a multi-agent run failed and you need to find the origin and blast radius of the failure.
- ▌ Productivity Score · hoangsonww bundleCalculate a productivity score using actual Agent Monitor metrics — session completion rates, cache efficiency (cache_read vs input), compaction pressure (baseline tokens), turn velocity (turn_count / total_turn_duration_ms), tool success ratio (PreToolUse vs PostToolUse), and the workflow intelligence API's complexity and effectiveness scores.
- ▌ Concurrency Report · hoangsonww bundleReport concurrency and parallelism for a session — how many agents ran in parallel, concurrency-lane utilization, peak parallel width, and serialization bottlenecks (sequential chains that could have run as parallel lanes) — using the Agent Monitor workflow intelligence API. Use when checking whether a multi-agent session used parallelism efficiently.
- ▌ Daily Budget Check · hoangsonww bundleRun a daily spend check-in against a daily budget on the Agent Monitor dashboard — today's spend vs the daily target, pace through the day, and the projected overage if the current pace holds. Uses /api/pricing/cost and /api/sessions (grouped by started_at = today). Use for a quick daily spend check-in or a morning/evening budget pulse.
- ▌ Optimization Suggest · hoangsonww bundleSuggest concrete optimizations for Claude Code usage based on historical session data. Covers cost reduction, speed improvement, error prevention, and workflow efficiency. Use for data-driven optimization planning.
- ▌ Workflow Optimizer · hoangsonww bundleAnalyze workflow patterns using the Agent Monitor's workflow intelligence API — orchestration DAGs, tool flow transitions, subagent effectiveness, model delegation patterns, error propagation by depth, concurrency lanes, compaction impact, and agent co-occurrence. Produces prioritized optimization recommendations with quantified impact.
- ▌ Fleet Runs · hoangsonww bundleSummarize Workflow-tool fleet runs from the Agent Monitor — these fleets emit no hooks and are ingested from on-disk run journals. List recent runs with status and agents-per-run, then drill into a single run's per-agent detail. Reconciles against the live run-state endpoints. Use when reviewing Workflow() fleets rather than hook-instrumented interactive sessions.
- ▌ Hook Inventory · hoangsonww bundleInventory hooks across the user, project, and project-local settings plus the ~/.claude/hooks scripts directory — read through the Agent Monitor Config Explorer API — and flag hooks that POST to the network or run arbitrary commands. Reads /api/cc-config/hooks and /api/cc-config/hook-scripts. Use when auditing hook safety.
- ▌ Budget Set · hoangsonww bundleDefine a spend budget for Claude Code and, optionally, create a cost alert rule that fires when usage crosses the limit, via POST /api/alerts/rules on the Agent Monitor dashboard. Reads current spend from /api/pricing/cost to size the budget sensibly and explains every rule field before writing. Use when setting a spend limit or wiring up a budget guardrail.
- ▌ Cost Alert · hoangsonww bundleReview the configured cost alert rules and the alerts currently fired on the Agent Monitor dashboard, then explain exactly what tripped and why. Uses /api/alerts (fired feed) and /api/alerts/rules (definitions). Use when checking spend alerts or asking why a cost alarm went off.
- ▌ Quick Stats · hoangsonww bundleOne-line summary of key Agent Monitor metrics — active sessions, total cost from the pricing engine, events today from daily_events, top tool from tool_usage, and current model from the most recent session. Use for a fast at-a-glance check without leaving the terminal.
- ▌ Health Check · hoangsonww bundleRun comprehensive health checks on the Claude Code Agent Monitor system. Validates dashboard API, database, WebSocket, hooks, and disk usage. Use to verify the monitoring setup is working correctly.
- ▌ Usage Trends · hoangsonww bundleAnalyze Claude Code usage trends over time using the Agent Monitor's analytics API — daily session counts, daily event counts, token volumes by type, model distribution, tool usage rankings, and agent/event type distributions across 365-day retention windows.
- ▌ Skill Inventory · hoangsonww bundleInventory the installed skills and which plugins contribute them, then flag overlap with the user's own skills — read through the Agent Monitor Config Explorer API. Reads /api/cc-config/skills and /api/cc-config/plugins. Use when managing skills: deduping, deciding what to keep, or tracing a skill back to the plugin that ships it.
- ▌ Session Debug · hoangsonww bundleDebug a specific session by inspecting its full event chain (PreToolUse, PostToolUse, Stop, SubagentStop, Compaction, APIError, TurnDuration, Notification events), agent hierarchy (recursive parent/child tree with subagent_type and depth), token usage with compaction baselines, workflow intelligence data (orchestration DAG, error propagation by depth), and session metadata (thinking_blocks, turn_count, total_turn_duration_ms).
- ▌ Anomaly Alert · hoangsonww bundleIdentify anomalous sessions using Agent Monitor data — cost outliers from the pricing engine, token anomalies (cache miss spikes, compaction baseline surges), unusual event type ratios (PreToolUse/PostToolUse gaps, APIError clusters), behavioral deviations from workflow intelligence (complexity score outliers, error propagation anomalies), and sessions with abnormal metadata (extreme turn_count, high thinking_blocks, zero turn_duration).
- ▌ Pattern Detect · hoangsonww bundleDetect recurring patterns using the Agent Monitor's workflow intelligence — toolFlow transitions (tool A → B frequency matrices), recurring workflow patterns, agent co-occurrence pairs, model delegation habits, error propagation paths by agent depth, and compaction triggers. Use to discover habitual usage patterns and anti-patterns.
- ▌ Session Search · hoangsonww bundleFind Claude Code sessions tracked by the Agent Monitor by project (cwd), model, status, or date, then rank the matches by cost or recency. Pulls the session list and the distinct cwd / facet values so filters use real values rather than guesses. Use when locating a session — "find my EstateWise sessions", "which Opus runs errored this week", "most expensive sessions in /repo".
- ▌ Cost Breakdown · hoangsonww bundleBreak down Claude Code costs using the Agent Monitor pricing engine. Shows per-model costs (input, output, cache_read, cache_write at $/Mtok rates), per-session costs, daily trends, and compaction baseline token recovery. Use when analyzing spending, comparing model costs, or planning budgets.
- ▌ Session Report · hoangsonww bundleGenerate a comprehensive session report with per-model token usage (input, output, cache_read, cache_write including compaction baselines), cost breakdown via the pricing engine, tool invocations, agent hierarchy, compaction events, API errors, turn durations, and thinking block counts. Use when reviewing a specific session or summarizing activity over a date range.
- ▌ Model Savings · hoangsonww bundleEstimate the dollars saved by routing eligible Claude Code work to a cheaper model family, using the Agent Monitor pricing engine. Re-prices each model's token mix at the target family's rates and quantifies the delta. Uses /api/pricing (rates), /api/pricing/cost (current per-model spend), /api/sessions, and /api/analytics. Use when hunting for cost cuts or comparing model tiers.
- ▌ Endpoint Probe · hoangsonww bundleProbes each major Agent Monitor API route — /api/stats, /api/analytics, /api/sessions, /api/pricing/cost, /api/workflows/runs, /api/cc-config/overview — and reports each one's HTTP status, latency, and response shape, flagging which are reachable. Use to verify a dashboard install is wired up correctly.
- ▌ Transcript Grep · hoangsonww bundleSearch a Claude Code session transcript for a string or regex pattern and show every matching message with surrounding context. Reads /api/sessions/:id/transcript and resolves sessions via /api/sessions?limit= from the Agent Monitor dashboard. Use when hunting for a specific message, prompt, tool call, or error inside a session's conversation.
- ▌ Session Compare · hoangsonww bundleCompare two sessions side-by-side using Agent Monitor data — per-model token usage (input/output/cache_read/cache_write + compaction baselines), pricing engine cost breakdowns, workflow intelligence (complexity scores, tool flow transitions, subagent effectiveness), session metadata (thinking_blocks, turn_count, turn_duration_ms, usage_extras), and full event timelines with all 10+ event types.
- ▌ Time Of Day · hoangsonww bundleDiscover when you are most active and most productive with Claude Code by bucketing sessions and events into hour-of-day and day-of-week bins from their timestamps, then flagging peak versus low-output windows. Uses the session list, per-session events, and analytics daily trends. Use when planning a schedule or deciding when to do deep work versus lighter tasks.
- ▌ API Error Report · hoangsonww bundleProduce a detailed report on APIError events from Agent Monitor data — counts over time, which sessions and models are affected, and the likely root cause (rate limits, overload/529, or context-window pressure) inferred from each event's summary and data payload. Use when API errors spike or when you need to explain why requests are failing.
- ▌ Regression Alert · hoangsonww bundleCompare this period's reliability against the prior period using Agent Monitor data — error rate (APIError/total) and tool-failure rate (PreToolUse→PostToolUse gap) — flag any regression where reliability got worse, and optionally wire a persistent alert rule so the dashboard catches the next regression automatically. Use when checking whether reliability degraded.
- ▌ Session Cleanup · hoangsonww bundleIdentify stale and empty Claude Code sessions in the Agent Monitor and explain the cleanup endpoint (POST /api/settings/cleanup), always showing the exact list of what WOULD be removed before anything is deleted. Cleanup permanently deletes data, so this skill previews first and requires explicit user confirmation. Use when tidying the monitoring database.
- ▌ Spend Forecast · hoangsonww bundleForecast Claude Code spend to the end of the week or month from the daily session trend on the Agent Monitor dashboard — moving average of daily spend × days remaining, added to spend-to-date. Uses /api/analytics daily_sessions, /api/pricing/cost, and /api/sessions for a per-day cost curve. Use when projecting cost or asking "where will my spend land".
- ▌ Hook Diagnostics · hoangsonww bundleDiagnose Claude Code hook installation, delivery, and ingestion issues. Checks hook configuration, connectivity, event flow, and identifies common problems. Use when events are not appearing in the dashboard.
- ▌ Regression Watch · hoangsonww bundleDetect quality and efficiency regressions over time using Agent Monitor data — rising error rate (APIError events), falling cache hit rate, growing compaction frequency, and climbing cost-per-session. Splits history into an earlier baseline window and a recent window and reports which metrics are getting worse, by how much, and where. Use when checking whether things are degrading or trending in the wrong direction.
- ▌ Session Timeline · hoangsonww bundleRender an ordered timeline of one Claude Code session's events (every event type) with per-event durations and tool names, reconstructed from Agent Monitor data. Pairs PreToolUse with PostToolUse to compute tool durations and surfaces gaps, errors, and compaction points. Use when reconstructing what happened in a session step by step.
- ▌ Cache Efficiency · hoangsonww bundleAnalyze prompt-cache effectiveness for Claude Code usage from the Agent Monitor dashboard — cache hit rate (total_cache_read / (total_cache_read + total_input)), cache_write vs cache_read reuse, cache-read vs cache-write spend, and the sessions with the poorest reuse. Pulls token totals from /api/analytics, per-session detail from /api/sessions, and dollar splits from /api/pricing/cost. Use when diagnosing cache spend or deciding whether prompt caching is paying off.
- ▌ Dashboard Status · hoangsonww bundleQuick dashboard health and status overview — checks the Agent Monitor API (port 4820), reports session/agent/event counts from /api/stats, confirms WebSocket connectivity, reads the redacted hook status returned by /api/settings/info, and shows data freshness (last event timestamp). Use to verify the monitoring system is operational.
- ▌ Daily Standup · hoangsonww bundleGenerate a daily standup summary from recent Claude Code sessions — completed work grouped by project (cwd), session costs from the pricing engine, tool invocations, error/compaction/APIError events, and turn velocity metrics from session metadata (turn_count, total_turn_duration_ms).
- ▌ Weekly Report · hoangsonww bundleCompile a weekly productivity report using Agent Monitor data — daily_sessions and daily_events trends, per-session costs from pricing engine, token volumes (input/output/cache_read/cache_write + baselines), tool usage top 20, session completion rates by status, and workflow intelligence metrics.
- ▌ Hook Failure Audit · hoangsonww bundleAudit hook delivery health from Agent Monitor data — balance PreToolUse vs PostToolUse (a gap means tools that started but never reported back), detect missing Stop/SubagentStop terminators (sessions/subagents that never closed), and check for stale ingestion (no recent events). Use when hooks look unreliable or events seem to be dropping.
- ▌ Transcript Replay · hoangsonww bundleWalk a Claude Code session transcript turn-by-turn from Agent Monitor data, summarizing each user, assistant, and tool message in order so a long conversation can be reviewed quickly. Anchors the recap to the session header (model, cost, turn_count). Use when reviewing what was actually said and done in a conversation.
- ▌ File Headers · hoangsonww bundleMANDATORY for every coding agent (Claude Code, Codex, or any other) on every change-set — every applicable source file the agent creates or updates MUST start with the project's copyright/authorship header (file overview + exact author line). Use automatically whenever writing a new file or editing an existing one; do not wait to be asked. Covers JS/TS/TSX/CJS/MJS, Python, shell, and CSS. Includes the audit script to verify repo-wide compliance.
- ▌ MCP Operations · hoangsonww bundleOperate and maintain the local MCP server for this project. Use when creating MCP host config, troubleshooting tool connectivity, modifying tool domains, or adjusting safety policy flags.
- ▌ Version Release · hoangsonww bundleChoose and apply the correct semantic version bump for this repository. Use for every user-visible release, before merge when a change set should ship as patch, minor, or major, and whenever package/plugin/desktop version metadata must stay synchronized.
- ▌ Update Project Docs · hoangsonww bundleMANDATORY for every coding agent (Claude Code, Codex, or any other) — keep this repository's documentation in sync after any change to behavior, configuration, interfaces, events, schema, or features. Use automatically (without being asked) at the end of ANY change-set that adds or alters an env var, event type, hook behavior, session/agent state transition, API route or response shape, DB schema, WebSocket message, MCP tool, CLI command, or user-facing feature — and whenever the user asks to "update the docs / README / wiki / architecture". Knows the full doc surface (README + CN/VN/KO/ES, ARCHITECTURE, root index.html, wiki + i18n, server/client READMEs, docs/*) and which docs each kind of change touches.
- ▌ MCP Audit · hoangsonww bundleAudit the configured MCP servers (user + project scope) via the Agent Monitor Config Explorer API: transport (stdio vs http), command/args and env variable names, headers, and the source file each definition came from. Reads /api/cc-config/mcp. Use when reviewing MCP integrations for hygiene, duplication, or unexpected transports.
- ▌ Slo Check · hoangsonww bundleDefine and check simple service-level objectives for Claude Code from Agent Monitor data — session completion rate, tool success rate (PostToolUse/PreToolUse), and error rate (APIError/total) — then compare each to its target and report the error budget remaining. Use when reporting reliability or when someone asks "are we meeting our SLOs?".
- ▌ Dag Map · hoangsonww bundleRender the multi-agent orchestration DAG for a session — parent→child subagent edges, tree depth, and fan-out — from the Agent Monitor workflow intelligence API. Cross-checks the orchestration dataset against the raw agent records and session detail. Use when visualizing how a session's agent structure was organized.
- ▌ Benchmark · hoangsonww bundleBenchmark one session (or a small recent set) against the rolling average using Agent Monitor data — cost, total tokens, tool count, and workflow complexity score — and report where each metric lands as a percentile of the population. Tells you whether a session was normal, cheap, or an outlier. Use when judging whether a session was typical or out of band.
- ▌ Error Scan · hoangsonww bundleScan recent Claude Code activity for errors and failure signals across all sessions using Agent Monitor data — APIError events and PreToolUse→PostToolUse gaps (tools that started but never completed) — then group failures by tool and model and rank them by frequency. Use when checking for errors or asking "what's failing right now".
- ▌ Model Mix · hoangsonww bundleBreak down Claude Code usage by model family (Opus / Sonnet / Haiku) from the Agent Monitor dashboard — each family's share of tokens, share of cost, and the spots where an expensive model is doing cheap work. Pulls per-model token and cost splits from /api/pricing/cost, current rates from /api/pricing, fleet token totals from /api/analytics, and per-session model assignment from /api/sessions. Use when deciding model routing or whether to downshift work to a cheaper tier.
- ▌ Config Audit · hoangsonww bundleRun a full audit of the user's Claude Code configuration via the Agent Monitor Config Explorer API: counts per surface (user vs project), duplicate or overlapping skills and subagents, hooks that run shell commands, and which surfaces are read-only vs mutable. Reads /api/cc-config/overview, /skills, /agents, /commands, /hooks, and /settings. Use when reviewing your Claude Code setup for sprawl, duplication, or risk.
- ▌ Cwd Rollup · hoangsonww bundleRoll up Claude Code sessions by working directory (project) from Agent Monitor data — session count, total cost, total tokens, and last-active timestamp per cwd — so per-project activity can be compared at a glance. Use when summarizing where effort and spend went across projects.
- ▌ Memory Review · hoangsonww bundleReview the file-based memory store via the Agent Monitor Config Explorer API: the user and project CLAUDE.md plus per-project auto-memory files under ~/.claude/projects/<slug>/memory/*.md. Groups by project, shows the index (MEMORY.md) vs per-fact files, and flags stale or oversized facts. Reads /api/cc-config/memory and /api/cc-config/file?path=. Use when curating agent memory.
- ▌ Live Watch · hoangsonww bundlePolls the Agent Monitor /api/stats endpoint several times over a short window and reports the live deltas in active_sessions, active_agents, events_today, and ws_connections so you can see activity moving in real time. Use when watching the dashboard for live changes rather than a one-time snapshot.
- ▌ Data Export · hoangsonww bundleExport Claude Code session and analytics data in JSON, CSV, or Markdown formats. Supports exporting sessions, events, costs, and analytics for external analysis or reporting. Use for data backup or integration.
- ▌ Event Trace · hoangsonww bundleTrace the full event chain for one Claude Code session into an ordered timeline of every event type with tool_name and summary, highlighting gaps, out-of-order events, and failures. Reads /api/events?session_id= and /api/sessions/:id from the Agent Monitor dashboard. Use when debugging what a session actually did, step by step.