메뉴
Runtime HAL for multi-runtime agent orchestration. Detects active AI assistant (Claude Code, Codex, Gemini, Cursor) and exposes uniform interface for startup injection, GUPP enforcement, and communication selection.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/aibot88/sec_skill_store --skill runtime-hal명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Guides the creation of agile user stories and Gherkin feature files. Use when the user wants to create a user story, write acceptance criteria, define Gherkin scenarios, or author BDD feature files. This should trigger for requests such as Create a user story; Write a user story; I need to write a user story. Part of cursor-rules-java project
Guía técnica completa para integrar 250+ servicios externos con agentes IA usando Composio. Cubre instalación, autenticación OAuth, gestión de herramientas, triggers y flujos multi-servicio.
Facilitates conversational discovery to create Architectural Decision Records (ADRs) for non-functional requirements using the ISO/IEC 25010:2023 quality model. Use when the user wants to document quality attributes, NFR decisions, security/performance/scalability architecture, or design systems with measurable quality criteria. This should trigger for requests such as Create ADR for Non-functional requirements; Document Non-functional requirements; Capture Non-functional requirements; Generate Non-functional requirements in an ADR. Part of cursor-rules-java project
SOC 직업 분류 기준
SKILL.md 표시 중
| name | runtime-hal |
| description | Runtime HAL for multi-runtime agent orchestration. Detects active AI assistant (Claude Code, Codex, Gemini, Cursor) and exposes uniform interface for startup injection, GUPP enforcement, and communication selection. |
| type | skill |
| category | orchestration |
| status | stable |
| origin | tibsfox |
| modified | false |
| first_seen | 2026-03-06T00:00:00.000Z |
| first_path | .claude/skills/runtime-hal/SKILL.md |
| superseded_by | null |
Hardware Abstraction Layer for AI coding assistant runtimes. The HAL detects which runtime environment is active and provides a uniform interface so that every other skill in the Gastown chipset can operate identically regardless of runtime. This mirrors Gastown's internal/runtime/runtime.go provider abstraction, where the Go binary auto-detects its host environment and adapts its hook, nudge, and session strategies accordingly.
In the chipset hardware metaphor, the Runtime HAL is the BIOS/UEFI firmware layer. Real firmware probes hardware on boot, detects what peripherals exist, and presents a uniform interface to the operating system. The HAL does the same: it probes the runtime on activation, detects what capabilities exist (hooks, session IDs, context forking), and presents a uniform interface to the chipset's skills and agents.
This skill activates when the task involves:
The HAL exposes a uniform interface that other skills consume. No skill outside the HAL should inspect environment variables, probe the filesystem for runtime indicators, or check the process tree directly.
interface RuntimeHAL {
// Detection
detectProvider(): RuntimeProvider;
// Startup
getStartupStrategy(): StartupStrategy;
getStartupCommands(role: AgentRole): string[];
// Communication capabilities
supportsHooks(): boolean;
supportsNudge(): boolean;
getSessionId(): string | null;
(): ;
(): ;
(): ;
}
type RuntimeProvider = 'claude' | 'codex' | 'gemini' | 'cursor' | 'unknown';
type StartupStrategy = 'hook_injection' | 'startup_fallback' | 'polling';
type GUPPStrategy = 'hook_injection' | 'prompt_preamble' | 'polling';
These types are also declared in the shared Gastown type system at src/chipset/gastown/types.ts. The HAL consumes AgentRole from the same module when generating startup commands.
Detection runs once at activation time and caches the result. The detection cascade follows Gastown's runtime.go pattern, which tries the most specific signal first and falls through to progressively weaker indicators.
Step 1: Explicit override via GT_RUNTIME environment variable
If GT_RUNTIME is set, use its value directly. This allows operators to force a specific provider during testing, CI, or when running inside a container where other signals are absent.
GT_RUNTIME=claude -> RuntimeProvider = 'claude'
GT_RUNTIME=codex -> RuntimeProvider = 'codex'
GT_RUNTIME=gemini -> RuntimeProvider = 'gemini'
GT_RUNTIME=cursor -> RuntimeProvider = 'cursor'
Any unrecognized value maps to 'unknown'.
Step 2: Check CLAUDE_SESSION_ID environment variable
Claude Code sets CLAUDE_SESSION_ID for every active session. If this variable is present and non-empty, the runtime is Claude Code.
CLAUDE_SESSION_ID exists && non-empty -> RuntimeProvider = 'claude'
Step 3: Check for .claude/settings.json in workspace
If the workspace root contains .claude/settings.json, this strongly indicates a Claude Code environment. This catches cases where the session ID variable is not yet propagated (e.g., hook execution before session fully initializes).
.claude/settings.json exists -> RuntimeProvider = 'claude'
Step 4: Check process tree for known runtime binaries
Inspect the process tree for known executable names:
| Binary | Provider |
|---|---|
claude | claude |
codex | codex |
gemini | gemini |
cursor | cursor |
This step is the least reliable (binary names can change across versions) and serves as a last-resort heuristic before falling back.
Step 5: Fall back to 'unknown'
If no signal matches, the provider is 'unknown'. The HAL selects the polling strategy for both startup and GUPP. This ensures graceful degradation: no crash, no hang, no error. The chipset operates in a reduced-capability mode where hooks are unavailable but work items still flow through periodic filesystem polling.
GT_RUNTIME set?
yes -> use GT_RUNTIME value
no -> CLAUDE_SESSION_ID set?
yes -> 'claude'
no -> .claude/settings.json exists?
yes -> 'claude'
no -> process tree matches known binary?
yes -> matched provider
no -> 'unknown'
| Capability | Claude Code | Codex | Gemini | Cursor | Unknown |
|---|---|---|---|---|---|
| Session hooks | Yes | No | No | Partial | No |
| Context fork | Yes | No | No | Yes | No |
| Session ID env var | CLAUDE_SESSION_ID | GT_SESSION_ID | GT_SESSION_ID | None | None |
| Startup injection | SessionStart hook | gt prime fallback | gt prime fallback | Command palette | Polling |
| GUPP strategy | hook_injection | startup_fallback | polling | prompt_preamble | polling |
| Stall threshold | 120s | 180s | 300s | 120s | 300s |
| Nudge interval | 30s | 60s | 120s | 30s | 120s |
| Nudge support | Yes (filesystem) | Yes (filesystem) | Yes (filesystem) | Limited | Yes (filesystem) |
The HAL selects a startup strategy based on the detected provider. Startup strategy determines how an agent receives its initial context (role, work item, GUPP rules) when it is spawned.
Claude Code supports .claude/settings.json hooks that fire on session events. The mayor writes a SessionStart hook entry that injects the agent's role, assigned bead, and GUPP rules into the session context before the agent's first prompt. This is the highest-fidelity strategy: the agent starts with full context and never needs to poll for its assignment.
Mayor writes hook -> Agent starts -> SessionStart fires -> Context injected
Codex does not support hooks. Instead, the mayor writes the agent's assignment to a known filesystem path, then starts the agent with a gt prime command that reads the assignment file on startup. The agent receives its context through command-line injection rather than hook callbacks.
Mayor writes assignment file -> gt prime starts agent -> Agent reads file -> Context loaded
For runtimes without hooks or startup injection, the agent starts with a generic context and immediately enters a polling loop, checking state/hooks/{agentId}.json at the configured nudge interval until it finds an assignment. This is the slowest strategy but requires zero runtime-specific integration.
Agent starts generic -> Polls hook file -> Finds assignment -> Context loaded
GUPP (Guided Unsupervised Parallel Processing) enforcement varies by runtime capability. The HAL selects the most reliable GUPP mechanism available.
GUPP rules are injected via hooks into the agent's session context. The agent operates under GUPP constraints enforced by the runtime itself. Stall detection works through hook callbacks: if the agent's lastActivity timestamp in the hook state exceeds the stall threshold, the witness raises an alert.
GUPP rules are baked into the agent's startup context via the gt prime command. The agent cannot modify its own GUPP constraints after startup. Stall detection relies on filesystem observation: the witness watches for changes in state/hooks/{agentId}.json and triggers if the file's modification time exceeds the threshold.
GUPP rules are prepended to the agent's prompt context via the command palette integration. This is less reliable than hook injection because the agent can potentially ignore preamble instructions. Stall detection works identically to the startup_fallback case.
GUPP rules are written to the hook state file. The agent polls for both work assignments and GUPP constraint updates. This is the most robust fallback: it requires no runtime-specific integration, but introduces latency equal to the nudge interval. Stall detection is inherent in the polling mechanism: if the agent stops polling (no reads on the hook file), it is stalled.
When the provider is 'unknown', the HAL guarantees:
detectProvider() always returns a valid RuntimeProviderThis is the fundamental contract: the chipset degrades gracefully, never catastrophically.
If detection throws an exception (corrupted settings file, permission denied on process tree), the HAL catches the error, logs a warning, and returns 'unknown'. No detection failure propagates to calling skills.
If getSessionId() returns null, the calling skill must not assume hooks are unavailable. Some runtimes set the session ID asynchronously. The HAL uses the full detection cascade (not just session ID) to determine capabilities.
| Skill | How It Uses the HAL |
|---|---|
mayor-coordinator | Calls getStartupStrategy() and getStartupCommands() when spawning polecats |
polecat-worker | Calls getGUPPStrategy() to know how GUPP rules are enforced |
witness-observer | Calls getStallThreshold() and getNudgeInterval() for monitoring timers |
nudge-sync | Calls supportsNudge() to decide whether to send filesystem nudges |
hook-persistence | Calls supportsHooks() to decide whether to write hook state files |
beads-state | Uses getSessionId() to tag work items with the active session |
No skill outside the HAL should perform its own runtime detection. If a skill needs to know the runtime, it calls detectProvider(). If it needs to know whether hooks work, it calls supportsHooks(). The HAL is the single source of truth for runtime capabilities.
The HAL NEVER:
hook-persistence and beads-statemail-async and nudge-syncwitness-observermayor-coordinatorThe HAL is a detection and capability layer. It answers "what can this runtime do?" but never "what should we do?"
Operators can override HAL defaults via environment variables:
| Variable | Purpose | Example |
|---|---|---|
GT_RUNTIME | Force a specific provider | GT_RUNTIME=codex |
GT_STALL_THRESHOLD | Override stall detection (seconds) | GT_STALL_THRESHOLD=240 |
GT_NUDGE_INTERVAL | Override nudge interval (seconds) | GT_NUDGE_INTERVAL=45 |
GT_GUPP_STRATEGY | Force a GUPP strategy | GT_GUPP_STRATEGY=polling |
Overrides take precedence over provider defaults but not over structural impossibilities (e.g., forcing hook_injection on Codex will not make hooks appear).
references/gastown-origin.md -- How this skill maps to Gastown's internal/runtime/runtime.goproviders/claude-code.md -- Claude Code provider details and hook integrationproviders/codex.md -- Codex provider details and startup fallbackproviders/fallback.md -- Generic fallback provider for unknown runtimes