# spt-claude-code — glossary

> Authoritative for meaning (grill-with-docs convention). Glossary only — no
> implementation detail. Decisions/rationale live in `SCOPE.md` and `docs/adr/`.

**spt-claude-code** — the rebuilt Claude Code harness adapter. The `claude-spt`
adapter in spt-core terms. Simultaneously spt-core's v1 acceptance proof (legacy
parity), its first casual-end-user entrypoint (a CC plugin), and an invisible spt-core
installer. Built by maintainer perri from the public spt-releases surface only.
(Repo being renamed `spt-claude-code` → `claude-spt` per the naming-domain rule; see
[[naming-domains]].)

**claude-spt** — the adapter_name spt-claude-code registers under (rides every `api`
invocation + the manifest). The CC adapter's identity inside spt-core. The
**spt-core-facing** token (repo + adapter + consolidated binary). See [[naming-domains]].

**naming-domains** — the two-token naming rule (ADR-0005): **`claude-spt`** is the
spt-core-facing identity (repo, adapter, binary — `spt adapter … claude-spt`), and
**`spt`** is the Claude-Code-facing identity (plugin + skills, `/spt:*`, via the
`sptc`→`spt` succession). One token can't cover both because the adapter cannot be named
`spt` (spt-core's own identity) while the skill prefix wants `/spt:*`. The `cc` launcher
shortcut (`cc-<id>`) is decoupled from both.

**legacy spt / `claude_skill_owl`** — the sister project; today's shipped CC integration
(owl.exe + `spt` plugin, v1.11.25). The parity *target* (user-facing features), not a
1:1 port — most of its machinery now lives in spt.exe.

**skeleton plugin** — the thin marketplace artifact on `SaberMage/cplugs`: namespaced
`/spt:*` skill stubs + hooks + a SessionStart bootstrap that installs spt-core. Low-churn;
the volatile bulk (binary + manifest) is spt-core-conducted, not in the plugin.

**fetch-stub skill** — a `/spt:X` SKILL.md that is a 2-line stub fetching its real
instructions at runtime from the adapter `[strings]` (`spt adapter get-string`/`skill-help`).
Keeps skill files static while instructions update via spt-core. Distinct from a `[hints]`
entry (proactive, keyword-triggered, UPS-hook-delivered).

**identity brief** — the agent-facing text the adapter injects at SessionStart into a session
that already owns a perch (the `bind` + `boundary` topologies). Tells the agent who it is, that
its perch is already live (so it must not re-arm), and how to message (send + reply + the endpoint
roster). Adapter-string-backed (`[strings.briefs]`), composed from an `{id}`-templated identity
piece plus shared messaging pieces. Liveness-agnostic: it does not distinguish live-vs-ready (that
flavor is deferred until spt-core publishes a machine-readable liveness query). Distinct from the
**ring brief** (the no-perch sibling).

**ring brief** — the SessionStart counterpart for a session with **no** perch (the `seed`
topology): a node-local agent that hasn't readied still learns how to reach other agents via
`spt ring` (the no-id messaging path). Peer-gated — emitted only when the node actually
participates in a subnet (has reachable peers), so a solo casual end user is never told how to
ring agents that don't exist.

**ccs profile** — a profile under spt-claude-code (`claude-spt:glm`, `claude-spt:kimi`)
that leaf-replaces the launch command + history/digest log dir to use the `ccs` backend.
NOT its own adapter — ccs is structurally Claude Code.

**`cc` launcher (capsule-style)** — a generated `cc`/`cc <id>` script at project root that
spawns-or-attaches a CC endpoint via spt-core's spt-hosted topology (broker PTY + inject +
attach). The spt-core realization of legacy's unbuilt "Capsule" milestone. _Avoid_: equating
it with psmux/sendkeys — spt-core's broker is the terminal host.

**Psyche** — a LiveAgent's detached *companion* process. When a session goes live
(`/sptc:live`), spt-core's daemon hosts a Psyche alongside it: the Psyche owns its own
perch (`<parent>-psyche`), is woken by daemon *pulses*, and on each pulse authors a
*commune*. It never replies or notifies (that is the echo-commune, a different actor) and
exits at session end. A *ready* agent has no Psyche — live-vs-ready is the command, not a
profile. (Realized here by the `claude-spt-psyche` runner.)

**commune** — the context-delta a Psyche writes on each pulse: a brief that lets the
parent agent resume coherently after a context wipe (`/clear` / compact). A file-drop the
daemon ingests, not an `api` verb.

**recharge** — a live agent's *self-initiated* context reset: the agent flags a commune
to request that its own working context be wiped and rebuilt from that latest commune, so it
continues coherently — carried *across* to the next session — without the operator manually
running `/clear`. The agent-driven sibling of the operator's manual clear; only meaningful for
a live agent (which has a Psyche + a commune to rebuild from). Named for what it does to the
agent rather than for the file mechanism it rides: the perch stays up and the agent comes back
lean, which is the opposite of the signoff the previous name was repeatedly mistaken for.
Operator phrasing: "recharge", "save and clear". See [[commune]], [[wake marker]].
_Also accepted, not yet retired_: "across-commune", "commune across", "commune to next
session", `--across` — the previous name for this exact thing (renamed 2026-09-09, staged:
peers carry the old spelling in durable context no release can reach, so it is understood
everywhere and refused nowhere). Requirement ids keep their `COMMUNE` spelling — an id is
identity, and renaming one orphans every tag pointing at it. See `REQ-RECHARGE-VOCABULARY`.
_Avoid_: "checkpoint" (retired 2026-07-16 — collides with Claude Code's own /checkpoint skill)
<!-- [doc->REQ-RECHARGE-VOCABULARY] -->

**wake marker** — the marker a live agent embeds in a commune to request a
[[recharge]]; a PAIR of markers brackets the *wake message* the next session opens with
(the request signal; distinct from the wire payload that carries it to the delivery layer,
which is an implementation concern).
_Avoid_: "checkpoint trigger" (retired with the checkpoint spelling of [[recharge]])

**session name** — the operator-facing display name an spt-hosted endpoint carries in the
harness TUI (prompt box / resume picker): the visual anchor tying a terminal to its agent.
Shape: `<id> @ <node> (<project>/)`, degrading to bare `<id>` when the node is unknown.
Distinct from the remote-control name (a character-safe token) and the endpoint id (spt-core's
identity — attach/inject key by it, never by this name).

**boundary rename** — re-asserting the [[session name]] on a `/clear` boundary. The harness
drops the display name when a clear rotates the session, leaving the operator no rendered
anchor; the adapter re-applies the same name to the fresh session, before any [[recharge]]
wake lands. `/compact` retains the name, so it has no rename.

**psyche sandbox** — the constrained surface a Psyche's `claude` turns run under:
Read/Edit/Write tools only, slash-commands disabled, permissions auto-approved, cheap
pinned model. Deliberately narrower than the parent agent (which is unconstrained). Mirrors
legacy owl's psyche box; see `docs/adr/0003-*`.

**casual end user** — a user who *uses* an spt-powered system mostly-invisibly, vs the
adapter/shell *developer* who is spt-core's nominal target. spt-claude-code serves casual
users: install the plugin, get spt-core for free.

**experimplate** — the standalone reusable project-workflow template (its own sibling repo)
extracted from spt-core's working style. spt-claude-code is its first consumer. Carries
traceable-reqs gating, JIT plans, grill-with-docs scaffolding, release/changelog, and
same-repo published-docs. Defined in its own folder, not here.

**tagged-input round-trip** — the harness pattern where the translation binary types
namespaced-XML-tagged content into the operator's *input box* without submitting, the operator
edits the payload between the tags, and the UserPromptSubmit hook recognizes the tags on the
resulting submit to consume the edited result. The binary-inject leg and the UPS leg are
decoupled and *rendezvous on the tags*, not on a shared channel. Backs `/sptc:role`'s no-directive
edit. Distinct from message injection (which auto-submits) and from an [[identity brief]]'s
additionalContext (which the operator never edits).

**message stub** — the tiny self-closing element an idle delivery types into the agent's input
box IN PLACE of the full message body: `<msg from="<id>[@<node>]" id="<short-id>"/>` for a peer
message (`@<node>` only when the sender is on another machine), `<wake/>` for a [[recharge]] wake.
A pointer, not a payload — the body arrives on the resulting [[stub turn]], never through the
input box. Same pointer-not-payload idea as a [[fetch-stub skill]], applied to deliveries. The
default for idle-delivered bodies; internal control envelopes (rename, role-edit, wake)
are not stubs and are unaffected.

**stub turn** — a turn whose ENTIRE prompt (trimmed) is exactly one [[message stub]]. Only then
does stub handling fire — a stub quoted inside prose is a quotation, never a trigger (whole-prompt
exact, the discipline that fixed the `@<…@>` false-fire). A stub turn delivers every parked body
waiting at that moment; a trailing stub whose bodies already rode an earlier stub turn gets a
one-line "coalesced" note instead.

**body park** — the holding state where an idle-delivered body waits between receipt and its
[[stub turn]]. Custody is adapter-local for now — the wake park exe-relative
(`state/wake/<eid>.park`; the hook writes AND reads it, one binary resolution), the msg park
HOME-anchored (`~/.spt-claude/msgpark/<eid>/`, one ordered file per body) because its writer is
the resident translation binary and its reader the always-fresh hook: two binary resolutions must
meet at a path neither owns. The end-state custody is spt-core's short-id store (the stub's `id`
fetched back by id), at which point a [[recharge]]'s `/clear <short-id>` carries the wake's id
across the boundary inside the transcript itself.

**full-inject override** — the deliberately undocumented sender-side escape hatch that routes ONE
message through legacy full-text typing instead of a [[message stub]] — for senders that need the
body to BE the visible prompt. Adapter-internal; never taught in agent-facing briefs.

**interrupt marker** — the digest-visible signal that the operator pressed Esc to interrupt a
turn: the session digest records a turn whose input is the literal `[Request interrupted by
user]` (the normalized form of the TUI's "Interrupted · What should Claude do instead?"). The
sole reliable idle-after-interrupt signal, since an Esc fires no `Stop` and no `idle_prompt`
hook; the receive-heal keys off it to re-assert idle. Surfaced only on a digest pull (the
fetcher re-reads the transcript), never daemon-pushed.

**private development home** — the private repository where all claude-spt development,
release builds, and GitHub releases live after the relocation (ADR-0008). Consumers are
internal and gh-authenticated; `spt adapter add/update` resolves its releases through the
`gh` CLI. Named precisely only in the ADR and release tooling, never in mirrored files.
_Avoid_: naming it in any file the [[source-only mirror]] ships

**source-only mirror** — the public lineage repo (the former development home) that
receives, per release, one squashed source snapshot plus the `vX.Y.Z` tag via plain `git`
push — no `gh`, no GitHub API. The snapshot excludes release/migration plumbing and every
file naming the [[private development home]]; a leak-guard grep hard-fails the mirror
otherwise. The public tree is deliberately not buildable or installable, and gets no new
GitHub releases.
_Avoid_: upstream, public release channel, buildable mirror

**migration script** — a per-platform script on a `migration/vX.Y.Z` branch of the
[[private development home]], fetched via `gh api` per internally-distributed
instructions. It patches an installed adapter's manifest `[update]` target to the private
home, then runs `spt adapter update claude-spt`. One-time per node; endpoints need no
action. No committed pointer to it exists in the [[source-only mirror]].
_Avoid_: committed redirect, public pointer release

**account** — an Anthropic identity a Claude Code session is logged in as. On disk it is
`.credentials.json` plus `.claude.json`'s `userID`/`oauthAccount.*`, and it is bound to a
[[config root]]: Claude Code holds exactly one account per root, `/login` replaces it, and
there is no in-product account switching. Distinct from an endpoint (an spt identity
other agents address) and from a [[alt profile]] (the launch overlay that selects a root).
_Avoid_: profile, login, user

**config root** — the directory Claude Code keeps its per-user state in, selected by
`CLAUDE_CONFIG_DIR` and defaulting to `~/.claude`. Holds one [[account]]'s credentials, the
trust store, and the session/transcript state. Because an account is bound to a root,
swapping roots at launch is the only way to run as a different account.
_Avoid_: instance, profile dir, account dir

**account root** — a [[config root]] that claude-spt owns and names after the [[account]] it
holds, one per account and shared by every endpoint that runs under it — so one login
serves them all. Its continuity directories are junctions into the [[shared continuity tree]]; its credentials and `.claude.json` are real files, never links, because Claude Code
rewrites those by replace and any link would silently stop tracking.
_Avoid_: instance, per-endpoint root, endpoint root

**shared continuity tree** — the single node-wide directory set (`projects/`, `todos/`,
`file-history/`, `shell-snapshots/`, `session-env/`) junctioned into every [[account root]],
so a session started under one [[account]] can be resumed under another. Directories only:
a file cannot be junctioned, which is why `history.jsonl` stays per-account.
_Avoid_: shared instance, continuity inheritance

**alt profile** — an adapter profile whose only job is to point a session at a non-default
[[account root]]. Static and pre-declared (spt has no runtime profile parameterization);
users add their own with `spt adapter create-profile` rather than waiting on an adapter
release. Selecting one changes which [[account]] pays, never which endpoint is speaking —
an endpoint keeps its id across profiles.
_Avoid_: alt account, account profile, ccs replacement