@dirtydishes/skills 0.1.1

package/README.md

@@ -0,0 +1,165 @@
+# Dirtydishes Skills
+
+Reusable assets for local Codex and agent workflows.
+
+This repository is the source directory for agent skills, prompt templates, loop scaffolds, schemas, examples, and related operating docs. It is meant to be edited directly, then synced to the places where the agents load their skills and templates.
+
+## Layout
+
+- `skills/` - User-created agent skills. Each skill should be self-contained, with a `SKILL.md` entrypoint and any references, templates, examples, or schemas it needs.
+- `codex-loop-templates/` - Reusable prompt and document scaffolds for Codex implementation loops.
+- `catalog/skills.json` - Installable skill catalog plus required tools, required skills, and recommended skills.
+- `bin/skills.js` - `npx`-compatible installer for copying packaged skills into an agent skill directory.
+
+## Installer
+
+The npm package name is `@dirtydishes/skills`; the Forgejo repo identity is `dirtydishes/skills`. Use `npx` when you want the latest published installer and catalog:
+
+```bash
+npx @dirtydishes/skills@latest list
+npx @dirtydishes/skills@latest install dirtyloops
+npx @dirtydishes/skills@latest update dirtyloops
+npx @dirtydishes/skills@latest doctor dirtyloops
+```
+
+Running `npx @dirtydishes/skills@latest` with no command opens a small interactive picker when stdin/stdout are TTYs. Automation should use explicit commands:
+
+```bash
+npx @dirtydishes/skills@latest update dirtyloops --quiet
+npx @dirtydishes/skills@latest update --all --quiet
+```
+
+The default install target is `~/.agents/skills`. Override it with `--target-dir`:
+
+```bash
+npx @dirtydishes/skills@latest install dirtyloops --target-dir ~/.agents/skills
+```
+
+The catalog distinguishes three dependency classes:
+
+- `requiresTools` - External commands that must exist on the system. `bd` is here because Beads is a tool, not a skill.
+- `requiresSkills` - Skills that must be installed for the target skill to satisfy its contract.
+- `recommendsSkills` - Skills that improve the workflow but are not mandatory.
+
+`dirtyloops` currently requires the external `bd` tool, requires `thermo-nuclear-code-quality-review`, and recommends `impeccable`. Required and recommended skills are updated to the latest version when they are packaged in `@dirtydishes/skills@latest`. If a dependency is not packaged yet, `doctor` reports whether it is already installed locally and exits nonzero when a required dependency is missing.
+
+For local development from this checkout:
+
+```bash
+node bin/skills.js list
+node bin/skills.js install dirtyloops --source-dir .
+node bin/skills.js doctor dirtyloops
+```
+
+## Skills
+
+### `dirtyloops`
+
+`skills/dirtyloops/` contains a router skill for Beads-canonical Codex implementation loops. It turns finalized plans into Beads issues, typed loop metadata, phase docs, run prompts, turn docs, review/CI contracts, and post-run storyboard artifacts.
+
+Use it when a project needs durable implementation control instead of one-off chat instructions. A dirtyloop gives the agent a persistent execution surface: Beads tracks status and dependencies, docs hold the phase context, turn docs hold phase history, and reviewers/CI have explicit ownership.
+
+#### Commands
+
+- `dirtyloops help` - Explain the available commands, workflows, examples, and expected artifacts.
+- `dirtyloops create <workflow>` - Compile a finalized plan into Beads loop metadata and a generated loop scaffold.
+- `dirtyloops run <workflow>` - Execute ready phases until the epic is complete, blocked, interrupted, or review/CI is unresolved.
+- `dirtyloops run <workflow> --once` - Execute only the next ready phase, close it out, and stop.
+- `dirtyloops inspect <workflow>` - Summarize loop state without mutating files, Beads, branches, PRs, or threads.
+- `dirtyloops closeout <workflow>` - Verify completion and produce the storyboard artifact.
+
+#### Create Then Run
+
+The normal flow is two-stage:
+
+1. Finalize the plan in chat or in existing project docs.
+2. Run `dirtyloops create <workflow>` to compile that plan into Beads issues, implementation docs, templates, schemas, and a runnable prompt.
+3. Open the generated `docs/implementation/<stream-slug>/prompts/run-loop.md`.
+4. Run `dirtyloops run <workflow>` from a fresh or continuing Codex thread using that generated prompt.
+5. Let `run` continue phase-by-phase until Beads says the stream is complete, blocked, interrupted, or review/CI is unresolved. Use `--once` only for one-shot operation.
+6. Run `dirtyloops closeout <workflow>` to verify completion and generate the final storyboard.
+
+`create` is the plan compiler. `run` is the execution loop. Keep those separate so the generated artifacts become the durable source of truth before implementation begins.
+
+#### Generated Artifacts
+
+A created loop writes a project-local execution surface under `docs/implementation/<stream-slug>/`:
+
+- `IMPLEMENT.md` - Agent-facing index for the stream, including workflow rules, phase links, quality gates, and operating contract.
+- `00-roadmap.md` - Human-readable map of the implementation stream and phase ordering.
+- `NN-phase-name.md` - One phase doc per Beads child issue.
+- Beads loop metadata - Canonical workflow, run policy, callback policy, thread defaults, swarm policy, quality gates, and branch/PR policy.
+- `loop-state.md` - Lightweight mirror for current phase, branch/PR posture, blockers, and next action.
+- `turn-docs/` - One Markdown turn doc per phase. Reviewers update the existing phase turn doc instead of creating separate review docs.
+- `prompts/run-loop.md` - The prompt used to start or continue loop execution.
+- Workflow prompts - `orchestrator-callback` also emits implementation and review thread prompts.
+- Schemas - Callback/report JSON contracts for implementation, review, and swarm reports.
+- `storyboard-post-run-mm-dd-yyyy.html` - Final closeout artifact generated after the stream completes.
+
+The skill package itself mirrors that shape:
+
+- `SKILL.md` routes commands and enforces hard requirements.
+- `references/` holds command and workflow instructions.
+- `templates/` holds reusable generated docs and prompts.
+- `schemas/` defines callback/report payload contracts.
+- `examples/` shows complete generated loop trees for both workflows.
+- `plan.html` is the human-readable map of the skill's workflow model.
+
+#### Workflows
+
+- `single-thread-subagent` - One visible coordinator thread owns loop state while mass subagent swarms handle selection, scouting, slice planning, implementation assistance, review, and CI.
+- `orchestrator-callback` - One orchestrator thread creates separate implementation and review threads; those threads call back to a concrete orchestrator thread id only when they are done, blocked, or have opened the expected PR.
+
+Choose `single-thread-subagent` when you want one visible coordinator thread, less thread management, and a CLI-friendly loop. The main coordinator owns the branch, integration, PR state, Beads updates, and closeout. Subagents inspect, scout, split phases into slices, prepare implementation guidance or patches, review, verify CI, and report, but they do not advance loop state. Broad phases should use 8+ subagents before implementation.
+
+Choose `orchestrator-callback` when you want the original multi-thread flow. The orchestrator chooses the next ready Beads phase, creates implementation threads with a concrete callback target id, waits for implementation callbacks, creates review threads with the same callback target id, waits for review and CI callbacks, updates Beads, and then advances to the next phase.
+
+#### Authority Rules
+
+The `dirtyloops` skill is strict about ownership:
+
+- Beads is canonical for status, ordering, blockers, dependencies, and completion.
+- Beads stores typed dirtyloop metadata for workflow, run policy, callback policy, thread defaults, swarm policy, quality gates, and branch/PR policy.
+- Generated docs and prompts use repo-relative paths so they can move between machines.
+- Phase docs are execution context linked from Beads child issues.
+- One Markdown turn doc exists per phase.
+- Reviewers update the existing phase turn doc.
+- Reviewers use `thermo-nuclear-code-quality-review`.
+- Reviewer and CI verification agents own CI through green, repaired-green, unavailable-with-evidence, or blocked-with-cause.
+- `dirtyloops run` continues until complete by default. Use `--once` for one phase only.
+- Broad scout, slice, implementation-helper, and review work should use bounded subagent swarms, usually 8 or more agents and up to 20 when the phase warrants it.
+- Phase scope stays narrow. File follow-up Beads issues instead of widening an active phase.
+
+For `orchestrator-callback`, only the orchestrator creates implementation and review threads. Implementation threads do not create review threads, review threads do not create follow-up implementation threads, selector subagents never implement, and reviewer subagents never close Beads issues.
+
+For `single-thread-subagent`, the coordinator must run a slice/scout swarm before broad implementation. Solo coordinator implementation of most phase work is a workflow violation; coordinator implementation should be limited to synthesis, integration, glue, conflicts, final repairs, and Beads/PR closeout.
+
+#### Callback Contracts
+
+Implementation threads call back exactly once when the PR is ready, the task is complete but PR creation is blocked, or the phase is genuinely blocked. The callback includes the concrete orchestrator thread id, source thread id, Beads issue id, status, branch, PR, commits, turn doc, local gates, changed files, blockers, and context to keep.
+
+Review threads call back exactly once after review and CI are resolved. The callback includes the concrete orchestrator thread id, source thread id, Beads issue id, status, PR, CI state, review skill, repairs, remaining findings, turn doc, and context to keep.
+
+Prefer callback-driven coordination over polling. For long-running worker or reviewer threads, use a lightweight heartbeat around 30 minutes. Do not launch callback threads whose actual prompt text says only `current orchestrator thread`, `this thread`, or another generic callback target.
+
+#### Closeout
+
+Closeout verifies that the Beads epic and child phases are complete, checks the loop docs for unresolved blockers, and writes `storyboard-post-run-mm-dd-yyyy.html`.
+
+The storyboard should use `impeccable` when that skill is present. If it is missing, closeout still completes and records that it was skipped. Storyboard diffs use `@pierre/diffs/ssr`; closeout installs `@pierre/diffs` in the target repo first if it is missing.
+
+#### Examples
+
+- `skills/dirtyloops/examples/single-thread-subagent/` - Generated output for a one-thread coordinator loop.
+- `skills/dirtyloops/examples/orchestrator-callback/` - Generated output for the orchestrator, worker callback, and reviewer callback loop.
+
+## Conventions
+
+- Keep skill entrypoints short and route deeper behavior through reference files.
+- Put reusable examples next to the skill or template that owns them.
+- Prefer repo-relative paths in prompts and templates so assets can move between machines.
+- Treat Beads as canonical when a workflow tracks implementation phases, dependencies, blockers, or completion state.
+
+## Publishing
+
+This repo is intended to be pushed to Forgejo as `dirtydishes/skills` so the agent assets have a durable remote source. The npm package should be published as `@dirtydishes/skills` so `npx @dirtydishes/skills@latest ...` installs from the current catalog bundle.

package/bin/skills.js

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import readline from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(__dirname, "..");
+const catalog = readJson(path.join(packageRoot, "catalog", "skills.json"));
+const packageJson = readJson(path.join(packageRoot, "package.json"));
+
+main().catch((error) => {
+  console.error(`skills: ${error.message}`);
+  process.exit(1);
+});
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (!parsed.command) {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      await interactiveInstall(parsed);
+      return;
+    }
+
+    printHelp();
+    return;
+  }
+
+  switch (parsed.command) {
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+    case "list":
+      listSkills(parsed);
+      break;
+    case "install":
+    case "update":
+      installOrUpdate(parsed);
+      break;
+    case "doctor":
+      doctor(parsed);
+      break;
+    default:
+      throw new Error(`unknown command "${parsed.command}". Run "skills help".`);
+  }
+}
+
+async function interactiveInstall(parsed) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log("dirtydishes/skills");
+    console.log("");
+    catalog.skills.forEach((skill, index) => {
+      console.log(`${index + 1}. ${skill.name} - ${skill.description}`);
+    });
+    console.log("");
+
+    const answer = await rl.question("Install/update which skill? ");
+    const selected = Number.parseInt(answer.trim(), 10);
+    if (!Number.isInteger(selected) || selected < 1 || selected > catalog.skills.length) {
+      throw new Error("selection cancelled or invalid");
+    }
+
+    const includeRecommended = await rl.question("Install recommended skills when packaged? [y/N] ");
+    const skill = catalog.skills[selected - 1];
+    installOrUpdate({
+      ...parsed,
+      command: "install",
+      positionals: [skill.name],
+      flags: {
+        ...parsed.flags,
+        withRecommended: /^y(es)?$/i.test(includeRecommended.trim())
+      }
+    });
+  } finally {
+    rl.close();
+  }
+}
+
+function listSkills(parsed) {
+  const sourceRoot = resolveSourceRoot(parsed);
+  for (const skill of catalog.skills) {
+    const packaged = hasPackagedSkill(skill.name, sourceRoot);
+    console.log(`${skill.name}${packaged ? "" : " (not packaged)"}`);
+    console.log(`  ${skill.description}`);
+    if (skill.requiresTools?.length) {
+      console.log(`  requires tools: ${skill.requiresTools.map((tool) => tool.name).join(", ")}`);
+    }
+    if (skill.requiresSkills?.length) {
+      console.log(`  requires skills: ${skill.requiresSkills.map((dep) => dep.name).join(", ")}`);
+    }
+    if (skill.recommendsSkills?.length) {
+      console.log(`  recommends skills: ${skill.recommendsSkills.map((dep) => dep.name).join(", ")}`);
+    }
+  }
+}
+
+function installOrUpdate(parsed) {
+  const selected = selectSkills(parsed);
+  const sourceRoot = resolveSourceRoot(parsed);
+  const targetRoot = resolveTargetRoot(parsed);
+  const includeRequired = parsed.flags.withRequired !== false;
+  const includeRecommended = parsed.flags.withRecommended === true;
+  const installPlan = buildInstallPlan(selected, sourceRoot, targetRoot, {
+    includeRequired,
+    includeRecommended
+  });
+
+  for (const warning of installPlan.warnings) {
+    log(parsed, `warning: ${warning}`);
+  }
+
+  for (const skillName of installPlan.skillNames) {
+    copySkill(skillName, sourceRoot, targetRoot);
+    const pastTense = parsed.command === "install" ? "installed" : "updated";
+    log(parsed, `${pastTense} ${skillName} -> ${path.join(targetRoot, skillName)}`);
+  }
+
+  const doctorResult = checkSkills(selected, sourceRoot, targetRoot);
+  printDoctorResult(doctorResult, parsed);
+  if (!doctorResult.ok) {
+    process.exitCode = 1;
+  }
+}
+
+function doctor(parsed) {
+  const selected = selectSkills(parsed, { defaultAll: true });
+  const sourceRoot = resolveSourceRoot(parsed);
+  const targetRoot = resolveTargetRoot(parsed);
+  const result = checkSkills(selected, sourceRoot, targetRoot);
+  printDoctorResult(result, parsed);
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+
+function buildInstallPlan(selected, sourceRoot, targetRoot, options) {
+  const seen = new Set();
+  const skillNames = [];
+  const warnings = [];
+
+  function visit(skillName, dependencyKind = "requested") {
+    if (seen.has(skillName)) return;
+    seen.add(skillName);
+
+    const skill = getCatalogSkill(skillName);
+    if (skill && options.includeRequired) {
+      for (const dep of skill.requiresSkills ?? []) {
+        if (hasPackagedSkill(dep.name, sourceRoot)) {
+          visit(dep.name, "required");
+        } else if (!isInstalledSkill(dep.name, targetRoot)) {
+          warnings.push(`${skill.name} requires ${dep.name}, but that skill is not packaged in ${catalog.package} ${packageJson.version} and is not installed in ${targetRoot}.`);
+        }
+      }
+    }
+
+    if (skill && options.includeRecommended) {
+      for (const dep of skill.recommendsSkills ?? []) {
+        if (hasPackagedSkill(dep.name, sourceRoot)) {
+          visit(dep.name, "recommended");
+        } else if (!isInstalledSkill(dep.name, targetRoot)) {
+          warnings.push(`${skill.name} recommends ${dep.name}, but that skill is not packaged in ${catalog.package} ${packageJson.version} and is not installed in ${targetRoot}.`);
+        }
+      }
+    }
+
+    if (!hasPackagedSkill(skillName, sourceRoot)) {
+      if (dependencyKind === "requested") {
+        throw new Error(`${skillName} is not packaged in ${catalog.package} ${packageJson.version}`);
+      }
+      return;
+    }
+
+    skillNames.push(skillName);
+  }
+
+  for (const skill of selected) {
+    visit(skill.name);
+  }
+
+  return { skillNames, warnings };
+}
+
+function checkSkills(selected, sourceRoot, targetRoot) {
+  const checks = [];
+  let ok = true;
+
+  for (const skill of selected) {
+    const skillCheck = {
+      name: skill.name,
+      packaged: hasPackagedSkill(skill.name, sourceRoot),
+      installed: isInstalledSkill(skill.name, targetRoot),
+      requiredTools: [],
+      requiredSkills: [],
+      recommendedSkills: []
+    };
+
+    if (!skillCheck.installed) ok = false;
+
+    for (const tool of skill.requiresTools ?? []) {
+      const found = commandWorks(tool.command, tool.args ?? []);
+      skillCheck.requiredTools.push({ ...tool, found });
+      if (!found) ok = false;
+    }
+
+    for (const dep of skill.requiresSkills ?? []) {
+      const installed = isInstalledSkill(dep.name, targetRoot);
+      const packaged = hasPackagedSkill(dep.name, sourceRoot);
+      skillCheck.requiredSkills.push({ ...dep, installed, packaged });
+      if (!installed) ok = false;
+    }
+
+    for (const dep of skill.recommendsSkills ?? []) {
+      const installed = isInstalledSkill(dep.name, targetRoot);
+      const packaged = hasPackagedSkill(dep.name, sourceRoot);
+      skillCheck.recommendedSkills.push({ ...dep, installed, packaged });
+    }
+
+    checks.push(skillCheck);
+  }
+
+  return { ok, targetRoot, checks };
+}
+
+function printDoctorResult(result, parsed) {
+  if (parsed.flags.quiet && result.ok) return;
+
+  console.log("");
+  console.log(`doctor target: ${result.targetRoot}`);
+  for (const check of result.checks) {
+    console.log(`${status(check.installed)} ${check.name} installed${check.packaged ? "" : " (not packaged)"}`);
+
+    for (const tool of check.requiredTools) {
+      console.log(`  ${status(tool.found)} required tool: ${tool.name}`);
+    }
+    for (const dep of check.requiredSkills) {
+      const packageNote = dep.packaged ? "packaged" : "not packaged";
+      console.log(`  ${status(dep.installed)} required skill: ${dep.name} (${packageNote})`);
+    }
+    for (const dep of check.recommendedSkills) {
+      const packageNote = dep.packaged ? "packaged" : "not packaged";
+      console.log(`  ${dep.installed ? "ok" : "--"} recommended skill: ${dep.name} (${packageNote})`);
+    }
+  }
+}
+
+function copySkill(skillName, sourceRoot, targetRoot) {
+  const source = skillSourcePath(skillName, sourceRoot);
+  const target = path.join(targetRoot, skillName);
+  if (!fs.existsSync(path.join(source, "SKILL.md"))) {
+    throw new Error(`${skillName} is missing SKILL.md at ${source}`);
+  }
+
+  fs.mkdirSync(targetRoot, { recursive: true });
+  fs.rmSync(target, { recursive: true, force: true });
+  fs.cpSync(source, target, { recursive: true, force: true });
+  fs.writeFileSync(
+    path.join(target, ".dirtydishes-skill.json"),
+    `${JSON.stringify(
+      {
+        package: catalog.package,
+        packageVersion: packageJson.version,
+        repo: catalog.repo,
+        skill: skillName,
+        installedAt: new Date().toISOString()
+      },
+      null,
+      2
+    )}\n`
+  );
+}
+
+function selectSkills(parsed, options = {}) {
+  if (parsed.flags.all) return catalog.skills;
+  const names = parsed.positionals.length ? parsed.positionals : [];
+  if (!names.length && options.defaultAll) return catalog.skills;
+  if (!names.length) {
+    throw new Error("missing skill name. Use --all or run \"skills list\".");
+  }
+
+  return names.map((name) => {
+    const skill = getCatalogSkill(name);
+    if (!skill) {
+      throw new Error(`unknown skill "${name}". Run "skills list".`);
+    }
+    return skill;
+  });
+}
+
+function getCatalogSkill(name) {
+  return catalog.skills.find((skill) => skill.name === name);
+}
+
+function skillSourcePath(skillName, sourceRoot) {
+  const skill = getCatalogSkill(skillName);
+  const relativePath = skill?.path ?? `skills/${skillName}`;
+  return path.join(sourceRoot, relativePath);
+}
+
+function hasPackagedSkill(skillName, sourceRoot) {
+  return fs.existsSync(path.join(skillSourcePath(skillName, sourceRoot), "SKILL.md"));
+}
+
+function isInstalledSkill(skillName, targetRoot) {
+  return fs.existsSync(path.join(targetRoot, skillName, "SKILL.md"));
+}
+
+function commandWorks(command, args) {
+  const result = spawnSync(command, args, { stdio: "ignore" });
+  return result.status === 0;
+}
+
+function resolveSourceRoot(parsed) {
+  return path.resolve(expandHome(parsed.flags.sourceDir ?? packageRoot));
+}
+
+function resolveTargetRoot(parsed) {
+  return path.resolve(expandHome(parsed.flags.targetDir ?? catalog.defaultTargetDir));
+}
+
+function expandHome(value) {
+  if (value === "~") return os.homedir();
+  if (value.startsWith("~/")) return path.join(os.homedir(), value.slice(2));
+  return value;
+}
+
+function parseArgs(args) {
+  const flags = {
+    withRequired: true
+  };
+  const positionals = [];
+  let command = null;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!command && !arg.startsWith("-")) {
+      command = arg;
+      continue;
+    }
+
+    if (arg === "--all") flags.all = true;
+    else if (arg === "--with-required") flags.withRequired = true;
+    else if (arg === "--no-required") flags.withRequired = false;
+    else if (arg === "--with-recommended") flags.withRecommended = true;
+    else if (arg === "--yes" || arg === "-y") flags.yes = true;
+    else if (arg === "--quiet" || arg === "-q") flags.quiet = true;
+    else if (arg === "--target-dir") {
+      index += 1;
+      flags.targetDir = args[index];
+    } else if (arg.startsWith("--target-dir=")) {
+      flags.targetDir = arg.slice("--target-dir=".length);
+    } else if (arg === "--source-dir") {
+      index += 1;
+      flags.sourceDir = args[index];
+    } else if (arg.startsWith("--source-dir=")) {
+      flags.sourceDir = arg.slice("--source-dir=".length);
+    } else if (arg.startsWith("-")) {
+      throw new Error(`unknown flag "${arg}"`);
+    } else {
+      positionals.push(arg);
+    }
+  }
+
+  return { command, flags, positionals };
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function status(ok) {
+  return ok ? "ok" : "!!";
+}
+
+function log(parsed, message) {
+  if (!parsed.flags.quiet) console.log(message);
+}
+
+function printHelp() {
+  console.log(`dirtydishes/skills (${catalog.package})
+
+Usage:
+  skills list
+  skills install <skill> [--with-recommended]
+  skills update <skill> [--with-recommended]
+  skills update --all [--with-recommended]
+  skills doctor [skill]
+
+Examples:
+  npx @dirtydishes/skills@latest install dirtyloops
+  npx @dirtydishes/skills@latest update dirtyloops --with-recommended
+  npx @dirtydishes/skills@latest doctor dirtyloops
+
+Flags:
+  --all                 Select all catalog skills
+  --with-required       Include packaged required skill dependencies (default)
+  --no-required         Do not include required skill dependencies
+  --with-recommended    Include packaged recommended skill dependencies
+  --target-dir <path>   Install target, default ${catalog.defaultTargetDir}
+  --source-dir <path>   Source root, default this package
+  --quiet               Reduce successful output
+`);
+}

package/catalog/skills.json

@@ -0,0 +1,32 @@
+{
+  "package": "@dirtydishes/skills",
+  "repo": "dirtydishes/skills",
+  "defaultTargetDir": "~/.agents/skills",
+  "skills": [
+    {
+      "name": "dirtyloops",
+      "path": "skills/dirtyloops",
+      "description": "Beads-canonical Codex implementation loops with phase docs, review/CI contracts, and storyboard closeout.",
+      "requiresTools": [
+        {
+          "name": "bd",
+          "command": "bd",
+          "args": ["--version"],
+          "description": "Beads CLI. Dirtyloops uses Beads as the canonical issue and loop-state layer."
+        }
+      ],
+      "requiresSkills": [
+        {
+          "name": "thermo-nuclear-code-quality-review",
+          "description": "Required reviewer skill for strict dirtyloops review phases."
+        }
+      ],
+      "recommendsSkills": [
+        {
+          "name": "impeccable",
+          "description": "Recommended for polished storyboard closeout artifacts."
+        }
+      ]
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@dirtydishes/skills",
+  "version": "0.1.1",
+  "description": "Installer and catalog for dirtydishes agent skills.",
+  "type": "module",
+  "bin": {
+    "skills": "./bin/skills.js"
+  },
+  "files": [
+    "bin/",
+    "catalog/",
+    "skills/",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "ssh://ssh.git.dirtydishes.dev/dirtydishes/skills.git"
+  },
+  "scripts": {
+    "test": "node --check bin/skills.js && node bin/skills.js list"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "UNLICENSED"
+}