simiancraft/simiancraft-skills / skills/burn-down-github-issues
burn-down-github-issues
UnverifiedRun 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.
status.ts
View on GitHub/**
* 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;
};
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| 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: 471k | Updated | Claude CodeCodex | Verified | Install |
| 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: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| 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 available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |