gt

Plugin gt from marketplace golden-thread-plugin in shaven/golden-thread. Commands read from the repo's manifest — 7 days ago.

Skills (40)

• gt-adopt

  Adopt a vault gt did not create: inspect its folders, propose a layout manifest, write it only after a yes, then run the read-only checks. Use when the user says: adopt this vault, use gt on my existing vault, my notes are not laid out like gt, point gt at my own folders.

• gt-allin-commit

  Commit once checks pass and a test receipt covers every staged file. Refuses without evidence or on the default branch; never pushes. Use when the user says: commit it, commit once checks pass.

• gt-allin

  Run every check in one command (scan, lint, optimize, install health, credentials, runbook and wiki lint, tests, receipts) and report how many actually ran. Never pushes or applies a change. Use when the user says: run everything, check everything, all checks.

• gt-brief

  Draft a self-contained CLAUDE.md section for a project's code repo from its vault notes — what it is, the stable decisions, where it runs, what not to do — printed for review, never written. Use when the user says: /gt-brief, brief the repo, draft the repo CLAUDE.md, graduate this project to its rep

• gt-calibrate

  Run model calibration now: re-run recent agent-stage work a tier and an effort up and down, have a zero-context judge compare, and show each stage's verdict and the command to apply it. Runs even when model_calibration is off. Use when the user says: calibrate the models, calibrate the agents, run m

• gt-close

  Close this session's work, the opposite of /gt:gt-open: write back what it learned and release its vault claim. Use when the user says: close this session, close out the session, I'm done for now, wrap up this session, close the project I opened. To complete or archive a project, task or handoff, us

• gt-complete

  Complete a project (review its open tasks and handoffs, offer to graduate what it learned, archive it), a task (mark it done) or a handoff (mark it handled). Use when the user says: complete the project, we're done with this project, archive the project, retire this project, mark that task done, mar

• gt-context

  Show what words mean in this vault: vocabulary, validation rules and runbooks from the definition packs in effect, inside an untrusted-data envelope. Use when the user says: what does this term mean, show the vocabulary.

• gt-create

  Create a project (scaffold and brain dump), a task (one line, optionally tied to a page or source) or a handoff (facts for the next session, labelled by source and verification). Use when the user says: new project, create a project, start a project called X, make a sub-project under Y, add a task,

• gt-digest

  Have a big file, long paste or image read by the cheapest reader (a local model, a small subagent, or Claude) and get back only the answer, keeping the text out of this conversation. Use when the user says: digest this file, digest this paste, summarize this big file for me, read this log and tell m

• gt-disposable

  Run work a gate refuses on this machine in a throwaway VM or container instead, without loosening the gate: the tree is copied in, the command runs, you get the exit code and output, the guest is destroyed. Use when the user says: run this in a disposable VM, run this in a throwaway container, run i

• gt-doctor

  Check this gt install in one command (version, drift, hook wiring, modules, migrations, stray workers, unpushed commits, lint) and name the gate that blocked a test run, with its fix. Use when the user says: is everything healthy, check my install, gt doctor, health check, is anything broken, why is

• gt-forget

  Forget a fact that turned out wrong: find every vault note that states it and retract the ones the owner picks, each marked with reason, date and where the right fact lives, deleting nothing. Use when the user says: forget that, that fact is wrong, retract this note, the vault says X but it is no lo

• gt-grant

  Let one command through once, for a while or forever, without lowering the lockdown level; list and revoke grants. Use when the user says: grant this, allow this once, allow it for 30 minutes, stop asking for this command, list my grants, revoke a grant, why was my command refused.

• gt-handle

  Work through waiting handoffs (close each item, keep it as a task, or defer to a date) or tasks (close, drop, defer, move, keep) one at a time. Use when the user says: handle the handoffs, deal with the handoff, defer that handoff, work through the handoffs, handle my tasks, work through the tasks,

• gt-help

  Open an offline page that plays a gt command against a demo vault, with what it does and what to try next; with no command, a searchable index for your role. Use when the user says: gt help, show me how a command works, what does this command do, show me around gt, getting started with gt, what can

• gt-implement

  Carry out an approved gt-plan phase by phase, test first; stop on any failure, name the tests that ran, commit only on the user's yes. Use when the user says: implement the plan, build it now, execute the plan, run the approved plan, next phase.

• gt-ingest

  Import a project's memory files, CLAUDE.md constraints and notes into the vault, deleting nothing; external sources go to Sources/ before becoming Knowledge pages. Use when the user says: import this project, ingest my notes.

• gt-init

  Create the gt vault and wire it to this project, or re-check an existing setup. Use when the user says: install Golden Thread, set up Golden Thread, set up my notes vault, connect this project to my vault, check my Golden Thread setup.

• gt-lint

  Audit the vault: broken links, orphans, missing index entries, unlisted memory, bloated or project-specific globals, pages citing superseded sources. Use when the user says: check the vault, find broken links, lint the vault.

• gt-list

  Show what is waiting, read-only: handoffs (open or no longer deferred) and open tasks, filtered by project, priority, mine, overdue, stale, deferred or ref. Use when the user says: list the handoffs, what handoffs are waiting, any handoffs pending, list tasks, show my tasks, what tasks are open, wha

• gt-minimize

  Prune a heavy session before cutting it: measure it and its prompt cache, keep what is worth keeping, then /compact or /clear while cheap; `compact` does the whole cut (capture, handoff, then a compact or a clear, per cut_kind and cut_handoff); `clear` forces a clear. Use when the user says: minimiz

• gt-next

  Say the one best next action from the vault, and why, in under five lines: no model call, shaped by your role. Use when the user says: what's next, what should I do next, I'm not sure what to do, where do I start.

• gt-open

  Load a project from the vault at the start of a session: read its core docs in order, index its memory, summarize and ask where to pick up. Use when the user says: open project X, load project X, work on X, continue X, start on X.

• gt-optimize

  Find what costs context and earns nothing back, in the vault (duplicate facts, dead index rows, relative dates, memory over budget, unread pages) and in sessions (lost prompt-cache writes). Reports never write; --demote, --archive and --supersede move or mark content and leave a pointer. Use when th

• gt-plan

  Plan coding work before any code: restate the requirement, read the design and spec, surface risks, and write a phased plan (goal and done condition per phase) that waits for the user's approval. Use when the user says: plan this, make a plan for, plan before coding, write an implementation plan, ho

• gt-promote

  Graduate a fact or finding up the ladder: project memory, then decisions/research, a Knowledge page, global-memory. Use when the user says: promote this, make this permanent knowledge.

• gt-query

  Look up a topic in the Golden Thread vault — reads index.md first, follows wiki links, falls back to grep across Knowledge and global-memory. Use when the user says: what did we decide about X, look that up in my notes, what do we know about X, do we have notes on X, where did we write down X.

• gt-refresh

  Check a gt vault's Sources/ for upstream changes and supersede stale ones, never editing a source. Use when the user says: refresh the vault, check the vault's sources, are my project sources still current, supersede a stale source. For a standalone LLM Wiki, use gt-wiki-refresh.

• gt-review

  Sweep INBOX.md (and daily notes) for unfiled thoughts and route each into a project. Use when the user says: review the inbox, review my daily notes, what's uncaptured, file my inbox, turn my notes into projects. Vault path via ~/.claude/vault-config.json.

• gt-route

  Mid-session check: what this session has become, where its output belongs, and whether it is in the right place. Use when the user says: where does this go, where should this live, am I in the right project, should I be in the terminal for this, I'm not sure where I'm going with this. Also when a se

• gt-runbook-lint

  Find content duplicated across project runbooks that should move to a shared layer. Use when the user says: lint runbooks, check runbooks for drift, find graduation candidates in runbooks.

• gt-scan

  Scan a tree against the definitions in effect (lint rules, naming, encoding per language) and report which checks ran. Use when the user says: scan this folder, run the lint rules.

• gt-settings

  View and change what gt does on its own: every optional automatic behaviour, gt's and each module's, in one place (`show` lists them). `lotr` shows LOTR connections and whether each works; `models` is the Models and cost page (model, effort, cost and calibration per agent type). Use when the user sa

• gt-setup

  Finish installing gt from inside Claude Code, no terminal: pick modules, security level and vault, then run the installer. Use when the user says: finish the install, finish setting up gt, install all the modules, add a module, remove a module, gt is not set up, I just installed gt from the marketpl

• gt-sync

  Keep the vault in step with its git remote: show ahead and behind, pull (fast-forward only), or push this machine's session commits after the push check. Use when the user says: sync the vault, pull the vault, push the vault, is the vault up to date, get the latest vault, publish my vault commits.

• gt-upgrade

  Bring a vault up to the installed release: run pending migrations, merge the release's PROTOCOL.md and CONVENTIONS.md changes, add new Core rules, stamp it. Use when the user says: upgrade the vault, is my vault up to date, I just installed a new version, migrate the vault.

• gt-validate

  Independently verify a claim with a fresh-context agent that sees only the claim, the rules and the artifact, never the reasoning. Use when the user says: verify this claim, check this number, is this true, before a production change.

• gt-validation

  Record what a validation established about a file, stamped with its content hash so it goes stale when the file changes. Use when the user says: record this validation, is this validation still current.

• gt-work

  Capture session findings into the vault: research.md, ADRs in decisions.md, design.md, spec.md, PROTOCOL.md for process rules. Use when the user says: write up where we left off, save what we learned, capture today's findings, log what we did today, write that down in the project notes.

Subagents (10)

• classify

  gt ingest-pipeline stage 'classify'. Spawn it ONLY when a gt skill (gt-ingest) says to, with the prompt gt_agent_spec.py rendered for it.

• disk-reader

  gt disk reader. Delegate to it ONE file read or folder listing outside the vault when the session's own Read is denied or should not be widened. Asks the user for paths off the allow list; never serves credentials, keys or .env. Read-only.

• disk-writer

  gt disk writer. Delegate to it ONE text file to write into another project's git work tree when the session's own Write is denied or should not be widened. Every write asks the user; never commits. Cannot read.

• draft

  gt ingest-pipeline stage 'draft'. Spawn it ONLY when a gt skill (gt-ingest) says to, with the prompt gt_agent_spec.py rendered for it.

• extract

  gt ingest-pipeline stage 'extract'. Spawn it ONLY when a gt skill (gt-ingest) says to, with the prompt gt_agent_spec.py rendered for it.

• generalize

  gt promote-pipeline stage 'generalize'. Spawn it ONLY when a gt skill (gt-promote) says to, with the prompt gt_agent_spec.py rendered for it.

• net-fetcher

  gt network fetcher. Delegate to it ONE web page or API response (a GET, no cookies) when the session's own WebFetch route is denied or should not be widened. Asks the user for domains off the list; never fetches private addresses.

• place

  gt promote-pipeline stage 'place'. Spawn it ONLY when a gt skill (gt-promote) says to, with the prompt gt_agent_spec.py rendered for it.

• reconcile

  gt ingest-pipeline stage 'reconcile'. Spawn it ONLY when a gt skill (gt-ingest) says to, with the prompt gt_agent_spec.py rendered for it.

• verify

  gt promote-pipeline stage 'verify'. Spawn it ONLY when a gt skill (gt-validate) says to, with the prompt gt_agent_spec.py rendered for it.

MCP servers (1)

• gt-vault

  runs: python3 -I ${CLAUDE_PLUGIN_ROOT}/scripts/gt_vault_mcp.py

Hooks (30)

• SessionStart

  [ -f "${HOME:-$USERPROFILE}/.claude/golden-thread/hooks/gt_paths.py" ] || { s="${CLAUDE_PLUGIN_ROOT}/scripts/gt_setup.py"; { command -v py >/dev/null 2>&1 && py -3 -I "$s" hook; } || python3 -I "$s" h

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_components.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_workers.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_version_check.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_push_check.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_surface.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_unlock.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_grant.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_queue_autodrain.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_calibration_schedule.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_skill_runlog.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_session_search.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_addon_scan.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__gt_mcp_pin.py"; if [ -f "$f" ]; then . "$f"; fi

• SessionStart

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/SessionStart__inject_core_rules.sh"; if [ -f "$f" ]; then . "$f"; fi

• UserPromptSubmit

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/UserPromptSubmit__gt_state.py"; if [ -f "$f" ]; then . "$f"; fi

• UserPromptSubmit

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/UserPromptSubmit__vault_hints.py"; if [ -f "$f" ]; then . "$f"; fi

• UserPromptSubmit

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/UserPromptSubmit__gt_expiry_guard.py"; if [ -f "$f" ]; then . "$f"; fi

• UserPromptSubmit

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/UserPromptSubmit__gt_hints.py"; if [ -f "$f" ]; then . "$f"; fi

• UserPromptSubmit

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/UserPromptSubmit__gt_intake.py"; if [ -f "$f" ]; then . "$f"; fi

• UserPromptSubmit

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/UserPromptSubmit__inject_core_rules.sh"; if [ -f "$f" ]; then . "$f"; fi

• PreCompact

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/PreCompact__gt_state.py"; if [ -f "$f" ]; then . "$f"; fi

• PreToolUse

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/PreToolUse__guard_protected_paths.sh"; if [ -f "$f" ]; then . "$f"; fi

• PreToolUse

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/PreToolUse__guard_foreign_checkout.sh"; if [ -f "$f" ]; then . "$f"; fi

• PreToolUse

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/PreToolUse__guard_scope_contract.sh"; if [ -f "$f" ]; then . "$f"; fi

• PreToolUse

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/PreToolUse__guard_lotr_agent.py"; if [ -f "$f" ]; then . "$f"; fi

• PreToolUse

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/PreToolUse__gt_grant.py"; if [ -f "$f" ]; then . "$f"; fi

• PreToolUse

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/PreToolUse__guard_install.sh"; if [ -f "$f" ]; then . "$f"; fi

• PreToolUse

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/PreToolUse__gt_integrity.py"; if [ -f "$f" ]; then . "$f"; fi

• PreToolUse

  f="${HOME:-$USERPROFILE}/.claude/golden-thread/wired/PreToolUse__gt_agent_model.py"; if [ -f "$f" ]; then . "$f"; fi