Skip to content

simiancraft/simiancraft-skills / skills/burn-down-github-issues

burn-down-github-issues

Unverified

Run an unattended burndown of a GitHub issue backlog as cards on a per-operator GitHub Projects board whose lanes are an explicit state machine: appraise and size the inbox, carve what is over the ceiling, fix the ready ones in parallel git worktrees, prove each fix on a draft pull request, have an isolated second-engine reviewer judge it, land one branch at a time with freshness checks, and dead-letter per phase whatever a machine cannot finish. Use when the task is "work the backlog unattended", "triage and fix recent issues", "run the issue loop", "burn down issues", or "where is issue N on the board". Requires a per-repository burn-down-github-issues.config.ts at the target repo's root (the loop refuses to start without it), the prove-work-on-github skill, the codex and claude CLIs for the default seats, and a gh token with the project scope for the board. Skip for one-off fixes to a known issue you are already working interactively, and for backlogs whose issues are mostly product decisions rather than code.

FileKindSize
SKILL.mdskill md17.0 KB
board.tsscript6.5 KB
callbacks/README.mdmarkdown1.1 KB
callbacks/on-size-over-ceilingother843 B
card.tsscript4.3 KB
chart-machine.tsscript3.9 KB
claim-race.tsscript6.1 KB
export-machine.tsscript1.8 KB
lanes.tsscript5.2 KB
lib/admission.test.tsscript7.6 KB
lib/admission.tsscript5.5 KB
lib/board-writer.test.tsscript3.6 KB
lib/board-writer.tsscript11.8 KB
lib/carving-revisit.test.tsscript7.5 KB
lib/carving.tsscript26.9 KB
lib/floor/config.test.tsscript456 B
lib/floor/config.tsscript8.1 KB
lib/floor/floor.test.tsscript9.9 KB
lib/floor/floor.tsscript28.7 KB
lib/floor/incident.tsscript11.2 KB
lib/floor/ledger.tsscript5.6 KB
lib/floor/probe.tsscript3.6 KB
lib/lanes.tsscript4.4 KB
lib/machine.test.tsscript11.2 KB
lib/machine.tsscript52.4 KB
lib/place-callbacks.test.tsscript2.5 KB
lib/place-callbacks.tsscript3.0 KB
lib/preflight.test.tsscript4.5 KB
lib/preflight.tsscript1.2 KB
lib/pressure.test.tsscript56.9 KB
lib/refs.test.tsscript1010 B
lib/refs.tsscript1.9 KB
lib/run-scope.test.tsscript5.4 KB
lib/run-scope.tsscript1.2 KB
lib/scenarios.test.tsscript17.1 KB
lib/simulate.test.tsscript7.3 KB
lib/simulate.tsscript7.0 KB
lib/world-sweep.test.tsscript21.4 KB
loop.source.test.tsscript4.8 KB
loop.tsscript66.2 KB
prompts/diagnose.mdmarkdown2.1 KB
prompts/walk.mdmarkdown3.6 KB
references/adopting.mdmarkdown26.3 KB
references/architecture.mdmarkdown20.7 KB
references/floor.mdmarkdown14.6 KB
references/operating.mdmarkdown19.6 KB
references/state-machine.mdmarkdown31.1 KB
status.tsscript4.9 KB
watch.tsscript6.4 KB

chart-machine.ts

View on GitHub
#!/usr/bin/env bun
/**
 * Render the burndown's state machine as a Graphviz chart, one cluster per phase, so the shape
 * can be looked at rather than read:
 *
 *   bun run <skill-dir>/chart-machine.ts > burndown.dot && dot -Tsvg burndown.dot > burndown.svg
 *   bun run <skill-dir>/chart-machine.ts --phase carving   # one phase and its exits only
 *
 * Ticket-wide transitions (issue closed, a person's hold, a foreign claim, run start) are drawn
 * once from a single node rather than from every state, or they would bury the chart. The
 * reconcile state's always-transitions are drawn dashed. Nothing here is read by the loop.
 */

import { LANES, laneByKey, PHASES } from './lib/lanes.ts';
import { MACHINE, transitions, walk } from './lib/machine.ts';

const args = process.argv.slice(2);
const only = args.includes('--phase') ? args[args.indexOf('--phase') + 1] : undefined;

const COLORS: Record<string, string> = {
  GRAY: '#d0d7de', BLUE: '#b6e3ff', GREEN: '#aceebb', YELLOW: '#fae17d', ORANGE: '#ffd8b5', RED: '#ffcecb', PINK: '#ffc8e6', PURPLE: '#d8b9ff',
};

const phaseOf = (path: string): string | undefined => path.split('.')[1];
const lines: string[] = [];
lines.push('digraph burndown {');
lines.push('  rankdir=LR; fontname="Helvetica"; node [fontname="Helvetica", shape=box, style="rounded,filled"]; edge [fontname="Helvetica", fontsize=9];');

const phases = Object.keys(PHASES) as Array<keyof typeof PHASES>;
const phaseDirs: Record<string, string> = {
  appraisal: 'ticket.appraisal', ready: 'ticket.ready', carving: 'ticket.carving', work: 'ticket.work', review: 'ticket.review',
  landing: 'ticket.landing', waits: 'ticket.waits', 'dead-letters': 'ticket.deadLetters', human: 'ticket.human', terminal: 'ticket.terminal',
};
const keep = (path: string) => !only || path.startsWith(phaseDirs[only]) || path === 'ticket.reconcile';

for (const phase of phases) {
  const dir = phaseDirs[phase];
  const members = walk().filter(([path, node]) => path.startsWith(`${dir}.`) && node.lane && keep(path));
  if (members.length === 0) continue;
  lines.push(`  subgraph "cluster_${phase}" { label="${PHASES[phase].emoji} ${PHASES[phase].label}"; style="rounded"; color="gray50";`);
  for (const [path, node] of members) {
    const lane = laneByKey((node.lane as { key: string }).key);
    const entry = (node.entry ?? []).filter((a) => a !== 'moveCard').join('\\n');
    lines.push(`    "${path}" [label="${lane.key} ${lane.name}${entry ? `\\n${entry}` : ''}", fillcolor="${COLORS[PHASES[phase].color]}"];`);
  }
  lines.push('  }');
}
lines.push('  "ticket.reconcile" [label="reconcile", shape=diamond, fillcolor="#ffffff"];');
lines.push('  "ticket.offBoard" [label="off the board", shape=doublecircle, fillcolor="#ffffff"];');
lines.push('  "ticket-wide" [label="any ticket state", shape=plaintext, fillcolor="#ffffff"];');

for (const { from, event, transition } of transitions()) {
  if (from === 'line' || from.startsWith('line.')) continue;
  const source = from === 'ticket' ? 'ticket-wide' : from;
  if (!keep(source) && source !== 'ticket-wide') continue;
  if (only && !keep(transition.target) && source !== 'ticket-wide') {
    // an exit from the chosen phase into another: draw the target as a plain node
    lines.push(`  "${transition.target}" [label="${transition.target.replace('ticket.', '')}", fillcolor="#ffffff"];`);
  }
  if (only && source === 'ticket-wide' && !keep(transition.target)) continue;
  // In a phase chart the reconcile fan-out is drawn only where it lands inside the phase.
  if (only && source === 'ticket.reconcile' && !transition.target.startsWith(phaseDirs[only])) continue;
  const label = event === 'always' ? (transition.guard ?? '') : `${event}${transition.guard ? `\\n[${transition.guard}]` : ''}`;
  const style = event === 'always' ? ', style=dashed' : '';
  lines.push(`  "${source}" -> "${transition.target}" [label="${label}"${style}];`);
}
lines.push('}');
console.log(lines.join('\n'));
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall