Skip to content

stabem/graphhelm

v1.0.0MIT

GraphHelm methodology, host setup guidance, and evidence-based next-step selection.

GraphHelm guide

GraphHelm is an experimental, local-first agent operating system. Its plugin skills help an agent decide what to do; the CLI and Runtime provide typed contracts, deterministic checks, execution control, and evidence. A skill's text is never authority to bypass permissions, publish a graph, or claim an unobserved result.

flowchart LR
  A[User promise] --> B[Scope and risk]
  B --> C{Adequate observer?}
  C -->|No| M[Keep proof unresolved]
  C -->|Yes| D[Keel: smallest scoped change]
  D --> E[Run reached checks]
  E --> F[Independent review]
  F --> G[Merge and verify]
  G --> H[Resume: two next options]

For a small reversible change with a clear observer, use the direct route. For unclear proof, persistence, permissions, compatibility, security, or external effects, use Journey-Proven Development (JPD): describe the user journey, compile each promise into an observable obligation, and refuse a success claim if the required observer is missing. Keel keeps context and new code surface proportional, then asks for the lowest total cost per proven delivery after quality is preserved. Count repairs, reviews, and repeated work, not tokens alone. Neither method replaces the repository's review and merge rules.

GraphHelm's Governor owns operational graph publication. Agents send typed signals and proposals; deterministic code enforces schemas, policies, permissions, and state transitions. A plugin install does not start the Runtime, install the CLI, activate an extension package, or change a user's existing instructions. graphhelm init creates a project MCP entry that selects the authenticated Runtime from the project identity, without pinning a port or token path; graphhelm setup --resolve home/.claude.json=register-mcp can register the same project-aware command at user scope. Direct --url and --token-file connections remain available when an operator deliberately wants to pin one Runtime. graphhelm setup starts with inventory and a preview; applying a reviewed plan requires explicit acceptance and creates a backup before supported host files change. graphhelm restore previews recovery before applying it. See the 1.0.0 release, getting started, skills map, and current delivery process.

Install from the repository

The graphhelm plugin contains this guide, graphhelm-setup, graphhelm-resume, graphhelm-kickoff, graphhelm-team, and graphhelm-work. The same marketplace also lists the existing graphhelm-jpd and graphhelm-development-contracts plugins. Install those companions only when their skill families are needed; both can connect to the same local Runtime and require a separately configured trusted CLI, token file, and per-session actor. Installing any plugin alone does not install the GraphHelm executable.

In Claude Code:

claude plugin marketplace add stabem/GraphHelm
claude plugin install graphhelm@graphhelm

In Codex CLI:

codex plugin marketplace add stabem/GraphHelm
codex plugin add graphhelm@graphhelm
codex plugin add graphhelm-codex-hooks@graphhelm

After installation, start a fresh session. In Claude Code, use /graphhelm:graphhelm-guide, /graphhelm:graphhelm-setup, /graphhelm:graphhelm-resume, or /graphhelm:graphhelm-kickoff; Claude namespaces plugin skills, so the installed commands are not bare /graphhelm-setup or /graphhelm-resume. In Codex, invoke $graphhelm-guide, $graphhelm-setup, $graphhelm-resume, or $graphhelm-kickoff. The setup skill guides the separate graphhelm setup CLI through inventory, a reviewed plan, backup, and restore; invoking the skill alone changes no host files. The resume skill reads current evidence and offers exactly two next actions with one recommendation; it does not take either action for you. The kickoff skill starts a brand-new project: it grills the owner one question at a time, writes docs/PROJECT.md and draft journey flows with them, waits for the owner to approve the flows, then runs each issue through the five task steps while the owner follows in the Studio. The kickoff session is the orchestrator: it asks once which models and how many agents to use, and spawns every author and reviewer with the team skill, which bootstraps implementation authors under their own lanes and withholds implementation until own-claim admission; reviewers retain exact-head review assignments. The plugin also ships three tool-restricted subagent types for the orchestrator to spawn instead of a general-purpose agent: keel-author, keel-reviewer and keel-journey-qa (agents/); they take effect after the plugin is reinstalled. They load skills from the keel and graphhelm-development-contracts plugins, so both must be installed too, and because they list their tools they have no MCP tools and use the graphhelm CLI. The keel plugin ships its own keel-author, keel-reviewer and a read-only Haiku keel-scout that name only the keel plugin's skills, for projects that do not install GraphHelm; these three are the GraphHelm-repository variants. Measured starting context (one spawn each, prompt "answer only: ok", no tool use, first usage record: input + cache-creation + cache-read tokens): keel-author 45,821 (sonnet), keel-reviewer 45,375 (opus), keel-journey-qa 45,014 (opus), against 86,397 for a general-purpose spawn in the same session; models differ per row, so the counts are not strictly like for like.

Session hooks

Version 0.1.25 added these hooks. This installed plugin includes command hooks for Claude Code. Affected Codex versions use the separate graphhelm-codex-hooks compatibility companion, which is the only Codex hook registration. Unbound sessions are silent by default. When the session is explicitly bound to a GraphHelm execution, SessionStart injects a short Keel reminder, and startup and resume read one Runtime briefing and return a bounded summary of its next action and pending work. There is no unconditional second briefing read: request detailed evidence only when the next action needs it. Compaction restores cached context labeled as not refreshed, without an HTTP read. A cached summary never authorizes a state transition; the Runtime still validates the current state. SessionEnd records an attributed agent_session_ended signal. It never marks a task or node complete. The hook does not create a run, pick a run by project name, or forward the host's raw payload. When the session is a lane (GRAPHHELM_ACTOR, or the lane name its title or .graphhelm/team.json bound), SessionStart also records one agent_session_started and both signals are signed as the lane, with the host and session id in the description, so the Studio's lanes and run members read the lane's start and end; a session that is no lane keeps the {host}-session-{id} actor.

Each hook process accepts one bounded JSON object frame. It returns after the first complete object, even when the caller keeps stdin open; a process performs one operation and does not consume a second object. EOF before a complete object, invalid UTF-8 or JSON, a non-object value, and an oversized frame remain invalid input.

SessionStart allows one request up to five seconds of socket inactivity, within the thirty-second hook declaration, including startup and durable cache publication. Runtime's five-second operator read budget is a progress check and does not guarantee a response within five seconds. SessionEnd also allows five seconds of socket inactivity; the Claude plugin declares ten seconds for that event and the Codex companion three. Older Codex versions may clamp larger declarations to three seconds. Inspect the installed host's effective budget rather than assuming it honors a declaration.

Claude has a separate shared shutdown budget, which defaults to 1.5 seconds. A plugin's SessionEnd timeout does not raise that shared budget. Set CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS=10000 in the environment that launches Claude when using the bound end hook. This is a supported host setting; changing it inside a hook cannot change its parent's budget. See the Claude SessionEnd reference. This setting permits more shutdown time, not more requests or tokens. A desktop process already running must be restarted from the configured launch environment.

A socket inactivity limit is not a wall-time deadline. Host cancellation can stop the hook before its acknowledgement is observed, while a separately recorded Runtime effect remains durable. An unavailable briefing or acknowledgement stays UNOBSERVED; it never becomes task success and is never retried by this hook.

Python 3 must be on the host's PATH. Desktop sessions can resolve their lane identity without per-session environment variables: SessionStart saves a valid session_title by session_id in ~/.graphhelm/lane-sessions/, and the Stop hook combines that identity with .graphhelm/team.json found from the hook payload's working directory. The team file contains executionId, runtimeUrl, and tokenFile (a local path, not a token); keep this machine-specific file out of version control. SessionEnd removes the session identity, and SessionStart prunes entries older than seven days. Codex sessions without a session_title continue to use explicit environment binding.

Set these variables in the environment that launches the agent host when using explicit binding:

  • GRAPHHELM_EXECUTION_ID: exact execution ID to bind. Without it, the hook makes no Runtime request and injects no context by default.
  • GRAPHHELM_KEEL_CONTEXT=1: explicitly enable the short Keel reminder in an unbound session.
  • GRAPHHELM_TOKEN_FILE: path to the local Runtime token file, required for a bound run.
  • GRAPHHELM_RUNTIME_URL: Runtime API origin; defaults to http://127.0.0.1:8791.
  • GRAPHHELM_SESSION_ID: optional expected host session ID. A mismatch leaves the operation unobserved rather than reading or writing a different session's binding.
  • GRAPHHELM_NODE_ID: optional explicit node reference. It is labeled as configured; the hook does not infer an assignment from the next pending node or claim that the Runtime assigned it.

For example, in PowerShell before launching an agent in a terminal:

$env:GRAPHHELM_EXECUTION_ID = 'run-example'
$env:GRAPHHELM_TOKEN_FILE = 'C:/path/to/events.token'
$env:GRAPHHELM_RUNTIME_URL = 'http://127.0.0.1:8793'
$env:CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS = '10000'
claude

The same environment variables apply to Codex. A desktop app that was already running will not inherit variables set later in a terminal. Codex asks the user to review and trust new plugin hooks before running them. Updating the plugin does not override that host decision.

Third-party agent hosts can use the same script as a portable adapter. Pass an explicit bounded host identity such as --host my-agent; unknown hosts use the graphhelm-portable-v1 JSON contract automatically. start returns a bounded context, end returns its acknowledged delivery state, and inspect returns local observations. A portable response reports the adapter boundary and activation: "unobserved"; it does not claim that the host loaded the hook or accepted a task. Use --format portable when the host wants this shared machine-readable contract; the built-in claude and codex hooks keep their native envelopes by default.

The token stays in its file and travels only to a loopback HTTP or HTTPS Runtime. A redirect is refused. The hook prints UNOBSERVED if a bound read or write fails, without blocking the agent session or claiming a record landed. End signals require a Runtime keyring; this hook does not write an unsealed evidenceOut file. A full signal budget also leaves the end unobserved.

A repeated end hook uses the same signal body and idempotency key. Once the Runtime acknowledges the matching execution and signal IDs, the hook saves that confirmation and skips later sends. An unconfirmed request remains retryable. A rejected graph mutation does not mean the signal was not recorded: those are different results in the Runtime contract.

State is scoped to host, Runtime origin, execution and session, outside the repository under the user's local state directory; GRAPHHELM_HOOK_STATE_DIR can override that path. Actors carry a session-specific identity rather than only a host name. The end request also sends the host session ID as X-GraphHelm-Actor-Session for the Runtime's structured presence record. These observations do not assign or complete operational nodes, and session end is not proof that the work passed.

Since version 0.1.3, hooks use a new state and signal-key namespace: 0.1.2 timestamp files have no delivery acknowledgment and are not migrated as proof. A corrupt record stays unobserved; it is not silently replaced with a new signal under the same key. The local lock is released by the OS if the host terminates the hook. Delivery deduplication is scoped to this protocol, not an exactly-once claim across plugin upgrades or deletion of local state.

The hook calls no model. Cached compaction avoids a Runtime request, and confirmed repeated end delivery avoids another request. These are request-count guarantees covered by local HTTP tests, not a measured reduction in a complete task's billed tokens. The hook returns only bounded typed summary fields, never the full objective, transcript or Runtime command text.

Lane Stop reminder

lane_stop_hook.py runs in both host packages. Bind GRAPHHELM_EXECUTION_ID to the team execution, GRAPHHELM_RUNTIME_URL, the agent GRAPHHELM_TOKEN_FILE, and GRAPHHELM_ACTOR to the exact lane id. A pending addressed operator_note blocks once with "read the notes addressed to you". Only a later reply recorded by that agent clears its note. The hook neither acknowledges notes nor sends messages.

The scan reads only event pages: optional opaque to and replyTo on signal_recorded replace per-note evidence GETs. It reads the last 4096 events, at most 8 pages of 512 (one MiB maximum response per page), plus one head request. Notes older than the window and legacy notes without routing hints are outside this reminder; the normal inbox still reads their sealed evidence.

Roll out addressed-note routing in reader-first order. First upgrade every active reader of the shared event store: PATH-installed and versioned graphhelm CLIs, direct-store status or inbox tools, and any sidecar that reads the event log. Verify each can read events with to and replyTo. HTTP-only hooks do not read the store directly; upgrade those with their host plugin in the final step. After readers are ready, switch the Runtime writer that appends routing fields, then update and restart host plugins. Keep source release, Runtime writer activation, host activation, and observed autonomous wake as separate rollout statuses. Old binaries cannot read events already appended with the new fields, so rollback to old readers is not valid after the first such event. Never delete or rewrite events to recover; restore compatible readers instead. Historical events are not rewritten.

Unbound sessions, stop_hook_active=true, unreadable state, malformed responses, oversized pages, exhausted scan and timeout allow Stop. The scan child has a two-second wall timeout; the host declaration allows ten seconds for process startup and cleanup. Allow is never proof that the inbox is empty. Host background wake notification remains a separate observer.

Explicit task handoff

hooks/task_handoff.py is a provider-neutral command adapter for any host that can run Python. It is explicit and is never called automatically by SessionStart or SessionEnd. offer records a sealed task_handoff_offer signal for one exact recipient host and session. receive reads the original journal event and opens its sealed envelope. Before requesting a fresh bounded briefing, it checks the journal for an existing receipt and validates its sealed envelope and relation to the offer. A valid replay then reads the current briefing; a new receive reads the briefing before recording a sealed task_handoff_received signal with replyTo pointing to the offer. status reconstructs offers and matching receipts from the Runtime journal.

The receive response returns offeredBriefing, the bounded digest sealed when the sender offered the handoff, and receiptBriefing, the digest sealed in the first recipient receipt, alongside briefing, the current Runtime digest. On receipt replay, both historical digests stay tied to their sealed records while briefing may advance. A missing or malformed receipt digest is refused before a current briefing request. A valid replay still requires a fresh briefing; if that read fails, no historical digest is returned as current and no receipt is posted. These historical digests do not assign current duties or imply task acceptance.

The current briefing must be at least as new as the latest journal sequence already read and the validated offered and receipt briefing digests. An older response is refused before a receipt is posted; equal or newer sequence numbers are accepted.

Read-only status retains the receipts ID list and exposes receiptBriefings, keyed by those IDs, from each validated sealed receipt. An offer without receipts has an empty map. This historical receipt context needs no current briefing fetch and does not imply acceptance.

When status names an offer ID, it opens only that offer's sealed content. It still validates the current recipient's receipt records to determine which reference that offer. A receipt claiming the selected offer through either replyTo or its sealed offerId is fully validated before it can be reported or ignored; missing or disagreeing relation metadata refuses the status result. A valid receipt consistently linked to another offer remains unrelated. Unfiltered status continues opening all offer records. An unavailable unrelated offer cannot block a targeted read, while unavailable or corrupt selected evidence is refused.

A timed-out or disconnected write can have committed before its response was lost. The adapter does not repeat that POST. It reads the journal and validates the exact sealed offer or receipt, including content hash, execution, actor and addressing. Only verified durable evidence permits state: recorded; the result retains writeAcknowledgement: unobserved for that attempt. Missing, invalid or unavailable evidence remains unobserved. Explicit HTTP refusals are not reconciled into success. This proves retrieval only: accepted: false, task completion and native host activation remain separate. Socket timeouts still bound inactivity rather than total wall time; the caller must bound the whole operation, including reconciliation reads.

python <installed-plugin>/hooks/task_handoff.py offer --host claude --session-id <sender-session> --recipient-host codex --recipient-session-id <receiver-session> --handoff-id <bounded-id>
python <installed-plugin>/hooks/task_handoff.py receive --host codex --session-id <receiver-session> --offer-id <offer-id>
python <installed-plugin>/hooks/task_handoff.py status --host codex --session-id <receiver-session> --offer-id <offer-id>

The adapter requires the Runtime to seal the signal evidence. It re-reads the journal and sealed evidence on retries, so losing local hook state does not create a second offer. It validates the execution, source actor, target actor, protocol metadata, evidence hash, and replyTo; bounded incomplete pagination or missing evidence stays unobserved. A receipt proves that the receiving adapter retrieved the offer and current briefing. It does not prove model comprehension, task acceptance, node ownership, permission transfer, or completion. Runtime owner credentials authorize declared actor labels; they do not cryptographically authenticate the host or model.

Offer, receive, and status refuse event pages with more than 256 entries, negative or regressing heads, a head behind the requested cursor, or an event sequence beyond its page head. The reader accepts increasing cursors and heads that advance while it reads concurrent appends. Invalid history is refused before the adapter fetches evidence or briefing or attempts a write.

An offer replay reports already_recorded only after validating the sealed offer kind, requested identities and handoff ID, protocol metadata, and historical briefing digest. Invalid or unavailable evidence is refused without fetching a current briefing or writing another offer.

Each explicit handoff request allows up to five seconds of socket inactivity per Runtime request; the caller must still impose its own whole-process deadline. A timeout remains unobserved and is not retried automatically. --handoff-id distinguishes multiple offers between the same two sessions in one execution; repeating the same id replays the journal record after local state loss.

The same adapter has an optional, explicitly configured stdio MCP mode. The Codex compatibility companion registers it with a plugin-relative working directory and script path; the main plugin does not register a second server. The server makes no Runtime request while starting. Its legacy environment session mode uses GRAPHHELM_MCP_HOST, GRAPHHELM_SESSION_ID, GRAPHHELM_EXECUTION_ID, GRAPHHELM_TOKEN_FILE, and (when needed) GRAPHHELM_RUNTIME_URL. For normal Codex calls, opt into native metadata mode with GRAPHHELM_MCP_SESSION_SOURCE=codex_metadata; it requires GRAPHHELM_MCP_HOST=codex and each tools/call _meta object to contain equal, valid threadId and sessionId values. GRAPHHELM_SESSION_ID, when set, pins that per-call identity. The server does not retain a session between calls. Initialize and tool discovery can run unbound; an actual tool call without fixed execution, Runtime, and token configuration remains unobserved. The companion explicitly forwards the host's task execution, Runtime URL, token-file path, optional session pin, and optional node binding through env_vars. It never forwards the token contents or accepts those settings from model arguments. Starting Codex without these task settings leaves the server discoverable but its task calls unobserved.

Configure the trusted server process and run directly when needed:

python <installed-plugin>/hooks/task_handoff.py --mcp-stdio

The server exposes offer, receive, and status through standard newline-delimited MCP JSON-RPC. Host, execution, Runtime URL, and token path come only from trusted server configuration. In native Codex mode, the host supplies the session identity in per-call metadata; tool arguments can name the recipient or offer, but cannot replace any binding. Missing, malformed, conflicting, or pinned-mismatched metadata fails before Runtime I/O. In legacy mode, the environment session contract is unchanged. Requests are bounded and unknown fields fail closed. A tool failure returns MCP isError: true and an unobserved result. An oversized or unterminated frame closes the transport after a sanitized error; its remaining bytes cannot become another request. This local transport proves adapter behavior only; native host trust and activation still need a separate fresh-session observation.

Admission before task dispatch

graphhelm-team separates implementation bootstrap from task work. Trusted setup provisions each lane's scoped credential first. The actual implementation child claims its issue with its own credential, reads it back, and calls MCP task_admit with executionId, lane, issue, branch, repo and claimSequence. Only the matching admitted: true receipt permits dispatch of the implementation payload. The CLI contract is graphhelm --json tasks admit --execution <id> --lane <lane> --issue <N> --branch <B> --repo <owner/name> --claim-sequence <sequence> with explicit Runtime/read-token options when needed. Missing credentials or failed admission are blockers, not workers. No shared-token fallback, coordinator impersonation or new credential authority is provided by admission.

This admission and the run-codex launcher cover pre-PR implementation authors only. Reviewers retain the existing review_assigned record for their actual identity, current PR and exact head; they receive an independent blind-review payload and never claim the author's issue. Flow reviews use their existing scoped flow contract.

The Runtime permits an explicit assignedBy handover while the predecessor still has a live claim lease. Admission conservatively refuses the successor until the predecessor releases its own claim; an unrelated issue does not block admission. This is stricter than Runtime claim registration and does not change its handover rules.

Admission checks the current claim snapshot; it does not start a host, prove work happened or prevent a later lease expiry. Direct external host spawn APIs are not intercepted. Session presence, mailbox acknowledgements and self-reported activity remain separate evidence; a team_report saying working does not create an accepted task or change task bars in Studio.

Explicit run team and shared mailbox

The optional run-team protocol is bound to one GRAPHHELM_EXECUTION_ID. Joining is explicit; installing the plugin or opening a host chat does not attach it to a run. The Codex compatibility companion exposes team_join, team_report, team_send, team_inbox, and team_acknowledge through its existing metadata-bound MCP server. Each tool call uses the native Codex session ID from matching threadId/sessionId transport metadata. The member identity is the same codex-session-<id> label used by the session hooks. The plugin's general graphhelm MCP server still uses the shared agent-chat label and is not a team identity source.

An environment-bound Claude session can use the provider-neutral CLI with GRAPHHELM_EXECUTION_ID, GRAPHHELM_RUNTIME_URL, GRAPHHELM_TOKEN_FILE, and a trusted GRAPHHELM_SESSION_ID set by its launcher. For example, from the installed plugin directory:

python hooks/run_team.py join --host claude
python hooks/run_team.py report --host claude --update-id progress-1 --task "Review UI" --activity "Checking the rendered view" --state working
python hooks/run_team.py inbox --host claude
python hooks/run_team.py acknowledge --host claude --message-id <recorded-message-id>
python hooks/run_team.py send --host claude --message-id reply-1 --to <sender-actor-id> --reply-to <recorded-message-id> --text "Review complete"

team_send writes either an addressed message to an already joined actor or a room message. The caller supplies a stable messageId so a retry cannot duplicate it. A direct reply must return to the sender of a message addressed to this session. team_inbox reads a bounded set of room and unacknowledged addressed messages; a read does not acknowledge anything. A separate call by the addressed session records team_acknowledge. Studio reconstructs members, public work reports, messages, and acknowledgements from sealed evidence in that exact run. A report is the session's statement, not independent proof of active work or acceptance. Silence is shown as missing fresh activity; only a recorded SessionEnd says an end was observed.

The mailbox is pull-based. A busy or closed host is not interrupted or restarted, and a recorded message does not imply that another host read it. The current Studio operator note is a separate run-log message, not an automatic team-mailbox delivery. Runtime bearer credentials authorize declared actor labels; they do not cryptographically authenticate native host identity. Use a trusted launcher to pin the Claude session and never accept session IDs from a model argument in place of that pin. Existing sessions need an explicit safe migration before using these tools.

Setup inspection

The graphhelm-setup skill includes a hook inspection step. Resolve the actual installed plugin directory from the host's plugin inventory, then run the Claude hook from graphhelm or the Codex hook from the installed graphhelm-codex-hooks companion:

python <installed-plugin>/hooks/session_hook.py inspect --host claude
python <installed-codex-hooks>/hooks/session_hook.py inspect --host codex --session-id <actual-session-id>

Inspection is read-only, makes no Runtime request, and does not read token contents. It reports configuration and local script observations. It cannot establish that the host trusted or loaded the hook; a manual invocation can also create a local observation. Keep activation unverified until the host's own fresh-session event is observed. Do not register a second copy in settings. The adoption CLI does not migrate opaque hook commands; the setup skill identifies legacy registrations and requires an explicit, backed-up migration for those entries.

The optional SubagentStart and SubagentStop hooks record a child identity under the host session bound to the current execution. They do not receive the direct nested delegator, task title, result, or acceptance verdict. Studio shows only the verified host-session link and the observed lifecycle events; a missing stop never means the child is still working. Claude's TaskCreated and TaskCompleted hooks separately record the bounded task subject, native task id, optional teammate name, and observed task phase. They do not link that task to a subagent id or certify that its output was accepted. Task descriptions and transcripts are not uploaded. The UserPromptSubmit hook (hooks/prompt_hook.py, #1921) is off unless .graphhelm/team.json sets "recordOwnerPrompts": true. Then each prompt in a title-bound lane session is recorded on the team execution as a candidate ask (task.request_recorded, requestId candidate-…, title candidate: …), capped at 1000 characters, skipped when it looks like a secret, and sent only with that lane's own credential to a loopback Runtime. It never blocks the prompt and prints nothing. Claude's PostToolUse hook on the Skill tool (hooks/skill_record_hook.py) records each skill a bound session loads as one skill.loaded signal (low severity), once per session and skill (a repeat load is a recognized retry, so it does not spend the execution's shared signal bound), carrying only the skill name, the session id and, for a subagent, its agent id. It never records the skill's args, any other tool input or any tool output; outside a bound execution, or on any failure, it does nothing, prints nothing and never blocks the tool call. Codex has no such hook, so a Codex session records nothing. Installing updated source does not prove host activation; verify a fresh native session separately.

To add a methodology companion, install graphhelm-jpd@graphhelm or graphhelm-development-contracts@graphhelm with the host's plugin install / plugin add command. Install graphhelm-codex-hooks@graphhelm for Codex hook compatibility as shown above. The skill catalog shows when each is useful. Their MCP registration needs GRAPHHELM_CLI to be an absolute trusted executable path, GRAPHHELM_TOKEN_FILE to name a local token file, and GRAPHHELM_ACTOR to identify the chat session. Never paste the token value into a manifest or prompt.