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

lib/lanes.ts

View on GitHub
/**
 * The lanes: the burndown's state machine as the Status options of an operator's board, derived
 * from `machine.ts`, which is the one source. A lane is a leaf state of the ticket region that
 * carries a `lane` spec; the board order is the machine's declaration order, and the phase is the
 * state's compound parent. The lane is the fine state; the phase is the coarse view a person or
 * the console collapses to, and it is derived from the lane, never the other way around.
 *
 * Keys (A1, C5, Q3) are the stable identifiers code uses; names are what the board shows and what
 * the lane writer matches on. Colors are GitHub's eight; a phase shares one, and the emoji prefix
 * carries the phase where colors run out.
 */

import { MACHINE, type Phase, PHASE_OF_STATE, walk } from './machine.ts';

export type { Phase } from './machine.ts';

export type LaneColor = 'GRAY' | 'BLUE' | 'GREEN' | 'YELLOW' | 'ORANGE' | 'RED' | 'PINK' | 'PURPLE';

export type Lane = {
  key: string;
  phase: Phase;
  name: string;
  description: string;
  /** The state path in the machine, `ticket.work.coding`. */
  state: string;
};

export const PHASES: Record<Phase, { label: string; emoji: string; color: LaneColor; description: string }> = {
  appraisal: { label: 'Appraisal', emoji: '📏', color: 'BLUE', description: 'Is it real, and how big; read-only' },
  ready: { label: 'Ready', emoji: '🟢', color: 'GREEN', description: 'Sized leaf waiting for a worker' },
  carving: { label: 'Carving', emoji: '🔪', color: 'PURPLE', description: 'Too big; being cut into children, or held while they move' },
  work: { label: 'Work', emoji: '🔨', color: 'YELLOW', description: 'A worker in a worktree: code, prove, draft' },
  review: { label: 'Review', emoji: '🔍', color: 'ORANGE', description: 'A second engine judges the evidence' },
  landing: { label: 'Landing', emoji: '🚀', color: 'GREEN', description: 'The serial pull master: freshness, checks, smoke, merge' },
  waits: { label: 'Waits', emoji: '⏳', color: 'GRAY', description: 'Nothing is wrong; something else must move first' },
  'dead-letters': { label: 'Dead letters', emoji: '☠️', color: 'RED', description: 'A machine gave up; its triage may retry' },
  panel: { label: 'Panel', emoji: '⚖️', color: 'ORANGE', description: 'Frontier models test whether a person must decide; read-only' },
  human: { label: 'Human', emoji: '🙋', color: 'PINK', description: 'Only a person can move it' },
  terminal: { label: 'Done', emoji: '✅', color: 'GRAY', description: 'Closed' },
};

/** Every lane, in board order (left to right): the machine's leaf states that carry a lane spec. */
export const LANES: readonly Lane[] = walk(MACHINE)
  .filter(([path, node]) => path.startsWith('ticket.') && node.lane)
  .map(([path, node]) => {
    const phase = PHASE_OF_STATE[path.split('.')[1]];
    if (!phase) throw new Error(`state ${path} carries a lane but sits in no known phase`);
    const spec = node.lane as NonNullable<typeof node.lane>;
    return { key: spec.key, phase, name: spec.name, description: spec.description, state: path };
  });

/** What the board shows for a lane: the phase emoji, then the name. */
export function laneLabel(lane: Lane): string {
  return `${PHASES[lane.phase].emoji} ${lane.name}`;
}

export function laneByKey(key: string): Lane {
  const lane = LANES.find((l) => l.key === key);
  if (!lane) throw new Error(`no lane with key ${key}`);
  return lane;
}

/** The lane a displayed option name denotes, or undefined for an option the table does not know. */
export function laneByLabel(label: string): Lane | undefined {
  return LANES.find((l) => laneLabel(l) === label);
}

/** The board's Phase option name for a lane. */
export function phaseLabel(phase: Phase): string {
  return `${PHASES[phase].emoji} ${PHASES[phase].label}`;
}

/** The GitHub option payload for the Status field: the whole set, in board order. */
export function statusOptions(): Array<{ name: string; color: LaneColor; description: string }> {
  return LANES.map((lane) => ({ name: laneLabel(lane), color: PHASES[lane.phase].color, description: lane.description }));
}

/** The GitHub option payload for the Phase field: one per phase, in board order. */
export function phaseOptions(): Array<{ name: string; color: LaneColor; description: string }> {
  return (Object.keys(PHASES) as Phase[]).map((phase) => ({
    name: phaseLabel(phase),
    color: PHASES[phase].color,
    description: PHASES[phase].description,
  }));
}
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