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/floor/probe.ts

View on GitHub
/**
 * What a walk learns before any agent runs. The liveness probe requests each health path under the
 * base URL with a short timeout; "up" means every path answered 2xx or 3xx. A path may be a string
 * (GET) or an object naming a method and body, so an API that rejects GET (a GraphQL endpoint with
 * CSRF protection) can still be probed with the request it accepts. The revision helpers turn the
 * propagation race into a state rather than a guess: `not-yet-deployed` when a merge is not an
 * ancestor of the deployed revision, `unverified` when there is no revision signal and the merge is
 * inside the grace window, and "walk it" otherwise.
 */

export type HealthPath = string | { path: string; method?: string; body?: string; headers?: Record<string, string> };

export type ProbeResult = {
  up: boolean;
  results: Array<{ path: string; status: number | null; ms: number; error?: string }>;
};

export async function probe(baseUrl: string, healthPaths: HealthPath[], timeoutMs = 10_000): Promise<ProbeResult> {
  const results: ProbeResult['results'] = [];
  const paths: HealthPath[] = healthPaths.length > 0 ? healthPaths : ['/'];
  for (const entry of paths) {
    const spec = typeof entry === 'string' ? { path: entry } : entry;
    const url = new URL(spec.path, baseUrl).toString();
    const started = Date.now();
    try {
      const response = await fetch(url, {
        method: spec.method ?? 'GET',
        body: spec.body,
        headers: spec.headers,
        redirect: 'manual',
        signal: AbortSignal.timeout(timeoutMs),
      });
      results.push({ path: spec.path, status: response.status, ms: Date.now() - started });
    } catch (error) {
      results.push({ path: spec.path, status: null, ms: Date.now() - started, error: (error as Error).message });
    }
  }
  const up = results.every((r) => r.status !== null && r.status >= 200 && r.status < 400);
  return { up, results };
}

export function describe(result: ProbeResult): string {
  return result.results
    .map((r) => `${r.path} ${r.status ?? 'no response'}${r.error ? ` (${r.error})` : ''} ${r.ms}ms`)
    .join('; ');
}

export type Pending = 'not-yet-deployed' | 'unverified' | null;

/**
 * Runs the configured revision command and returns the first 7-to-40 hex run in its stdout, or
 * null when the command is unset, fails, or prints no SHA.
 */
export function deployedRevision(command: string | undefined, cwd: string): string | null {
  if (!command) return null;
  const proc = Bun.spawnSync(['sh', '-c', command], { cwd, stderr: 'pipe', timeout: 60_000 });
  if (proc.exitCode !== 0) return null;
  const match = proc.stdout.toString().match(/\b[0-9a-f]{7,40}\b/);
  return match ? match[0] : null;
}

/** True when `sha` is an ancestor of (or equal to) `deployed` in the repository at `repoRoot`. */
export function includesCommit(repoRoot: string, deployed: string, sha: string): boolean {
  const proc = Bun.spawnSync(['git', 'merge-base', '--is-ancestor', sha, deployed], { cwd: repoRoot, stderr: 'pipe' });
  return proc.exitCode === 0;
}

/** Classifies an item before any agent runs. An item without a merge SHA is always walked. */
export function classify(options: {
  deployed: string | null;
  sha?: string;
  mergedAt?: string;
  graceMinutes: number;
  repoRoot: string;
  now?: number;
}): Pending {
  const { deployed, sha, mergedAt, graceMinutes, repoRoot } = options;
  const now = options.now ?? Date.now();
  if (!sha) return null;
  if (deployed) return includesCommit(repoRoot, deployed, sha) ? null : 'not-yet-deployed';
  if (mergedAt && now - Date.parse(mergedAt) < graceMinutes * 60_000) return 'unverified';
  return 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