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
/**
 * Operator feedback: the console's view of the board. Every card the run has touched is printed as
 * one emoji line on every lane change (trigger) and as a whole on a cadence (pulse), so a person or
 * an agent watching the console can tell at a glance where each issue is, whether the line is
 * paused, and for how long. On by default; `--silent` turns the pulse and the trigger lines off,
 * and the timestamped driver log is unaffected either way.
 *
 * The vocabulary is the lane table (`lib/lanes.ts`): a card is in a lane, the line shows the
 * lane's phase emoji and name, and the pulse counts cards per phase, which is the same collapse
 * the board's Phase field makes. The console and the GitHub board are two projections of one
 * `place` call; neither has a word the other lacks.
 *
 * Line shape: 🎫 #1234  βœ… Merged  🟒 active  ⏱ 14:56 3/3/2026  fix(search): return a page
 */

import { type Lane, laneByKey, PHASES } from './lib/lanes.ts';

type Card = { title: string; lane: Lane; note: string; at: Date };

export type LineState = { state: 'active' | 'paused'; since: Date; reason: string };

let silent = false;
const board = new Map<number, Card>();
let line: LineState = { state: 'active', since: new Date(), reason: '' };
let pulseTimer: ReturnType<typeof setInterval> | null = null;

export function configureStatus(options: { silent: boolean }): void {
  silent = options.silent;
}

/** Board stamps are local wall-clock time, the operator's clock; the driver log stays UTC. */
export function stamp(date = new Date()): string {
  const hh = String(date.getHours()).padStart(2, '0');
  const mm = String(date.getMinutes()).padStart(2, '0');
  const ss = String(date.getSeconds()).padStart(2, '0');
  return `${hh}:${mm}:${ss} ${date.getMonth() + 1}/${date.getDate()}/${date.getFullYear()}`;
}

export function elapsed(since: Date, now = new Date()): string {
  const seconds = Math.max(0, Math.floor((now.getTime() - since.getTime()) / 1000));
  const h = Math.floor(seconds / 3600);
  const m = Math.floor((seconds % 3600) / 60);
  const s = seconds % 60;
  if (h > 0) return `${h}h ${m}m`;
  if (m > 0) return `${m}m ${s}s`;
  return `${s}s`;
}

function lineText(now = new Date()): string {
  return line.state === 'paused' ? `⏸️ paused ${elapsed(line.since, now)}` : '🟒 active';
}

/** One line of display text: whatever it was, coerced to a string with control characters removed. */
function oneLine(value: unknown): string {
  return String(value ?? '')
    .replace(/[\x00-\x1f\x7f]/g, ' ')
    .replace(/\s+/g, ' ')
    .trim();
}

function cardText(issue: number, card: Card, now = new Date()): string {
  const full = oneLine(card.title);
  const title = full.length > 60 ? `${full.slice(0, 57)}...` : full;
  const note = card.note ? `  (${oneLine(card.note)})` : '';
  return `🎫 #${issue}  ${PHASES[card.lane.phase].emoji} ${card.lane.name}${note}  ${lineText(now)}  ⏱ ${stamp(card.at)}  ${title}`;
}

/** Records the lane an issue's card is in and prints its line now, unless `--silent`. */
export function mark(issue: number, title: string, lane: string, note = ''): void {
  const card: Card = { title, lane: laneByKey(lane), note, at: new Date() };
  board.set(issue, card);
  if (!silent) console.log(cardText(issue, card));
}

/** Records the line state; a change is printed now, unless `--silent`. */
export function setLine(state: 'active' | 'paused', reason = ''): void {
  if (line.state === state) return;
  line = { state, since: new Date(), reason };
  if (!silent) console.log(state === 'paused' ? `⏸️ line paused${reason ? `: ${reason}` : ''}` : `🟒 line active again`);
}

export function lineState(): LineState {
  return line;
}

/** The whole board, printed on the cadence and at the end of a run; the summary counts per phase. */
export function pulse(label = 'pulse'): void {
  if (silent) return;
  const now = new Date();
  const counts = new Map<Lane['phase'], number>();
  for (const card of board.values()) counts.set(card.lane.phase, (counts.get(card.lane.phase) ?? 0) + 1);
  const summary = (Object.keys(PHASES) as Lane['phase'][])
    .filter((phase) => counts.has(phase))
    .map((phase) => `${PHASES[phase].emoji} ${counts.get(phase)} ${PHASES[phase].label.toLowerCase()}`)
    .join('  ');
  console.log(`\nπŸ’“ ${label}  ${lineText(now)}${line.state === 'paused' && line.reason ? ` (${line.reason})` : ''}  ⏱ ${stamp(now)}  ${summary || 'nothing touched yet'}`);
  for (const [issue, card] of [...board.entries()].sort((a, b) => b[1].at.getTime() - a[1].at.getTime())) {
    console.log(`   ${cardText(issue, card, now)}`);
  }
  console.log('');
}

/** Starts the cadence; the timer never keeps the process alive. Returns the stop function. */
export function startPulse(minutes: number): () => void {
  if (silent || pulseTimer) return () => {};
  pulseTimer = setInterval(() => pulse(), minutes * 60 * 1000);
  pulseTimer.unref();
  return () => {
    if (pulseTimer) clearInterval(pulseTimer);
    pulseTimer = null;
  };
}
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