From 69c2d966b29de128b307b32e0e845e98567552a4 Mon Sep 17 00:00:00 2001 From: Dotta Date: Tue, 13 Oct 2026 13:21:11 -0500 Subject: [PATCH] Rename plugin to dottastack and add blameless root-cause skill --- .claude-plugin/marketplace.json | 4 +- .cursor-plugin/marketplace.json | 4 +- AGENTS.md | 2 +- README.md | 20 +- docs/compatibility.md | 20 +- .../.claude-plugin/plugin.json | 2 +- .../.cursor-plugin/plugin.json | 2 +- {dstack => dottastack}/plugin.json | 2 +- .../skills/blameless-root-cause/SKILL.md | 198 ++++++++++++++++++ .../references/evidence.md | 138 ++++++++++++ .../skills/dotta-ui-ux/SKILL.md | 0 .../skills/dotta-ui-ux/agents/openai.yaml | 0 .../goal-poteto-style-definition/SKILL.md | 0 .../skills/trees-maps-theorems/SKILL.md | 0 scripts/install.py | 6 +- 15 files changed, 370 insertions(+), 28 deletions(-) rename {dstack => dottastack}/.claude-plugin/plugin.json (84%) rename {dstack => dottastack}/.cursor-plugin/plugin.json (86%) rename {dstack => dottastack}/plugin.json (89%) create mode 100644 dottastack/skills/blameless-root-cause/SKILL.md create mode 100644 dottastack/skills/blameless-root-cause/references/evidence.md rename {dstack => dottastack}/skills/dotta-ui-ux/SKILL.md (100%) rename {dstack => dottastack}/skills/dotta-ui-ux/agents/openai.yaml (100%) rename {dstack => dottastack}/skills/goal-poteto-style-definition/SKILL.md (100%) rename {dstack => dottastack}/skills/trees-maps-theorems/SKILL.md (100%) diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json index 9731217..28e7680 100644 --- a/.claude-plugin/marketplace.json +++ b/.claude-plugin/marketplace.json @@ -5,8 +5,8 @@ }, "plugins": [ { - "name": "dstack", - "source": "./dstack", + "name": "dottastack", + "source": "./dottastack", "description": "Dotta\u2019s personal skills and agent workflows." } ], diff --git a/.cursor-plugin/marketplace.json b/.cursor-plugin/marketplace.json index 9731217..28e7680 100644 --- a/.cursor-plugin/marketplace.json +++ b/.cursor-plugin/marketplace.json @@ -5,8 +5,8 @@ }, "plugins": [ { - "name": "dstack", - "source": "./dstack", + "name": "dottastack", + "source": "./dottastack", "description": "Dotta\u2019s personal skills and agent workflows." } ], diff --git a/AGENTS.md b/AGENTS.md index a1c98f2..837e995 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -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 diff --git a/README.md b/README.md index 087e198..17dd8d6 100644 --- a/README.md +++ b/README.md @@ -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. diff --git a/docs/compatibility.md b/docs/compatibility.md index e82dc5c..c8dcf43 100644 --- a/docs/compatibility.md +++ b/docs/compatibility.md @@ -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//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//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. diff --git a/dstack/.claude-plugin/plugin.json b/dottastack/.claude-plugin/plugin.json similarity index 84% rename from dstack/.claude-plugin/plugin.json rename to dottastack/.claude-plugin/plugin.json index 159f854..689308e 100644 --- a/dstack/.claude-plugin/plugin.json +++ b/dottastack/.claude-plugin/plugin.json @@ -1,5 +1,5 @@ { - "name": "dstack", + "name": "dottastack", "version": "0.1.0", "description": "Dotta\u2019s personal skills and agent workflows.", "author": { diff --git a/dstack/.cursor-plugin/plugin.json b/dottastack/.cursor-plugin/plugin.json similarity index 86% rename from dstack/.cursor-plugin/plugin.json rename to dottastack/.cursor-plugin/plugin.json index ec40b80..c2cf286 100644 --- a/dstack/.cursor-plugin/plugin.json +++ b/dottastack/.cursor-plugin/plugin.json @@ -1,5 +1,5 @@ { - "name": "dstack", + "name": "dottastack", "version": "0.1.0", "description": "Dotta\u2019s personal skills and agent workflows.", "author": { diff --git a/dstack/plugin.json b/dottastack/plugin.json similarity index 89% rename from dstack/plugin.json rename to dottastack/plugin.json index 86b130d..7efddab 100644 --- a/dstack/plugin.json +++ b/dottastack/plugin.json @@ -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": { diff --git a/dottastack/skills/blameless-root-cause/SKILL.md b/dottastack/skills/blameless-root-cause/SKILL.md new file mode 100644 index 0000000..733ece4 --- /dev/null +++ b/dottastack/skills/blameless-root-cause/SKILL.md @@ -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/.mdc` rule, `CLAUDE.md`, or `.claude/rules/.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. diff --git a/dottastack/skills/blameless-root-cause/references/evidence.md b/dottastack/skills/blameless-root-cause/references/evidence.md new file mode 100644 index 0000000..fdc9319 --- /dev/null +++ b/dottastack/skills/blameless-root-cause/references/evidence.md @@ -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 :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. diff --git a/dstack/skills/dotta-ui-ux/SKILL.md b/dottastack/skills/dotta-ui-ux/SKILL.md similarity index 100% rename from dstack/skills/dotta-ui-ux/SKILL.md rename to dottastack/skills/dotta-ui-ux/SKILL.md diff --git a/dstack/skills/dotta-ui-ux/agents/openai.yaml b/dottastack/skills/dotta-ui-ux/agents/openai.yaml similarity index 100% rename from dstack/skills/dotta-ui-ux/agents/openai.yaml rename to dottastack/skills/dotta-ui-ux/agents/openai.yaml diff --git a/dstack/skills/goal-poteto-style-definition/SKILL.md b/dottastack/skills/goal-poteto-style-definition/SKILL.md similarity index 100% rename from dstack/skills/goal-poteto-style-definition/SKILL.md rename to dottastack/skills/goal-poteto-style-definition/SKILL.md diff --git a/dstack/skills/trees-maps-theorems/SKILL.md b/dottastack/skills/trees-maps-theorems/SKILL.md similarity index 100% rename from dstack/skills/trees-maps-theorems/SKILL.md rename to dottastack/skills/trees-maps-theorems/SKILL.md diff --git a/scripts/install.py b/scripts/install.py index eeec6b7..8012144 100644 --- a/scripts/install.py +++ b/scripts/install.py @@ -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: