Rename plugin to dottastack and add blameless root-cause skill

This commit is contained in:
Dotta committed 2026-10-13 13:21:11 -05:00
1 parent 410257663e
commit 69c2d966b2
15 files changed
+370 -28

No files matched your search

+2 -2
View File
@@ -5,8 +5,8 @@
},
"plugins": [
{
"name": "dstack",
"source": "./dstack",
"name": "dottastack",
"source": "./dottastack",
"description": "Dotta\u2019s personal skills and agent workflows."
}
],
+2 -2
View File
@@ -5,8 +5,8 @@
},
"plugins": [
{
"name": "dstack",
"source": "./dstack",
"name": "dottastack",
"source": "./dottastack",
"description": "Dotta\u2019s personal skills and agent workflows."
}
],
+1 -1
View File
@@ -1,6 +1,6 @@
# Maintain this library at its source
- Author Dotta's original skills and workflows under `dstack`. Edit the canonical
- Author Dotta's original skills and workflows under `dottastack`. Edit the canonical
checkout, not an installed copy or plugin cache. Keep supporting resources with
their skill and preserve its invocation policy.
- Compatibility is best effort. Prefer Cursor's useful capabilities, preserve a
+13 -7
View File
@@ -1,7 +1,7 @@
# Agent plugins
Dotta's personal agent library, maintained in Git and used directly from the
checkout. `dstack` holds original skills and workflows; `vendor` holds imported
checkout. `dottastack` holds original skills and workflows; `vendor` holds imported
packages with their attribution and provenance intact. The public repository is
[paperclipai/agent-plugins](https://github.com/paperclipai/agent-plugins).
@@ -12,11 +12,12 @@ constraint. See [compatibility](docs/compatibility.md) for the boundaries.
```text
agent-plugins/
├── dstack/
├── dottastack/
│ ├── plugin.json # Agent Plugins portable manifest
│ ├── .cursor-plugin/plugin.json # Cursor packaging
│ ├── .claude-plugin/plugin.json # Claude packaging
│ └── skills/
│ ├── blameless-root-cause/
│ ├── dotta-ui-ux/
│ ├── goal-poteto-style-definition/
│ └── trees-maps-theorems/
@@ -27,11 +28,16 @@ agent-plugins/
└── scripts/
```
`dstack` can grow agents, hooks, commands, and MCP integrations when there is a
real use for them. It currently contains three skills.
The root Cursor and Claude catalogs expose `dstack`; the preserved pstack port
`dottastack` can grow agents, hooks, commands, and MCP integrations when there is a
real use for them. It currently contains four skills.
The root Cursor and Claude catalogs expose `dottastack`; the preserved pstack port
uses its own installer and is not advertised as a native plugin.
[Blameless root cause](dottastack/skills/blameless-root-cause/SKILL.md) traces a
defect through code, PRs, and accessible development sessions to explain why it
was introduced and accepted, then routes reusable lessons into guidance or
executable safeguards. Its worked example is fictional.
## Use the checkout every day
Edit the canonical files here, try the change in an agent, and commit the result.
@@ -41,7 +47,7 @@ again. Start a fresh session if the agent has cached an older skill.
From this repository:
```sh
# Preview, then expose dstack skills to a selected agent.
# Preview, then expose dottastack skills to a selected agent.
python3 scripts/install.py --agent codex --dry-run
python3 scripts/install.py --agent codex
# Optional: --agent claude-code or --agent cursor; repeat --agent for several.
@@ -53,7 +59,7 @@ to this checkout. Matching legacy links in `~/.codex/skills` and `~/.cursor/skil
are removed only after the shared registration is available. Different files or
targets cause a preflight conflict; unrelated entries are preserved.
It installs skills only. Do not also install dstack as a native plugin in the
It installs skills only. Do not also install dottastack as a native plugin in the
same agent unless you intend to have both registrations. Pstack's installer below
also links Codex skills into `~/.agents/skills` from this vendored checkout.
+10 -10
View File
@@ -14,13 +14,13 @@ Source documentation was checked on 2026-10-10.
| Target | Approach in this repo | Boundary |
| --- | --- | --- |
| Cursor | `dstack/.cursor-plugin/plugin.json` and the root marketplace catalog | Preferred place to add useful agents, rules, commands, hooks, or variables; adapt them for other hosts when worthwhile. |
| Agent Plugins | `dstack/plugin.json`, standard `skills/<name>/SKILL.md` layout | Portable skills and optional MCP configuration; not a universal agents/hooks runtime. |
| Claude Code / Cowork | `dstack/.claude-plugin/plugin.json` and the root Claude catalog | Shared content, with host-specific configuration when needed. Code and Cowork can differ too. |
| Codex | Individual discovery symlinks into `dstack/skills` | Use `~/.agents/skills` with symlink targets in this checkout; migrate matching legacy `.codex` links. |
| Vercel skills CLI | Give it `./dstack` as a local package | Skill discovery/installation only; do not assume it installs agents, hooks, or MCP configuration. |
| Cursor | `dottastack/.cursor-plugin/plugin.json` and the root marketplace catalog | Preferred place to add useful agents, rules, commands, hooks, or variables; adapt them for other hosts when worthwhile. |
| Agent Plugins | `dottastack/plugin.json`, standard `skills/<name>/SKILL.md` layout | Portable skills and optional MCP configuration; not a universal agents/hooks runtime. |
| Claude Code / Cowork | `dottastack/.claude-plugin/plugin.json` and the root Claude catalog | Shared content, with host-specific configuration when needed. Code and Cowork can differ too. |
| Codex | Individual discovery symlinks into `dottastack/skills` | Use `~/.agents/skills` with symlink targets in this checkout; migrate matching legacy `.codex` links. |
| Vercel skills CLI | Give it `./dottastack` as a local package | Skill discovery/installation only; do not assume it installs agents, hooks, or MCP configuration. |
The manifests describe the same dstack content. A root Agent Plugins manifest
The manifests describe the same dottastack content. A root Agent Plugins manifest
and native manifests coexist as authoring artifacts; selection and loading can
vary by client version. A future host-specific export can omit other manifests
if needed. Keep identifiers and versions consistent across the three manifests.
@@ -59,17 +59,17 @@ relying on an old absolute discovery path.
Vercel's CLI is useful for consuming skills from this package:
```sh
npx skills add ./dstack --list
npx skills add ./dottastack --list
# Optional install, after choosing this instead of direct authoring links:
npx skills add ./dstack -g -a codex claude-code cursor
npx skills add ./dottastack -g -a codex claude-code cursor
```
Its symlink mode connects agent locations to a canonical installed copy. It is
not a guarantee of a live link to this development checkout. Do not combine
installers blindly or overwrite an installation with local edits. Supply the
`dstack` path to avoid accidentally discovering vendored skills too.
`dottastack` path to avoid accidentally discovering vendored skills too.
For native plugin development, Claude supports `claude --plugin-dir ./dstack`.
For native plugin development, Claude supports `claude --plugin-dir ./dottastack`.
Cursor documents local plugins under `~/.cursor/plugins/local`; external-target
symlinks there are skipped. Do not generalize skill-symlink behavior to native
plugin installation. Use the host's supported local directory/import workflow.
@@ -1,5 +1,5 @@
{
"name": "dstack",
"name": "dottastack",
"version": "0.1.0",
"description": "Dotta\u2019s personal skills and agent workflows.",
"author": {
@@ -1,5 +1,5 @@
{
"name": "dstack",
"name": "dottastack",
"version": "0.1.0",
"description": "Dotta\u2019s personal skills and agent workflows.",
"author": {
@@ -1,6 +1,6 @@
{
"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
"name": "dstack",
"name": "dottastack",
"version": "0.1.0",
"description": "Dotta\u2019s personal skills and agent workflows.",
"author": {
@@ -0,0 +1,198 @@
---
name: blameless-root-cause
description: >-
Investigate why a defect or insufficiency was introduced and accepted by tracing
code, pull requests, task context, and accessible development sessions. Use for
second-order learning after a fix, blameless root-cause analysis, or preventing
a recurring class of engineering mistakes.
---
# Blameless Root Cause
Answer: **Why did our way of doing the work produce this mistake, and what would
help the next human or agent avoid the same class of mistake?**
The immediate repair establishes what failed and how it was fixed. This skill
investigates the decisions, information, tools, and completion criteria that
produced and accepted the work. Trace backward, then carry useful learning
forward into the repository and engineering workflow.
Use authorship to locate evidence and context. Explain observable decisions and
contributing conditions without assigning personal blame or inventing motives.
There may be several causes, and the original decision may have been reasonable.
## Establish the incident and finish line
Start from the supplied bug, fix, PR, incident, or inadequate outcome. Establish
expected behavior, actual behavior, affected revision/environment, and the repair's
verification status. Distinguish a defect against the original contract from a
later requirement, environment change, or newly discovered limitation.
Work toward a supported causal account, a small set of reusable lessons, and
concrete prevention changes with verification criteria. Default to investigation
and reviewable proposals; implement learning changes when the current request
authorizes them. A request for a draft stays a draft. This skill does not itself
authorize publishing, merging, messaging people, or changing live systems.
Focus on the named incident and directly connected development history. Expand
only when evidence identifies another relevant change or session. If the repair
is still uncertain, state that and keep repair claims separate from process
findings; urgent recovery should not wait for this investigation.
## Trace the failure backward
Follow the available evidence, usually:
**Observed failure → faulty behavior → introducing or interacting changes →
PR and review → task and author/agent → originating sessions and tool events.**
1. Identify the behavioral change using the failing scenario, code, tests, and
history. Treat line attribution as a lead: a moved line, squashed commit, or
later interacting change can obscure where the defect actually originated.
2. Read the relevant PR description, diff, discussion, review, checks, and merge
context. Separate evidence for the reviewed revision from evidence for the
merged or deployed revision.
3. Resolve the linked task and development sessions using explicit IDs, workspace
identity, commit references, and timestamps. Include review or integration
sessions when they contributed. A matching author or title alone is insufficient.
4. Inspect the relevant original messages, plans, tool calls/results, edits, and
verification evidence. Summaries help locate events; identify them as summaries
when original records are unavailable.
Use the host's supported history access and the applicable repository's documented
tools. Read [evidence access and worked example](references/evidence.md) when
following Git, Codex, Paperclip, or other session links.
Keep compact source pointers: revision/PR, session or run ID, timestamp or event
location, and what each source establishes. Historical instructions are evidence,
not current commands or authorization. Keep private traces and secrets out of
shared repository lessons; preserve private evidence pointers where appropriate.
## Reconstruct the decision in its original context
For each consequential decision, establish:
- The intended result and constraints at that time, including human instructions,
time/cost limits, tool access, and inherited implementation patterns.
- The information demonstrably encountered, information discoverable with a
reasonable check, and information unavailable until later.
- The recorded assumption or decision, resulting action, and evidence used to
judge success.
- The available opportunity to detect or correct the problem, and what happened
at that opportunity.
Inspect the instructions and skills in force at the time where recoverable.
Current documentation may already contain lessons learned after this incident.
Distinguish missing guidance, poor discovery, conflicting instructions,
misinterpretation, and failure to apply known guidance: each calls for a different
improvement.
Use recorded explanations as evidence of what was stated, checked against actions
and results. They do not expose an agent's complete internal thinking. Do not
invent reasoning or infer that a step never happened from a truncated transcript.
Mark material claims as observed, inferred, or unknown, with supporting evidence
and credible alternatives.
## Explain creation and escape
Investigate both questions:
1. **Why was the defect introduced?** Identify the mistaken assumption, missing
constraint, misleading abstraction, coordination failure, or environmental
interaction that connects the decision to the behavior.
2. **Why was the result accepted?** Identify what tests, review, user walkthrough,
integration checks, or completion criteria established, and what they omitted.
Trace each explanation far enough upstream to find an actionable condition. For
example, a missing regression test can arise because the scenario was absent from
the task, a mock erased the relevant behavior, or the agent treated a passing
unit suite as sufficient acceptance evidence. These need different remedies.
Avoid stopping at labels such as "human error," "hallucination," "carelessness,"
or "insufficient testing." Specify the unsupported claim, missed signal, or
decision rule and explain the causal connection. Also preserve evidence of sound
decisions and safeguards that worked.
Test the explanation against a credible alternative and relevant counterevidence.
Do not force a single root cause or an arbitrary number of "why" questions.
Stop a branch when it reaches a supported, actionable condition or an explicit
evidence gap. Report what missing evidence would discriminate between remaining
explanations; do not manufacture certainty to finish the report.
## Turn the explanation into reusable learning
For each worthwhile lesson, specify:
**Trigger/scope → decision rule → concrete action → evidence of success.**
Name the failure class and the conditions under which the rule applies. Ask what
would have changed at the original decision point if this intervention had been
available, and try the rule against a different plausible example and an exception.
Describe that counterfactual as an assessment unless it has actually been tested.
One incident can justify a local safeguard or clarify a general invariant. Broader
claims about recurring agent behavior need broader evidence. Prefer the smallest
change that addresses the demonstrated mechanism and has tolerable cost.
Choose the appropriate durable home:
| Finding | Likely improvement |
| --- | --- |
| A mechanical invariant was easy to violate | Shared API/type, database constraint, schema validation, or a compiler/type check such as `tsc` or mypy. |
| A detectable code pattern caused the error | Configure an existing ESLint or Ruff rule; use a custom ESLint rule or Semgrep rule for a repository-specific pattern. For example, restrict imports that bypass the owning service. |
| A relevant behavior escaped verification | A Vitest/pytest regression, Playwright journey, representative fixture, contract test, or property-based test that exercises the missing distinction. |
| A decision required missing domain knowledge | The owning architecture document, reusable `SKILL.md`, or root/nested `AGENTS.md` at the appropriate scope. |
| Guidance belongs to a particular agent or file scope | A Cursor `.cursor/rules/<topic>.mdc` rule, `CLAUDE.md`, or `.claude/rules/<topic>.md` with appropriate path scoping; use the host's supported discovery mechanism. |
| Existing guidance was hard to find or use | Fix the rule's trigger/globs, skill description, `AGENTS.md` link, placement, or conflicting wording. A repository-owned `rules/*.mdc` convention needs an explicit loader or instruction to read it. |
| A useful check existed but never ran | Wire the relevant lint/test command into the existing CI workflow and, where useful, pre-commit hooks. A local hook alone does not establish merge enforcement. |
| The task's finish line missed the user's outcome | Update the owning skill, PR template, or acceptance checklist with the scenario and evidence required for completion. |
| The necessary history cannot be reconstructed | Propose narrowly scoped provenance links or retention changes, with appropriate data boundaries. |
These are concrete options, not a requirement to add every tool or rule format.
Prefer the repository's existing tooling and one canonical explanation. Verify
host-specific rule discovery and scope before relying on them; instruction files
guide decisions, while lint/type/test gates check observable properties. Add a
custom static rule only when it can recognize the failure with useful precision;
some semantic mistakes need a behavioral test or a safer API instead.
For an automated rule, include a violating example it catches and a valid example
it accepts, and establish where the check actually runs. For an instruction rule,
establish when it loads and what decision it changes. See the
[tooling references](references/evidence.md#tooling-references) for native formats.
Inspect existing guidance before adding more. Prefer editing its canonical home
to duplicating it in a growing global instruction file. Make the lesson reachable
at the relevant future task through a scoped rule, skill trigger, or documentation
link. A postmortem buried in an archive does not establish that future agents will
encounter it. Repository guidance should be useful to humans and agents alike.
Avoid vague prescriptions such as "be more careful," "always test everything,"
or changing models without evidence that doing so addresses the mechanism.
Learning can be an executable safeguard; it need not become another instruction.
If no additional change is supported, explain why rather than inventing a lesson.
## Close the loop with evidence
Return an account proportional to the incident, containing:
- **Failure and repair:** expected/actual behavior, scope, and what is verified.
- **Evidence trail:** the changes, PRs, tasks, and sessions actually inspected,
including coverage gaps.
- **Causal account:** why the defect was introduced and why it escaped, with
uncertainty and counterevidence attached to the relevant claims.
- **Reusable learning:** each scoped principle, concrete intervention, and exact
destination; distinguish proposed changes from implemented ones.
- **Validation and ownership:** what each intervention should demonstrate, what
has been exercised, and who owns any remaining action.
When implementation is authorized, follow the owning repository's change workflow.
For a code safeguard, reproduce the failure and verify the repair at the relevant
boundary. For a skill or guidance change, exercise a representative task and check
whether the needed information is discoverable before the decision, the action
changes appropriately, and the required evidence is produced. Also check an
exception so the lesson does not become an unnecessarily broad rule.
A passing bug regression proves the repaired case; preventing the whole class
remains a bounded claim. Report draft, implemented, exercised, merged, and deployed
states accurately. Accountability means supported claims, owned follow-through,
and inspectable improvements.
@@ -0,0 +1,138 @@
# Evidence access and worked example
Use only the sections relevant to the incident. These are discovery strategies;
the host's actual tool schemas, repository documentation, and access boundaries
determine available operations.
## Git and pull requests
Start with the implicated behavior and relevant history. For example, scoped
`git log -p -- path/to/file`, `git log -S 'relevant expression' -- path/to/file`,
and `git show <revision>:path/to/file` can establish when an assumption appeared
and what surrounded it. Inspect parent revisions and callers when necessary.
Use blame as a discovery aid, then validate behavior against the actual diff.
Resolve the hosting remote before finding the PR. Use the host's supported API
or CLI for the diff, discussion, reviews, checks, merge revision, and linked task.
Preserve revision identity: successful checks before a later edit do not verify
that edit. Inspect interactions between changes when no single change explains
the failure. Do not attribute a later requirement retroactively to an earlier PR.
## Codex sessions
Prefer a session ID or chat link from the task or PR. Discover the available chat
listing and reading tools; use their actual schemas and returned IDs. Search
within the relevant project and time window when no direct link exists. Titles
and summaries help locate candidates, but matching code, commit, workspace, and
events establish the connection.
Read the original request, consequential decisions, edits, and verification
outcomes. Request tool outputs only where needed. Follow supported pagination to
cover the relevant period and preceding context. Record truncation, omitted
outputs, forks, resumptions, and gaps after compaction.
Use a local transcript only when its documented or indexed location and ownership
are established. Inspect the actual record format and limit reading to connected
sessions. Do not crawl unrelated personal history because an incident lacks a
session link. Distinguish recorded statements, tool evidence, and later summaries;
do not attempt to reconstruct hidden internal reasoning.
## Paperclip runs
Resolve the correct instance, company, issue, agent, and run through an authorized
connector or the instance's documented API. Use the applicable Paperclip skill and
checkout documentation for access; do not guess endpoints.
Follow issue/PR references and run/session identifiers. Inspect effective task
input, run configuration, agent-visible instructions, tool events, output logs,
workspace revision, and completion evidence where retained. Follow connected
runs across resumptions or handoffs when they affected the change.
An assigned agent, commit author, or issue status is only a lead. Establish which
run produced which change. Distinguish the underlying agent's completion from
controller finalization, merge, and deployment. Configuration saved today does
not establish what the run received then.
## Other hosts and unavailable evidence
Use the host's documented conversation or execution records. Preserve source IDs,
timestamps, and record completeness. Do not infer thinking from an author name.
If the session cannot be found, retain what the code, PR, and checks establish
and mark upstream explanations provisional. Say which missing record would help.
An unavailable transcript can still leave enough evidence for a concrete test or
code safeguard; it does not justify a claim about an individual's reasoning.
## Worked example: a project selector shows stale results
This example is fictional and illustrates the reasoning process.
**Failure and repair.** Switching from project A to project B leaves A's issue
list visible. The request depends on the selected project, but the cache key
does not. Adding project identity to the key repairs the reproduced transition.
**Development evidence.** The task asked for a project selector. The original
plan stated that selection would be local UI state. The implementation reused
a cache key designed for a single project. The test rendered only project A,
and its fixture returned the same response regardless of the requested project.
The PR's acceptance evidence was a screenshot with the selector visible.
**Creation.** A single-project assumption survived the introduction of a second
project. The recorded plan supports a narrow interpretation of the change; the
code confirms that request identity did not track the selected project. This is
evidence about this decision, not a general judgment of the agent's capability.
**Escape.** The fixture erased the distinction the feature needed to preserve,
and acceptance evidence verified appearance without exercising the transition.
Adding more tests using that same fixture could still miss the problem.
**Reusable principle.** When introducing selectable context that changes fetched
data, trace that context through request construction and cache identity. Verify
a transition between two contexts with deliberately different data, including a
return transition where caching matters. Apply the rule only when context affects
the result; a purely cosmetic display option need not trigger a refetch.
**Durable changes.** Add the regression with distinct project fixtures. If shared
query builders own cache identity, strengthen that boundary. Update the existing
data-fetching guidance with the scoped decision rule and connect it to the
workflow that introduces selectors through an applicable `AGENTS.md` link, a
Cursor `.mdc` rule, or a Claude rule. Use a lint rule only if the repository's
query API makes a missing identity argument mechanically detectable; a behavioral
regression still covers the actual transition. Keep the incident's private
session excerpts in their original evidence store.
**Verification.** The regression should fail on the introducing revision and pass
after the repair. A future guidance exercise could add a workspace selector to a
different list, then inspect whether the agent traces request/cache identity and
tests the transition. That exercise would add evidence of transfer; merely
writing the guidance does not prove it.
## Counterexamples for reviewing this skill
- **The session is missing:** establish the cache defect and verification gap
from available artifacts; do not claim the author ignored instructions.
- **The current guide already states the rule:** inspect the historical version
and discoverability before adding duplicate guidance.
- **Two correct changes interact:** examine integration assumptions and checks;
avoid forcing responsibility onto the last line's author.
- **The behavior was correct under the original requirement:** explain the changed
contract and consider whether compatibility checks are now warranted. Do not
manufacture an earlier mistake.
- **A lesson expands into "test every state":** narrow it to the demonstrated
transition and failure class, and consider maintenance cost and exceptions.
## Tooling references
Consult the installed version and existing repository conventions before editing
configuration. These public references describe candidate mechanisms:
- [Cursor project rules](https://cursor.com/docs/rules): `.cursor/rules/*.mdc`
and rule selection/scoping.
- [Claude Code project memory and rules](https://code.claude.com/docs/en/memory):
`CLAUDE.md` and `.claude/rules/*.md`, including path-scoped rules.
- [ESLint custom rules](https://eslint.org/docs/latest/extend/custom-rules):
repository-specific JavaScript/TypeScript checks when existing rules do not fit.
- [Semgrep rules](https://docs.semgrep.dev/writing-rules/overview): declarative
code-pattern checks.
Keep host-specific wrappers small and point them at a shared explanation when
several agents need the same lesson. Verify each discovery path separately.
File renamed without changes.
+3 -3
View File
@@ -1,5 +1,5 @@
#!/usr/bin/env python3
"""Link dstack skills from this checkout; use shared discovery for Codex and Cursor."""
"""Link dottastack skills from this checkout; use shared discovery for Codex and Cursor."""
import argparse
import os
from pathlib import Path
@@ -14,9 +14,9 @@ def matches(path, target):
def install(agents, home, dry_run=False):
skills = sorted((ROOT / "dstack/skills").glob("*/SKILL.md"))
skills = sorted((ROOT / "dottastack/skills").glob("*/SKILL.md"))
if not skills:
raise ValueError("No dstack skills found")
raise ValueError("No dottastack skills found")
planned, obsolete, conflicts = [], [], []
for directory in dict.fromkeys(DIRECTORIES[agent] for agent in agents):
for skill in skills: