Agent skill

Investigating Kilroy Runs

by danshapiro in danshapiro/kilroy

To diagnose active, stuck, or failed Kilroy Attractor runs, inspect run artifacts (manifest.json, live.json, checkpoint.json, final.json, progress.ndjson), resolve run IDs/log roots, identify…

MITAuto-check passedDevelopment

Install Investigating Kilroy Runs

skills CLI
$ npx skills add danshapiro/kilroy --skill investigating-kilroy-runs -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install danshapiro/kilroy investigating-kilroy-runs --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/danshapiro/kilroy.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/investigating-kilroy-runs .claude/skills/investigating-kilroy-runs && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
investigating-kilroy-runs
GitHub stars
222
Token cost
~3.1k tokens
SKILL.md length
774 words
Files
2
Skills in repo
7
Repo updated
First seen
Licence
MIT

At a glance

To diagnose active, stuck, or failed Kilroy Attractor runs, inspect run artifacts (manifest.json, live.json, checkpoint.json, final.json, progress.ndjson), resolve run IDs/log roots, identify…

  • Works in 3 steps: To resolve run root with highest… → To infer run root when no path is… → To keep later commands consistent, treat…
  • Tasks that involve Model routing and gateways
  • SKILL.md covers Resolve Run Root, CXDB: Launch, UI, and Query, Read Canonical Files and Determine Current State, plus 11 more sections
  • Calls rg, jq and curl

What it does

Investigating Kilroy Runs is an agent skill from danshapiro/kilroy. To diagnose active, stuck, or failed Kilroy Attractor runs, inspect run artifacts (manifest.json, live.json, checkpoint.json, final.json, progress.ndjson), resolve run IDs/log roots, identify model/provider routing, and isolate failure causes. Includes CXDB operations for launching/probing CXDB, opening the CXDB UI, and querying run context turns. This skill is useful when investigating run status, debugging retries/failures, explaining model usage, or inspecting CXDB-backed event history.

Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `agents/openai.yaml`).

It sits in Development, covering Model routing and gateways. The licence is MIT.

When your agent uses it

  • Tasks that involve Model routing and gateways

Example prompts

  • “/investigating-kilroy-runs”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. To resolve run root with highest confidence, start from an explicit --logs-root path when provided.
  2. To infer run root when no path is provided, locate the newest run under ~/.local/state/kilroy/attractor/runs.
  3. To keep later commands consistent, treat that directory as RUN_ROOT.

What it can do on your machine

Read from SKILL.md and the folder at commit b55fb0f. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • rg
    • jq
    • curl
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use curl and git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Investigating Kilroy Runs loads about 3.1k tokens when it runs. Until then it costs about 133 tokens; SKILL.md has 774 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~133
When it runs · the whole SKILL.md, loaded when a task matches
~3.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from danshapiro/kilroy at commit b55fb0f, republished under its MIT licence (© danshapiro). 774 words, ~3,059 tokens.

Download SKILL.mdSave it as .claude/skills/investigating-kilroy-runs/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
investigating-kilroy-runs
description
To diagnose active, stuck, or failed Kilroy Attractor runs, inspect run artifacts (`manifest.json`, `live.json`, `checkpoint.json`, `final.json`, `progress.ndjson`), resolve run IDs/log roots, identify model/provider routing, and isolate failure causes. Includes CXDB operations for launching/probing CXDB, opening the CXDB UI, and querying run context turns. This skill is useful when investigating run status, debugging retries/failures, explaining model usage, or inspecting CXDB-backed event history.

Investigating Kilroy Runs

To inspect a run quickly and produce a precise diagnosis, follow this workflow.

Resolve Run Root

  1. To resolve run root with highest confidence, start from an explicit --logs-root path when provided.
  2. To infer run root when no path is provided, locate the newest run under ~/.local/state/kilroy/attractor/runs.
  3. To keep later commands consistent, treat that directory as RUN_ROOT.
bash
RUNS="$HOME/.local/state/kilroy/attractor/runs"
RUN_ID="$(find "$RUNS" -mindepth 1 -maxdepth 1 -type d -printf '%T@ %f\n' | sort -nr | awk 'NR==1 {id=$2} END {print id}')"
RUN_ROOT="$RUNS/$RUN_ID"
echo "$RUN_ID"

For a quick check of the newest run without manually resolving RUN_ROOT, use:

bash
./kilroy attractor status --latest --json

CXDB: Launch, UI, and Query

To get CXDB connection details, start with manifest.json, then fall back to run_config.json and live artifacts when fields are missing:

bash
CXDB_URL="$(jq -r '.cxdb.http_base_url // empty' "$RUN_ROOT/manifest.json")"
CONTEXT_ID="$(jq -r '.cxdb.context_id // empty' "$RUN_ROOT/manifest.json")"

if [ -z "$CXDB_URL" ] && [ -f "$RUN_ROOT/run_config.json" ]; then
  CXDB_URL="$(jq -r '.cxdb.http_base_url // empty' "$RUN_ROOT/run_config.json")"
fi
if [ -z "$CONTEXT_ID" ] && [ -f "$RUN_ROOT/live.json" ]; then
  CONTEXT_ID="$(jq -r '.context_id // empty' "$RUN_ROOT/live.json")"
fi
if [ -z "$CONTEXT_ID" ] && [ -f "$RUN_ROOT/checkpoint.json" ]; then
  CONTEXT_ID="$(jq -r '.context_id // empty' "$RUN_ROOT/checkpoint.json")"
fi

echo "cxdb_url=$CXDB_URL context_id=$CONTEXT_ID"

To make sure CXDB is available and to print the UI endpoint, run:

bash
./scripts/start-cxdb.sh
UI_LINE="$(./scripts/start-cxdb-ui.sh)"
echo "$UI_LINE"   # prints: cxdb_ui=http://...
CXDB_UI="${UI_LINE#cxdb_ui=}"

Use the endpoint printed by start-cxdb-ui.sh (cxdb_ui=...) as the source of truth. To open the UI in a browser when needed, run:

bash
KILROY_CXDB_OPEN_UI=1 ./scripts/start-cxdb-ui.sh

To follow run events directly from CXDB:

bash
./kilroy attractor status --logs-root "$RUN_ROOT" --follow --cxdb
./kilroy attractor status --logs-root "$RUN_ROOT" --follow --cxdb --raw

To run direct HTTP queries for ad-hoc debugging, use:

bash
# Health endpoint may be /healthz even when /health returns 404.
curl -fsS "$CXDB_URL/health" || curl -fsS "$CXDB_URL/healthz"
curl -fsS "$CXDB_URL/v1/contexts"
curl -fsS "$CXDB_URL/v1/contexts/$CONTEXT_ID"
curl -fsS "$CXDB_URL/v1/contexts/$CONTEXT_ID/turns?limit=20"
curl -fsS "$CXDB_URL/v1/contexts/$CONTEXT_ID/turns?view=typed&limit=20"

Read Canonical Files

To build a reliable picture of run state:

Always inspect graph.dot first so status is interpreted in graph context.

Preflight-only runs (--preflight / --test-run) are expected to write preflight_report.json and skip execution artifacts (manifest.json, checkpoint.json, final.json, worktree/).

  1. manifest.json: run identity, graph name, repo, worktree, started_at.
  2. live.json: most recent event.
  3. checkpoint.json: last completed node and failure context.
  4. final.json: if present, run is finished (success or fail).
  5. progress.ndjson: full event timeline.
bash
sed -n '1,200p' "$RUN_ROOT/graph.dot"
sed -n '1,200p' "$RUN_ROOT/manifest.json"
sed -n '1,200p' "$RUN_ROOT/live.json"
[ -f "$RUN_ROOT/checkpoint.json" ] && sed -n '1,200p' "$RUN_ROOT/checkpoint.json"
[ -f "$RUN_ROOT/final.json" ] && sed -n '1,200p' "$RUN_ROOT/final.json"
tail -n 80 "$RUN_ROOT/progress.ndjson"

Determine Current State

To classify run state:

  • Running: final.json missing and live.json/progress.ndjson still changing.
  • Finished: final.json present.
  • Likely stalled: no progress.ndjson updates for longer than configured stall timeout.
  • attractor status can show terminal fail while progress.ndjson still advances in overlap conditions; timestamp comparison resolves this ambiguity.

To quickly validate terminal state vs liveness, use:

bash
ls -la "$RUN_ROOT/final.json"
tail -n 1 "$RUN_ROOT/progress.ndjson"

Discover Event Schema First

To avoid filtering for non-existent event keys, discover the active event schema before building event-specific queries:

bash
jq -r '.event? // empty' "$RUN_ROOT/progress.ndjson" | sort | uniq -c | sort -nr

To inspect fields for a specific event type, run:

bash
jq -c 'select(.event=="stage_attempt_end")' "$RUN_ROOT/progress.ndjson" | head -n 5

Noise-to-Signal Query Patterns (Observed)

These patterns come from real investigation mistakes where the first query produced noisy output and the replacement query produced useful signal.

  1. Raw tail was dominated by heartbeats.
bash
# noisy
tail -n 80 "$RUN_ROOT/progress.ndjson"

# higher-signal
jq -rc 'select(.event!="branch_heartbeat") | {ts,event,node_id,status,branch_key,branch_event,branch_status,branch_failure_reason}' \
  "$RUN_ROOT/progress.ndjson" | tail -n 80
  1. Event frequency counts gave little "what is happening now" signal.
bash
# broad but low immediate diagnostic value
jq -r '.event? // empty' "$RUN_ROOT/progress.ndjson" | sort | uniq -c | sort -nr

# better for current state
jq -rc 'select(.event!="branch_heartbeat") | {ts,event,node_id,status,branch_key,branch_event,branch_status,branch_failure_reason}' \
  "$RUN_ROOT/progress.ndjson" | tail -n 40
  1. Broad history scans mixed unrelated commits into run analysis.
bash
# noisy across repo history
git rev-list HEAD | head -n 200

# scoped to this run's commits
git log --oneline --grep "$RUN_ID" -n 80
  1. Full commit stats pulled in target/ and artifact churn.
bash
# noisy if commit touched build outputs
git show --stat <commit>

# source-focused
git show --stat <commit> -- demo/rogue/rogue-wasm/src
  1. Progress checks can fail on pipe/SIGPIPE mechanics instead of run state.
bash
# brittle in strict pipefail shells
set -euo pipefail
jq -rc 'select(.event!="branch_heartbeat")' "$RUN_ROOT/progress.ndjson" | head -n 20

# safer wrapper for quick probes
set -euo pipefail
jq -rc 'select(.event!="branch_heartbeat")' "$RUN_ROOT/progress.ndjson" | head -n 20 || true
  1. "Is code still improving?" was unclear without a last-meaningful-change anchor.
bash
# activity-only view
git log --oneline --grep "$RUN_ID" -n 30

# source progress since last meaningful implementation commit
git diff --stat <last_meaningful_commit>..HEAD -- demo/rogue/rogue-wasm/src

Resolve Terminal-vs-Live Conflicts

To handle cases where final.json exists but progress.ndjson still changes:

  1. If final.json exists and progress.ndjson is newer, this is a possible overlapping-resume state rather than immediate data corruption.
  2. Compare file mtimes and latest event timestamps.
  3. Confirm whether a run/resume process is currently active.
bash
stat -c '%n %y' "$RUN_ROOT/final.json" "$RUN_ROOT/live.json" "$RUN_ROOT/progress.ndjson" 2>/dev/null
tail -n 5 "$RUN_ROOT/progress.ndjson"
Show full SKILL.md (329 more words)Show less

Check Process Liveness

To determine whether the run is truly active at the OS level:

bash
pgrep -af 'kilroy attractor (run|resume)'
[ -f "$RUN_ROOT/run.pid" ] && cat "$RUN_ROOT/run.pid"
[ -f "$RUN_ROOT/run.pid" ] && ps -fp "$(cat "$RUN_ROOT/run.pid")"
ps -ef | rg -i 'kilroy attractor (run|resume)' | rg -v rg

If a resume process is already active for the same --logs-root, launching another resume is a possible source of mixed terminal/live state.

A live PID with unchanged tail events across repeated checks is a possible stale/hung process, not active run progress.

bash
E1="$(tail -n 1 "$RUN_ROOT/progress.ndjson")"
sleep 3
E2="$(tail -n 1 "$RUN_ROOT/progress.ndjson")"
[ "$E1" = "$E2" ] && echo "no new events" || echo "events advancing"

Relaunch Hygiene (Single Owner)

When relaunching, quiescing duplicate resume processes first and launching one detached resume reduces the chance of stopped by signal terminated outcomes.

bash
ps -ef | rg -i "kilroy attractor resume --logs-root $RUN_ROOT" | rg -v rg
# If duplicates exist, stop extras before launching a single detached resume.
setsid -f bash -lc "cd /path/to/repo && ./kilroy attractor resume --logs-root '$RUN_ROOT' >> '$RUN_ROOT/resume.out' 2>&1"

Debug Parallel Fan-In Stalls

To diagnose fan-in waits, inspect branch-local progress under parallel/<join-node>/:

bash
find "$RUN_ROOT/parallel" -maxdepth 3 -type f -name 'progress.ndjson' | sort

To inspect branch outcomes and status-contract behavior:

bash
rg -n 'status_contract|stage_attempt_end|stage_retry_blocked|deterministic_failure_cycle_check|subgraph_deterministic_failure_cycle_check' \
  "$RUN_ROOT"/parallel/*/*/progress.ndjson

To interpret heartbeat-only behavior:

  • If events are mostly branch_heartbeat and branch_idle_ms rises monotonically, the branch is likely waiting/stalled rather than converging.
  • If branch_progress continues with new stage_attempt_* events, the branch is still making progress.
bash
tail -n 200 "$RUN_ROOT/progress.ndjson" | rg 'branch_heartbeat|branch_progress|branch_idle_ms'

Check Loop and Cycle Guardrails

To distinguish policy stops from compute hangs, inspect guardrail events directly:

bash
rg -n 'stuck_cycle_breaker|deterministic_failure_cycle_breaker|stage_retry_blocked|deterministic_failure_cycle_check' \
  "$RUN_ROOT/progress.ndjson"

Interpretation guidance:

  • stuck_cycle_breaker with visit_count/visit_limit indicates a configured loop-visit stop.
  • *_cycle_breaker indicates repeated deterministic failures reached the configured signature limit.

Identify Models and Providers

To identify models/providers accurately, combine static and runtime evidence:

  1. Static routing from graph model_stylesheet and node classes.
  2. Runtime events from progress.ndjson (llm_retry, llm_call_*, provider/model fields).
  3. Provider availability from run_config.json.
bash
rg -n 'model_stylesheet|llm_model|llm_provider|class=' "$RUN_ROOT/graph.dot"
rg -n '"event":"llm_|"provider":"|"model":"' "$RUN_ROOT/progress.ndjson"
sed -n '1,220p' "$RUN_ROOT/run_config.json"

Triage Common Failures

  • To diagnose missing status.json, check whether the codergen node emitted the required status signal.
  • To diagnose llm retry with 429/rate-limit, check for provider quota or backoff pressure.
  • To diagnose deterministic_failure_cycle_check, check for repeated deterministic failure at the same node.
  • To diagnose toolchain/setup errors, inspect setup_command_* events and stage stderr.log.
bash
rg -n 'missing status.json|llm_retry|deterministic_failure_cycle_check|setup_command_|failure_reason' "$RUN_ROOT/progress.ndjson"

Postmortem Capture (Overlap/Termination)

Capture final.json timestamp, latest progress.ndjson timestamp, active resume PIDs/PPIDs, and termination events (stopped by signal terminated, subgraph_canceled_exit, stage_attempt_end).

bash
stat -c '%y %n' "$RUN_ROOT/final.json" "$RUN_ROOT/live.json" "$RUN_ROOT/progress.ndjson" 2>/dev/null
ps -ef | rg -i "kilroy attractor resume --logs-root $RUN_ROOT" | rg -v rg
rg -n 'stopped by signal terminated|subgraph_canceled_exit|stage_attempt_end' "$RUN_ROOT/progress.ndjson" | tail -n 80

Report Format

To present findings clearly, report in this order:

  1. run_id, run_root, started time.
  2. Current node/state and whether run is still active.
  3. Models/providers configured and observed.
  4. Top failure signals with exact file references.
  5. One next action (continue waiting, resume, or fix specific failure cause).

© danshapiro, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file in skills/investigating-kilroy-runs of danshapiro/kilroy.

  • SKILL.md
  • agents/openai.yaml

Open the folder on GitHubat commit b55fb0f

Compare with similar skills

Investigating Kilroy Runs next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Investigating Kilroy Runs compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Investigating Kilroy Runs this skilldanshapiro/kilroy222—~3.1kAutomated safety check: PassMIT
Error Handlingmajiayu000/litellm-rs118—~2kAutomated safety check: PassMIT
Verifytheopenco/llmgateway1.7k—~1kAutomated safety check: PassCustom licence
Antigravityyuting0624/antigravity-for-claude-code375—~9.1kAutomated safety check: PassMIT
Changelogtheopenco/llmgateway1.7k—~2kAutomated safety check: PassCustom licence
Provider Integrationhex/claude-council857—~635Automated safety check: PassMIT

Similar skills

  • Error Handling

    majiayu000/litellm-rs

    LiteLLM-RS Error Handling Architecture. An agent skill from majiayu000/litellm-rs.

    118 GitHub stars~2k tokensUpdated today
    DevelopmentAuto-check passed
  • Verify

    theopenco/llmgateway

    Build, launch, and drive the LLM Gateway stack in an isolated worktree environment to verify API, gateway, dashboard, playground, or screenshot changes.

    1.7k GitHub stars~1k tokensUpdated today
    DevelopmentAuto-check passed
  • Antigravity

    yuting0624/antigravity-for-claude-code

    Run the Antigravity CLI (Gemini) as a collaborating AI inside Claude Code, with intelligent model routing across the software development lifecycle.

    375 GitHub stars~9.1k tokensUpdated 6 days ago
    AI & LLM EngineeringAuto-check passed
  • Changelog

    theopenco/llmgateway

    Write a new LLM Gateway changelog entry. An agent skill from theopenco/llmgateway.

    1.7k GitHub stars~2k tokensUpdated today
    DevelopmentAuto-check passed
  • Provider Integration

    hex/claude-council

    Adds new AI providers to claude-council, configures provider API settings, troubleshoots provider connections, and documents the provider script interface.

    857 GitHub stars~635 tokensUpdated 2 days ago
    AI & LLM EngineeringAuto-check passed
  • Config Architecture

    majiayu000/litellm-rs

    LiteLLM-RS Configuration Architecture. An agent skill from majiayu000/litellm-rs.

    118 GitHub stars~3.2k tokensUpdated today
    AI & LLM EngineeringAuto-check passed

More from danshapiro/kilroy

  • Build Dod

    danshapiro/kilroy

    A skill your agent uses when converting a spec, requirements document, or goal statement into a Definition of Done with acceptance criteria and integration test scenarios

    222 GitHub stars~2.5k tokensUpdated 5 mo ago
    Auto-check passed
  • Create Runfile

    danshapiro/kilroy

    A skill your agent uses when authoring or repairing Kilroy run config YAML/JSON files, including DOT-to-provider backend alignment and runtime policy defaults.

    222 GitHub stars~1.4k tokensUpdated 5 mo ago
    Auto-check: notes
  • Release Kilroy

    danshapiro/kilroy

    A skill your agent uses when preparing a Kilroy release — writing release notes, tagging, and publishing via goreleaser on GitHub.

    222 GitHub stars~2k tokensUpdated 5 mo ago
    Auto-check passed
  • Create Dotfile

    danshapiro/kilroy

    A skill your agent uses when authoring or repairing Kilroy Attractor DOT graphs from requirements, with template-first topology, routing guardrails, and validator-clean output.

    222 GitHub stars~6.4k tokensUpdated 5 mo ago
    Auto-check passed
  • Starting A Project

    danshapiro/kilroy

    A skill your agent uses when bootstrapping a new project repository for Kilroy Attractor from a clean directory using existing spec, DoD, graph, and run config artifacts.

    222 GitHub stars~498 tokensUpdated 5 mo ago
    Auto-check passed
  • Using Kilroy

    danshapiro/kilroy

    Operate Kilroy Attractor pipelines end-to-end: ingest English requirements into DOT graphs, validate graph semantics, run and resume pipelines with run config files, configure provider backends…

    222 GitHub stars~4.3k tokensUpdated 5 mo ago
    Auto-check passed

Questions about Investigating Kilroy Runs

What does Investigating Kilroy Runs do?

To diagnose active, stuck, or failed Kilroy Attractor runs, inspect run artifacts (manifest.json, live.json, checkpoint.json, final.json, progress.ndjson), resolve run IDs/log roots, identify…. Investigating Kilroy Runs is an agent skill from danshapiro/kilroy.ndjson), resolve run IDs/log roots, identify model/provider routing, and isolate failure causes.

When should I use Investigating Kilroy Runs?

Investigating Kilroy Runs fits situations like: tasks that involve Model routing and gateways.

How do I install Investigating Kilroy Runs in Claude Code?

Run `npx skills add danshapiro/kilroy --skill investigating-kilroy-runs -a claude-code`. Or copy the skill folder (skills/investigating-kilroy-runs in danshapiro/kilroy) into .claude/skills/investigating-kilroy-runs in your project. Claude Code loads it when a task matches its description.

How do I install Investigating Kilroy Runs in Codex?

Run `npx skills add danshapiro/kilroy --skill investigating-kilroy-runs -a codex`. Or copy the skill folder (skills/investigating-kilroy-runs in danshapiro/kilroy) into .agents/skills/investigating-kilroy-runs in your project. Codex loads it when a task matches its description.

Can I use Investigating Kilroy Runs in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add danshapiro/kilroy --skill investigating-kilroy-runs -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/investigating-kilroy-runs, .gemini/skills/investigating-kilroy-runs, .github/skills/investigating-kilroy-runs and .opencode/skills/investigating-kilroy-runs in your project.

What does Investigating Kilroy Runs need to run?

Going by SKILL.md and its folder, Investigating Kilroy Runs needs the command-line tools its instructions call (rg, jq, curl and git).

Does Investigating Kilroy Runs access the network?

SKILL.md contains no URLs. Its commands use curl and git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Investigating Kilroy Runs safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Investigating Kilroy Runs use?

Investigating Kilroy Runs is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Investigating Kilroy Runs use?

About 3.1k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Investigating Kilroy Runs?

Skills that share tags, products or a category with Investigating Kilroy Runs: Error Handling (majiayu000/litellm-rs, 118 stars), Verify (theopenco/llmgateway, 1.7k stars), Antigravity (yuting0624/antigravity-for-claude-code, 375 stars) and Changelog (theopenco/llmgateway, 1.7k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Investigating Kilroy Runs?

danshapiro (a GitHub user) maintains it in danshapiro/kilroy, which has 222 GitHub stars. The repository holds 7 skills in this directory. The repository was last updated on April 27, 2026.

Source: danshapiro/kilroy on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.