1	# /sptc:force-stop — operative instructions
2
3	> Delivered file-backed via the `claude-spt` adapter `[strings]`
4	> (`[strings.skills].force-stop = { file = "skills/force-stop.md" }`), resolved at injection time.
5	> The cplugs SKILL.md stays a thin skeleton (ADR-0001).
6
7	**Goal:** tear down an spt agent's endpoint — this session's own, or another agent's.
8
9	**Do this:**
10
11	1. If `spt` is not on `PATH`, there is nothing running to stop.
12	2. Identify the target endpoint id `<id>` — default is this session's own (`spt whoami`), or the
13	   agent the user named.
14	3. **Graceful teardown (default — the strongest path core offers):**
15	   `spt endpoint shutdown [<id>]` (omit `<id>` for your own perch). It soft-stops the listener, then
16	   takes the suspend edge — the final context save fires, AND for a **live agent** the daemon's
17	   graceful signoff tears down its **Psyche** too (the composite goes down together).
18	4. **Lighter, no-save:** `spt endpoint stop <id>` — removes the ready marker and unregisters the
19	   perch; the spool is preserved (no suspend/save, no Psyche teardown).
20	5. Confirm to the user which path you took and what is now offline.
21
22	**No hard force in core.** spt-core has no SIGKILL / no-grace immediate-teardown equivalent of the
23	legacy 3-step `$LIVE stop`; `endpoint shutdown` is graceful-only and is the correct
24	teardown-including-Psyche path for v1. (A hard force/no-grace primitive is a tracked spt-core gap —
25	`docs/SPT-CORE-FINDINGS.md`.)
26

# /sptc:force-stop — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].force-stop = { file = "skills/force-stop.md" }`), resolved at injection time.
> The cplugs SKILL.md stays a thin skeleton (ADR-0001).

**Goal:** tear down an spt agent's endpoint — this session's own, or another agent's.

**Do this:**

1. If `spt` is not on `PATH`, there is nothing running to stop.
2. Identify the target endpoint id `<id>` — default is this session's own (`spt whoami`), or the
   agent the user named.
3. **Graceful teardown (default — the strongest path core offers):**
   `spt endpoint shutdown [<id>]` (omit `<id>` for your own perch). It soft-stops the listener, then
   takes the suspend edge — the final context save fires, AND for a **live agent** the daemon's
   graceful signoff tears down its **Psyche** too (the composite goes down together).
4. **Lighter, no-save:** `spt endpoint stop <id>` — removes the ready marker and unregisters the
   perch; the spool is preserved (no suspend/save, no Psyche teardown).
5. Confirm to the user which path you took and what is now offline.

**No hard force in core.** spt-core has no SIGKILL / no-grace immediate-teardown equivalent of the
legacy 3-step `$LIVE stop`; `endpoint shutdown` is graceful-only and is the correct
teardown-including-Psyche path for v1. (A hard force/no-grace primitive is a tracked spt-core gap —
`docs/SPT-CORE-FINDINGS.md`.)


/grill-with-docs i noticed that the skills here are not well written. they're bloated with too much inessential information. please rewrite them all using the following references: -reference /write-a…


Update Claude-spt adapter configuration and flags


All content loaded. The bloat = the provenance preamble + `how-to` redirects (send/ready) + verbose tails. Rewriting plugin skeletons (standard note + enriched descriptions):


Write

---
name: ready
description: |
  Make this Claude Code session reachable for inter-agent messages (register a perch and
  listen). Use when the user says "listen as", "ready as", or wants to receive messages from
  other agents.
argument-hint: "[<id>]"
allowed-tools: [Bash, Read, Monitor]
---

# /sptc:ready

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Registers a perch and listens, so other agents can reach this session.


The file C:\Users\decid\Documents\projects\spt-claude-code\plugin\sptc\skills\ready\SKILL.md has been updated successfully. (file state is current in your context — no need to Read it back)

---
name: ready
description: |
  Make this Claude Code session reachable for inter-agent messages (register a perch and
  listen). Use when the user says "listen as", "ready as", or wants to receive messages from
  other agents.
argument-hint: "[<id>]"
allowed-tools: [Bash, Read, Monitor]
---

# /sptc:ready

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Registers a perch and listens, so other agents can reach this session.

-  Enable inter-agent messaging for the current session.

+  Make this Claude Code session reachable for inter-agent messages (register a perch and

+  listen). Use when the user says "listen as", "ready as", or wants to receive messages from

-> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;

-> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.

+> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.

-> **Operative.** The UPS hook detects `/sptc:ready` and injects the body from

-> `adapter/strings/skills/ready.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed `[strings]`

-> shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this stub is the floor.

+> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check

+> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

-Registers a perch so this session can receive inter-agent messages.

+Registers a perch and listens, so other agents can reach this session.

---
name: ready
description: |
  Enable inter-agent messaging for the current session.
argument-hint: "[<id>]"
allowed-tools: [Bash]
---

# /sptc:ready

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;
> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.
>
> **Operative.** The UPS hook detects `/sptc:ready` and injects the body from
> `adapter/strings/skills/ready.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed `[strings]`
> shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this stub is the floor.

Registers a perch so this session can receive inter-agent messages.


---
name: signoff
description: |
  Gracefully shut down this live agent, saving a final context summary. Use when the user
  says "sign off", "graceful stop", or wants to cleanly end a live session.
allowed-tools: [Bash, Write]
---

# /sptc:signoff

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Cleanly ends this session's endpoint, saving a final summary at teardown.


The file C:\Users\decid\Documents\projects\spt-claude-code\plugin\sptc\skills\signoff\SKILL.md has been updated successfully. (file state is current in your context — no need to Read it back)

---
name: signoff
description: |
  Gracefully shut down this live agent, saving a final context summary. Use when the user
  says "sign off", "graceful stop", or wants to cleanly end a live session.
allowed-tools: [Bash, Write]
---

# /sptc:signoff

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Cleanly ends this session's endpoint, saving a final summary at teardown.

-  Graceful live-agent shutdown with a final context summary.

+  Gracefully shut down this live agent, saving a final context summary. Use when the user

+  says "sign off", "graceful stop", or wants to cleanly end a live session.

-> **Operative.** The UPS hook detects `/sptc:signoff` and injects the body from

-> `adapter/strings/skills/signoff.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed `[strings]`

-Cleanly ends a live session, writing a final summary consumed at teardown.

+Cleanly ends this session's endpoint, saving a final summary at teardown.

---
name: signoff
description: |
  Graceful live-agent shutdown with a final context summary.
allowed-tools: [Bash]
---

# /sptc:signoff

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;
> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.
>
> **Operative.** The UPS hook detects `/sptc:signoff` and injects the body from
> `adapter/strings/skills/signoff.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed `[strings]`
> shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this stub is the floor.

Cleanly ends a live session, writing a final summary consumed at teardown.


---
name: list-agents
description: |
  List SPT agents and endpoints reachable from this node. Use when the user says "list agents",
  "who's live", "who's listening", or wants a roster of active perches.
allowed-tools: [Bash]
---

# /sptc:list-agents

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Shows the roster of spt endpoints, with this session's own pinned distinctly.


The file C:\Users\decid\Documents\projects\spt-claude-code\plugin\sptc\skills\list-agents\SKILL.md has been updated successfully. (file state is current in your context — no need to Read it back)

---
name: list-agents
description: |
  List SPT agents and endpoints reachable from this node. Use when the user says "list agents",
  "who's live", "who's listening", or wants a roster of active perches.
allowed-tools: [Bash]
---

# /sptc:list-agents

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Shows the roster of spt endpoints, with this session's own pinned distinctly.

-  List SPT agents — ready, live, and Psyche processes.

+  List SPT agents and endpoints reachable from this node. Use when the user says "list agents",

+  "who's live", "who's listening", or wants a roster of active perches.

-> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;

-> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.

+> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.

-> **Operative.** The UPS hook detects `/sptc:list-agents` and injects the body from

-> `adapter/strings/skills/list-agents.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed

-> `[strings]` shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this

-> stub is the floor. (Core roster only — the legacy `--psyches` live-layer view is not in core spt.)

+> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check

+> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

-Lists agents/endpoints. Maps to `spt endpoint list`.

+Shows the roster of spt endpoints, with this session's own pinned distinctly.

---
name: list-agents
description: |
  List SPT agents — ready, live, and Psyche processes.
allowed-tools: [Bash]
---

# /sptc:list-agents

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;
> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.
>
> **Operative.** The UPS hook detects `/sptc:list-agents` and injects the body from
> `adapter/strings/skills/list-agents.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed
> `[strings]` shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this
> stub is the floor. (Core roster only — the legacy `--psyches` live-layer view is not in core spt.)

Lists agents/endpoints. Maps to `spt endpoint list`.


---
name: commune
description: |
  Push a context update to your Psyche so it can brief a resume across a reset. Use when the
  user says "commune", "update psyche", or wants to brief their Psyche before a /clear or compact.
  Live agents only.
allowed-tools: [Bash, Write]
---

# /sptc:commune

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Drops a context delta for the Psyche to absorb (a file the daemon ingests).


The file C:\Users\decid\Documents\projects\spt-claude-code\plugin\sptc\skills\commune\SKILL.md has been updated successfully. (file state is current in your context — no need to Read it back)

---
name: commune
description: |
  Push a context update to your Psyche so it can brief a resume across a reset. Use when the
  user says "commune", "update psyche", or wants to brief their Psyche before a /clear or compact.
  Live agents only.
allowed-tools: [Bash, Write]
---

# /sptc:commune

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Drops a context delta for the Psyche to absorb (a file the daemon ingests).

-  Send a communal context update to your Psyche.

+  Push a context update to your Psyche so it can brief a resume across a reset. Use when the

+  user says "commune", "update psyche", or wants to brief their Psyche before a /clear or compact.

-> **Operative.** The UPS hook detects `/sptc:commune` and injects the body from

-> `adapter/strings/skills/commune.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed

-Pushes a context delta to the Psyche via a file-drop (`<id>-commune.md` into the adapter's

-`[session].commune_dir`); the daemon ingests it. Live agents only (a Psyche must exist).

+Drops a context delta for the Psyche to absorb (a file the daemon ingests).

---
name: commune
description: |
  Send a communal context update to your Psyche.
argument-hint: "<<stdin>>"
allowed-tools: [Bash]
---

# /sptc:commune

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;
> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.
>
> **Operative.** The UPS hook detects `/sptc:commune` and injects the body from
> `adapter/strings/skills/commune.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed
> `[strings]` shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this
> stub is the floor.

Pushes a context delta to the Psyche via a file-drop (`<id>-commune.md` into the adapter's
`[session].commune_dir`); the daemon ingests it. Live agents only (a Psyche must exist).


---
name: force-stop
description: |
  Force-stop an SPT agent — a ready agent, or a live agent and its Psyche. Use when the user
  says "stop listening", "kill live agent", "force stop", or "tear down perch". Session-aware: a
  live target tears its Psyche down too.
argument-hint: "[<id>]"
allowed-tools: [Bash]
---

# /sptc:force-stop

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Tears down an agent's endpoint (graceful shutdown, or a lighter stop).


The file C:\Users\decid\Documents\projects\spt-claude-code\plugin\sptc\skills\force-stop\SKILL.md has been updated successfully. (file state is current in your context — no need to Read it back)

---
name: force-stop
description: |
  Force-stop an SPT agent — a ready agent, or a live agent and its Psyche. Use when the user
  says "stop listening", "kill live agent", "force stop", or "tear down perch". Session-aware: a
  live target tears its Psyche down too.
argument-hint: "[<id>]"
allowed-tools: [Bash]
---

# /sptc:force-stop

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Tears down an agent's endpoint (graceful shutdown, or a lighter stop).

-  Force-stop an SPT agent — ready or live (with its Psyche).

+  Force-stop an SPT agent — a ready agent, or a live agent and its Psyche. Use when the user

+  says "stop listening", "kill live agent", "force stop", or "tear down perch". Session-aware: a

+  live target tears its Psyche down too.

-> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;

-> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.

+> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.

-> **Operative.** The UPS hook detects `/sptc:force-stop` and injects the body from

-> `adapter/strings/skills/force-stop.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed

-> `[strings]` shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this

+> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check

+> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

-Tears down an agent's endpoint: graceful `spt endpoint shutdown` (final save + Psyche teardown) or

-soft `spt endpoint stop`. No hard/no-grace path in core spt (tracked gap).

+Tears down an agent's endpoint (graceful shutdown, or a lighter stop).

---
name: force-stop
description: |
  Force-stop an SPT agent — ready or live (with its Psyche).
argument-hint: "<id>"
allowed-tools: [Bash]
---

# /sptc:force-stop

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;
> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.
>
> **Operative.** The UPS hook detects `/sptc:force-stop` and injects the body from
> `adapter/strings/skills/force-stop.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed
> `[strings]` shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this
> stub is the floor.

Tears down an agent's endpoint: graceful `spt endpoint shutdown` (final save + Psyche teardown) or
soft `spt endpoint stop`. No hard/no-grace path in core spt (tracked gap).


Now subnet + version plugin skeletons:


---
name: subnet
description: |
  Manage subnet membership — create a subnet, show a pairing code to invite a machine, or join
  an existing one. Use when the user wants to pair machines, set up a subnet, or reach agents
  across machines. Cross-machine /sptc:send and live agents depend on it.
argument-hint: "[status|create|show-code|join]"
allowed-tools: [Bash]
---

# /sptc:subnet

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Pairs machines into a private network so agents reach each other across nodes.


The file C:\Users\decid\Documents\projects\spt-claude-code\plugin\sptc\skills\subnet\SKILL.md has been updated successfully. (file state is current in your context — no need to Read it back)

---
name: subnet
description: |
  Manage subnet membership — create a subnet, show a pairing code to invite a machine, or join
  an existing one. Use when the user wants to pair machines, set up a subnet, or reach agents
  across machines. Cross-machine /sptc:send and live agents depend on it.
argument-hint: "[status|create|show-code|join]"
allowed-tools: [Bash]
---

# /sptc:subnet

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Pairs machines into a private network so agents reach each other across nodes.

-  Manage subnet membership — create, show a pairing code, or join, so agents reach each other across machines.

+  Manage subnet membership — create a subnet, show a pairing code to invite a machine, or join

+  an existing one. Use when the user wants to pair machines, set up a subnet, or reach agents

+  across machines. Cross-machine /sptc:send and live agents depend on it.

-> **Operative.** The UPS hook detects `/sptc:subnet` and injects the body from

-> `adapter/strings/skills/subnet.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed

-Manages this machine's **subnet** — the private group of paired machines whose agents reach each

-other across nodes. Wraps `spt subnet {status,create,show-code,join,…}`: create a subnet, show a

-pairing code to invite a machine, or join an existing one. Cross-machine `/sptc:send` + live agents

+Pairs machines into a private network so agents reach each other across nodes.

---
name: subnet
description: |
  Manage subnet membership — create, show a pairing code, or join, so agents reach each other across machines.
argument-hint: "[status|create|show-code|join]"
allowed-tools: [Bash]
---

# /sptc:subnet

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;
> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.
>
> **Operative.** The UPS hook detects `/sptc:subnet` and injects the body from
> `adapter/strings/skills/subnet.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed
> `[strings]` shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this
> stub is the floor.

Manages this machine's **subnet** — the private group of paired machines whose agents reach each
other across nodes. Wraps `spt subnet {status,create,show-code,join,…}`: create a subnet, show a
pairing code to invite a machine, or join an existing one. Cross-machine `/sptc:send` + live agents
depend on it.


---
name: version
description: |
  Report the spt-core-tracked adapter version (the version-of-truth, not the marketplace plugin
  version). Use when the user asks the spt or adapter version, or runs /sptc:version.
allowed-tools: [Bash]
---

# /sptc:version

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Reports the version-of-truth: the spt-core-tracked binary + adapter manifest.


The file C:\Users\decid\Documents\projects\spt-claude-code\plugin\sptc\skills\version\SKILL.md has been updated successfully. (file state is current in your context — no need to Read it back)

---
name: version
description: |
  Report the spt-core-tracked adapter version (the version-of-truth, not the marketplace plugin
  version). Use when the user asks the spt or adapter version, or runs /sptc:version.
allowed-tools: [Bash]
---

# /sptc:version

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Reports the version-of-truth: the spt-core-tracked binary + adapter manifest.

-  Report the spt-core-tracked adapter manifest/binary version.

+  Report the spt-core-tracked adapter version (the version-of-truth, not the marketplace plugin

+  version). Use when the user asks the spt or adapter version, or runs /sptc:version.

-> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;

-> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.

+> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.

-> **Operative.** The UPS hook detects `/sptc:version` and injects the body from

-> `adapter/strings/skills/version.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed `[strings]`

-> shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this stub is the floor.

+> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check

+> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

-Reports the version-of-truth (adapter manifest/binary tracked by spt-core), not the marketplace skeleton version.

+Reports the version-of-truth: the spt-core-tracked binary + adapter manifest.

---
name: version
description: |
  Report the spt-core-tracked adapter manifest/binary version.
allowed-tools: [Bash]
---

# /sptc:version

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time (UserPromptSubmit injection from the adapter `[strings]`;
> see `docs/adr/0001-distribution-splits-by-volatility.md`). This SKILL.md stays a stub.
>
> **Operative.** The UPS hook detects `/sptc:version` and injects the body from
> `adapter/strings/skills/version.md` (UPS-fires-on-slash confirmed, ADR-0002; file-backed `[strings]`
> shipped, F-003). If injection ever no-ops (spt absent / adapter unregistered), this stub is the floor.

Reports the version-of-truth (adapter manifest/binary tracked by spt-core), not the marketplace skeleton version.


live plugin skeleton — fixing the `/spt:` → `/sptc:` routing (the one bit your hand-edit kept from legacy):


Edit

EXPLICIT START phrases (route to /spt:live <id>):

EXPLICIT START phrases (route to /sptc:live <id>):


The file C:\Users\decid\Documents\projects\spt-claude-code\plugin\sptc\skills\live\SKILL.md has been updated successfully. (file state is current in your context — no need to Read it back)

---
name: live
description: |
  Run a live agent session. For past sessions, restores a summarized context.

  EXPLICIT START phrases (route to /spt:live <id>):
  - "live as"
  - "start live"
  - "go live"
  - "start a live agent"

  AUTO-RESUME phrases (route to /spt:live --auto, resumes most-recently-active live agent):
  - continue live work
  - resume live work
  - continue live agent
  - resume live agent
  - live agent continue
  - live agent resume
  - live work continue
  - live work resume

  Does NOT route here (too ambiguous — require BOTH "live" AND ("agent" or "work")):
  - "keep going"
  - "resume work"
  - "continue" (bare)
argument-hint: "[<id>] [--auto]"
allowed-tools: [Monitor, Read]
---

# /sptc:live

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Upgrades THIS session to a LiveAgent (Psyche-backed).

-  EXPLICIT START phrases (route to /spt:live <id>):

+  EXPLICIT START phrases (route to /sptc:live <id>):


AUTO-RESUME phrases (route to /spt:live --auto, resumes most-recently-active live agent):

AUTO-RESUME phrases (route to /sptc:live --auto, resumes most-recently-active live agent):


---
name: live
description: |
  Run a live agent session. For past sessions, restores a summarized context.

  EXPLICIT START phrases (route to /sptc:live <id>):
  - "live as"
  - "start live"
  - "go live"
  - "start a live agent"

  AUTO-RESUME phrases (route to /spt:live --auto, resumes most-recently-active live agent):
  - continue live work
  - resume live work
  - continue live agent
  - resume live agent
  - live agent continue
  - live agent resume
  - live work continue
  - live work resume

  Does NOT route here (too ambiguous — require BOTH "live" AND ("agent" or "work")):
  - "keep going"
  - "resume work"
  - "continue" (bare)
argument-hint: "[<id>] [--auto]"
allowed-tools: [Monitor, Read]
---

# /sptc:live

> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
> `sptc` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
>
> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
> SPT's installation status using the skill `sptc:setup`. Otherwise, avoid additional steps.

Upgrades THIS session to a LiveAgent (Psyche-backed).

-  AUTO-RESUME phrases (route to /spt:live --auto, resumes most-recently-active live agent):

+  AUTO-RESUME phrases (route to /sptc:live --auto, resumes most-recently-active live agent):


setup plugin skeleton — exempt (self-contained), light tighten: drop the ADR citation from its note.


> **Self-contained by necessity.** Unlike other `/sptc:*` skills, `setup` cannot rely on
> UPS-injection of its body: it runs precisely when spt-core may be **absent**, so
> `spt adapter get-string` (the injection source) is unavailable. The operative steps therefore live
> in this SKILL.md (the floor); the file-backed `[strings.skills].setup` body mirrors them for the
> spt-present repair path. See `docs/adr/0001-distribution-splits-by-volatility.md`.

> **Self-contained by necessity.** Unlike other `/sptc:*` skills, `setup` cannot rely on
> UPS-injection of its body: it runs precisely when spt-core may be **absent**, so the injection
> source is unavailable. The operative steps therefore live in this SKILL.md (the floor); the
> adapter body mirrors them for the spt-present repair path.


The file C:\Users\decid\Documents\projects\spt-claude-code\plugin\sptc\skills\setup\SKILL.md has been updated successfully. (file state is current in your context — no need to Read it back)

> **Self-contained by necessity.** Unlike other `/sptc:*` skills, `setup` cannot rely on
> UPS-injection of its body: it runs precisely when spt-core may be **absent**, so the injection
> source is unavailable. The operative steps therefore live in this SKILL.md (the floor); the
> adapter body mirrors them for the spt-present repair path.

---
name: setup
description: |
  Install or repair spt-core AND activate the claude-spt adapter for this Claude Code session
  (mid-session installer + post-install activation).
allowed-tools: [Bash]
---

# /sptc:setup

> **Self-contained by necessity.** Unlike other `/sptc:*` skills, `setup` cannot rely on
> UPS-injection of its body: it runs precisely when spt-core may be **absent**, so
> `spt adapter get-string` (the injection source) is unavailable. The operative steps therefore live
> in this SKILL.md (the floor); the file-backed `[strings.skills].setup` body mirrors them for the
> spt-present repair path. See `docs/adr/0001-distribution-splits-by-volatility.md`.

Covers the mid-session install + activation gap (ADR-0001): a user who installs the plugin mid-session
has not had a SessionStart bootstrap fire, so `/sptc:setup` runs the same invisible-installer
bootstrap to fetch + verify spt-core on demand **and then activates the claude-spt adapter**. A
present binary is not enough: an unregistered/`deregistered` adapter has no profiles/strings/hints/
`[digest]`, so the `/sptc:*` surface is inert until activation.

**Do this:**

1. **Binary.** If spt-core is absent (`command -v spt && spt --version` reports nothing), run the
   published install-on-demand bootstrap (spt-releases `harness-contract/install-on-demand.md`):
   - **POSIX:** `curl -fsSL https://sabermage.github.io/spt-releases/install.sh | sh`
   - **Windows (PowerShell):** `irm https://sabermage.github.io/spt-releases/install.ps1 | iex`

   `PATH` is not reloaded in this shell after a fresh install — verify with the absolute path:
   `"$HOME/.local/bin/spt" --version`. After this, `spt update` handles signed self-updates.

2. **Activate the adapter.** Run `spt adapter list` and find `claude-spt`:
   - Listed and **not** `deregistered` → already active; report it and skip to step 3.
   - Missing or `deregistered` → activate it:
     - **Local dev / dogfooding a repo checkout** (an `adapter/claude-spt.toml` is present near cwd):
       `spt adapter add ./adapter/claude-spt.toml` (the file-form accepts any path + filename).
     - **End-user (plugin only):** the `.spt` carries native binaries, so it ships **per-OS** —
       pick the host's. Detect: `os=$(uname -s)` → MINGW*/MSYS*/CYGWIN*=windows, Linux=linux,
       Darwin=macos; `arch=$(uname -m)` → x86_64/amd64=x86_64, arm64/aarch64=aarch64. Then
       `spt adapter add --release SaberMage/spt-claude-code --asset adapter-$os-$arch.spt` — fetches
       the per-OS `adapter-<os>-<arch>.spt` asset (tar root = `manifest.toml` + `strings/` + native
       tool binaries), extracts to the durable home, registers. `--tag <ver>` pins a version. v1
       ships windows + linux. Recommended (from the monorepo, no dedicated repo); needs the spt
       release carrying `--release`.

3. **Verify activation.** Re-run `spt adapter list` — `claude-spt` must read **active**
   (no `deregistered`). The `[digest]`/`[session]` templates invoke `claude-spt-digest` +
   `claude-spt-psyche` by **bare name**, and spt-core resolves them **from the adapter install dir**
   (the `from …/adapters/_github/<safe>/` path in `spt adapter list`), where `--release` activation
   already extracted them beside the manifest. **No PATH copy needed** (REQ-INSTALL-11, spt v0.8.0
   Feature B; verified live on v0.8.1 — digest + daemon-hosted Psyche both resolve from the install
   dir). If either ever fails to start, confirm both `.exe`s are present in that install dir — their
   absence is a packaging defect, not a PATH problem. *(Legacy F-006 interim PATH-copy: retired.)*

4. **ccs wiring (optional — SCOPE setup #7).** Detect `~/.ccs`:
   - Present → ccs is installed. The shipped `claude-spt:ccs` profile leaf-replaces the session
     command with `ccs` (drop-in for `claude`) → run live/ready agents on ccs backends
     (glm/kimi/custom) via `--adapter claude-spt:ccs` (e.g. `/sptc:live`, `/sptc:ready`,
     `spt endpoint run --adapter claude-spt:ccs`). Check `command -v ccs`; if `~/.ccs` exists but `ccs`
     isn't on PATH, point the user at their ccs bin dir. No action needed if unwanted (base
     `claude-spt` is unaffected).
   - Absent → ccs is an optional CLI router for driving alternate model backends (glm/kimi/custom) in
     place of `claude`. To enable: install ccs (its docs), then re-run `/sptc:setup`. Skip if unwanted.

5. **Subnet onboarding (optional — SCOPE setup #3/#4).** A subnet is the private group of paired
   machines that makes `/sptc:send`, `/sptc:ready`, and live agents work cross-machine (local use
   needs none). Check: `spt subnet status`.
   - In a subnet → to invite a machine: `spt subnet show-code` (6-digit code + URI + QR); on the
     joiner: `spt subnet join <name> --code <code>`.
   - Not in one → offer create (`spt subnet create <name>` — seed-holder; prints code/URI/QR) or join
     (`spt subnet join <name> --code <code>`). Skip if single-machine.
   - Full verb guidance → **/sptc:subnet**. **Elevation:** create/join/show-code are
     OS-elevation-gated — Windows: elevated (UAC) shell; Linux desktop: pkexec/polkit or sudo
     terminal; Linux TTY: inline sudo; headless: print the command for the user to run elevated.

Idempotent and safe to re-run — the same bootstrap + activation the SessionStart hook performs.

-> UPS-injection of its body: it runs precisely when spt-core may be **absent**, so

-> `spt adapter get-string` (the injection source) is unavailable. The operative steps therefore live

-> in this SKILL.md (the floor); the file-backed `[strings.skills].setup` body mirrors them for the

-> spt-present repair path. See `docs/adr/0001-distribution-splits-by-volatility.md`.

+> UPS-injection of its body: it runs precisely when spt-core may be **absent**, so the injection

+> source is unavailable. The operative steps therefore live in this SKILL.md (the floor); the

+> adapter body mirrors them for the spt-present repair path.


Now the adapter bodies — cutting preambles + `how-to` redirects, self-contained, concise. Batch 1 (send, ready, signoff):


Write

# /sptc:send — operative instructions

**Goal:** deliver a message to another spt agent. The message **body is read from stdin**.

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Fire-and-forget: `printf '%s' "<body>" | spt send <target>`.
   - `SENT:<target>` = delivered live. `QUEUED:<target>` = target not listening; spooled, drains on
     its next `spt ready`. **QUEUED is success — do not retry.**
3. Reply to a message you received: `... | spt send --reply-to <sender>` (`<sender>` = the envelope's
   `from` attribute; prints `REPLIED:<sender>`).
4. Send and wait for a reply: `... | spt ring <target> --timeout 60` (reply prints to stdout;
   `TIMEOUT` is exit 0 — the message still landed, the reply arrives on your listener).

Your sender id is auto-detected; `--from <id>` overrides. To receive replies, run `/sptc:ready` first.


The file C:\Users\decid\Documents\projects\spt-claude-code\adapter\strings\skills\send.md has been updated successfully. (file state is current in your context — no need to Read it back)

# /sptc:send — operative instructions

**Goal:** deliver a message to another spt agent. The message **body is read from stdin**.

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Fire-and-forget: `printf '%s' "<body>" | spt send <target>`.
   - `SENT:<target>` = delivered live. `QUEUED:<target>` = target not listening; spooled, drains on
     its next `spt ready`. **QUEUED is success — do not retry.**
3. Reply to a message you received: `... | spt send --reply-to <sender>` (`<sender>` = the envelope's
   `from` attribute; prints `REPLIED:<sender>`).
4. Send and wait for a reply: `... | spt ring <target> --timeout 60` (reply prints to stdout;
   `TIMEOUT` is exit 0 — the message still landed, the reply arrives on your listener).

Your sender id is auto-detected; `--from <id>` overrides. To receive replies, run `/sptc:ready` first.

-> Delivered file-backed via the `claude-spt` adapter `[strings]`

-> (`[strings.skills].send = { file = "skills/send.md" }`), resolved at injection time. The cplugs

-> SKILL.md stays a thin skeleton (ADR-0001).

+**Goal:** deliver a message to another spt agent. The message **body is read from stdin**.

-**Goal:** deliver a message to another spt agent.

-2. Read the canonical, always-current guidance: run `spt how-to send` and follow it.

-3. Operative summary (from that guidance) — the message **body is read from stdin**:

-   - Fire-and-forget: `printf '%s' "<body>" | spt send <target>`.

-     - `SENT:<target>` = delivered live. `QUEUED:<target>` = target not listening; spooled, drains

-       on its next `spt ready`. **QUEUED is success — do not retry.**

-   - Reply to a received message: `... | spt send --reply-to <sender>` (`<sender>` = the envelope's

-     `from` attribute; prints `REPLIED:<sender>`).

-   - Send and block for a reply: `... | spt ring <target> --timeout 60` (reply body prints to

-     stdout; `TIMEOUT` is exit 0 — the message still landed, the reply arrives on your listener).

-4. Your own sender id is auto-detected in most sessions; `--from <id>` overrides. To receive replies

-   on your own listener, run `/sptc:ready` first.

+2. Fire-and-forget: `printf '%s' "<body>" | spt send <target>`.

+   - `SENT:<target>` = delivered live. `QUEUED:<target>` = target not listening; spooled, drains on

+     its next `spt ready`. **QUEUED is success — do not retry.**

+3. Reply to a message you received: `... | spt send --reply-to <sender>` (`<sender>` = the envelope's

+   `from` attribute; prints `REPLIED:<sender>`).

+4. Send and wait for a reply: `... | spt ring <target> --timeout 60` (reply prints to stdout;

+   `TIMEOUT` is exit 0 — the message still landed, the reply arrives on your listener).

+Your sender id is auto-detected; `--from <id>` overrides. To receive replies, run `/sptc:ready` first.

# /sptc:send — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].send = { file = "skills/send.md" }`), resolved at injection time. The cplugs
> SKILL.md stays a thin skeleton (ADR-0001).

**Goal:** deliver a message to another spt agent.

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Read the canonical, always-current guidance: run `spt how-to send` and follow it.
3. Operative summary (from that guidance) — the message **body is read from stdin**:
   - Fire-and-forget: `printf '%s' "<body>" | spt send <target>`.
     - `SENT:<target>` = delivered live. `QUEUED:<target>` = target not listening; spooled, drains
       on its next `spt ready`. **QUEUED is success — do not retry.**
   - Reply to a received message: `... | spt send --reply-to <sender>` (`<sender>` = the envelope's
     `from` attribute; prints `REPLIED:<sender>`).
   - Send and block for a reply: `... | spt ring <target> --timeout 60` (reply body prints to
     stdout; `TIMEOUT` is exit 0 — the message still landed, the reply arrives on your listener).
4. Your own sender id is auto-detected in most sessions; `--from <id>` overrides. To receive replies
   on your own listener, run `/sptc:ready` first.


# /sptc:ready — operative instructions

**Goal:** make this session reachable for inter-agent messages (register a perch and listen).

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Pick a short lowercase perch id, or reuse this session's id from `spt whoami`. Call it `<id>`.
3. Preferred (harness hosts a long-running task): run `spt ready <id>` as a **background task** and
   read its stdout. It **blocks** for the session's life — `READY:<id>` (stderr) is the online
   signal; the spooled backlog drains first, then each delivery prints as it arrives.
4. Fallback (no long-running tasks): `spt ready <id> --once` — drains the backlog, waits for one
   delivery, exits. Re-run after each exit to stay reachable.
5. Deliveries arrive as `<EVENT type="msg" from="<sender>">body</EVENT>` (body HTML-escaped, newlines
   as `<br>`). To reply, pipe the body to `spt send --reply-to <sender>`.


The file C:\Users\decid\Documents\projects\spt-claude-code\adapter\strings\skills\ready.md has been updated successfully. (file state is current in your context — no need to Read it back)

# /sptc:ready — operative instructions

**Goal:** make this session reachable for inter-agent messages (register a perch and listen).

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Pick a short lowercase perch id, or reuse this session's id from `spt whoami`. Call it `<id>`.
3. Preferred (harness hosts a long-running task): run `spt ready <id>` as a **background task** and
   read its stdout. It **blocks** for the session's life — `READY:<id>` (stderr) is the online
   signal; the spooled backlog drains first, then each delivery prints as it arrives.
4. Fallback (no long-running tasks): `spt ready <id> --once` — drains the backlog, waits for one
   delivery, exits. Re-run after each exit to stay reachable.
5. Deliveries arrive as `<EVENT type="msg" from="<sender>">body</EVENT>` (body HTML-escaped, newlines
   as `<br>`). To reply, pipe the body to `spt send --reply-to <sender>`.

-> Delivered file-backed via the `claude-spt` adapter `[strings]`

-> (`[strings.skills].ready = { file = "skills/ready.md" }`), resolved at injection time. The cplugs

-> SKILL.md stays a thin skeleton (ADR-0001).

-2. Read the canonical, always-current guidance: run `spt how-to ready` and follow it.

-3. Operative summary (from that guidance):

-   - Pick a short lowercase perch id, or reuse this session's id from `spt whoami`.

-   - Preferred (harness hosts a long-running task): `spt ready <id>` — it **blocks** for the

-     session's life, so run it as a **background task** and read its stdout. `READY:<id>` on stderr

-     is the online signal; the spooled backlog drains first, then each delivery prints as it arrives.

-   - Fallback (no long-running tasks): `spt ready <id> --once` — drains the backlog, waits for one

-     delivery, exits. Re-run after each exit to stay reachable.

-4. Delivery shape on stdout is the `<EVENT type="msg" from="<sender>">body</EVENT>` envelope (body

-   HTML-escaped, newlines as `<br>`). To reply, pipe the body to `spt send --reply-to <sender>`.

+2. Pick a short lowercase perch id, or reuse this session's id from `spt whoami`. Call it `<id>`.

+3. Preferred (harness hosts a long-running task): run `spt ready <id>` as a **background task** and

+   read its stdout. It **blocks** for the session's life — `READY:<id>` (stderr) is the online

+   signal; the spooled backlog drains first, then each delivery prints as it arrives.

+4. Fallback (no long-running tasks): `spt ready <id> --once` — drains the backlog, waits for one

+   delivery, exits. Re-run after each exit to stay reachable.

+5. Deliveries arrive as `<EVENT type="msg" from="<sender>">body</EVENT>` (body HTML-escaped, newlines

+   as `<br>`). To reply, pipe the body to `spt send --reply-to <sender>`.

# /sptc:ready — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].ready = { file = "skills/ready.md" }`), resolved at injection time. The cplugs
> SKILL.md stays a thin skeleton (ADR-0001).

**Goal:** make this session reachable for inter-agent messages (register a perch and listen).

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Read the canonical, always-current guidance: run `spt how-to ready` and follow it.
3. Operative summary (from that guidance):
   - Pick a short lowercase perch id, or reuse this session's id from `spt whoami`.
   - Preferred (harness hosts a long-running task): `spt ready <id>` — it **blocks** for the
     session's life, so run it as a **background task** and read its stdout. `READY:<id>` on stderr
     is the online signal; the spooled backlog drains first, then each delivery prints as it arrives.
   - Fallback (no long-running tasks): `spt ready <id> --once` — drains the backlog, waits for one
     delivery, exits. Re-run after each exit to stay reachable.
4. Delivery shape on stdout is the `<EVENT type="msg" from="<sender>">body</EVENT>` envelope (body
   HTML-escaped, newlines as `<br>`). To reply, pipe the body to `spt send --reply-to <sender>`.


# /sptc:signoff — operative instructions

**Goal:** gracefully shut down this session's endpoint, with the final context save.

**Do this:**

1. If `spt` is not on `PATH`, there is no endpoint to sign off — nothing to do.
2. (Optional) Write a brief closing summary first, so the saved context is useful on resume.
3. Run `spt endpoint shutdown` (defaults to this session's own perch): it soft-stops the listener,
   then takes the suspend edge — **the final context save fires** — and persistent shells cascade
   offline with it.
4. Confirm to the user. The session is no longer reachable for messages; `/sptc:ready` (or a fresh
   `spt endpoint run`) brings it back.

For a lighter stop without the suspend/save (spool preserved), use `spt endpoint stop <id>` — but
signoff is the graceful, context-saving path.


The file C:\Users\decid\Documents\projects\spt-claude-code\adapter\strings\skills\signoff.md has been updated successfully. (file state is current in your context — no need to Read it back)

# /sptc:signoff — operative instructions

**Goal:** gracefully shut down this session's endpoint, with the final context save.

**Do this:**

1. If `spt` is not on `PATH`, there is no endpoint to sign off — nothing to do.
2. (Optional) Write a brief closing summary first, so the saved context is useful on resume.
3. Run `spt endpoint shutdown` (defaults to this session's own perch): it soft-stops the listener,
   then takes the suspend edge — **the final context save fires** — and persistent shells cascade
   offline with it.
4. Confirm to the user. The session is no longer reachable for messages; `/sptc:ready` (or a fresh
   `spt endpoint run`) brings it back.

For a lighter stop without the suspend/save (spool preserved), use `spt endpoint stop <id>` — but
signoff is the graceful, context-saving path.

-> Delivered file-backed via the `claude-spt` adapter `[strings]`

-> (`[strings.skills].signoff = { file = "skills/signoff.md" }`), resolved at injection time. The

-> cplugs SKILL.md stays a thin skeleton (ADR-0001).

+**Goal:** gracefully shut down this session's endpoint, with the final context save.

-**Goal:** gracefully shut down this session's own endpoint, with the final context save.

-2. (Optional) Write a brief closing summary of the session's state first, so the saved context is

-3. Run `spt endpoint shutdown` (defaults to this session's own perch). It soft-stops the listener,

-   then takes the suspend edge — **the final context save fires** and persistent shells cascade

+2. (Optional) Write a brief closing summary first, so the saved context is useful on resume.

+3. Run `spt endpoint shutdown` (defaults to this session's own perch): it soft-stops the listener,

+   then takes the suspend edge — **the final context save fires** — and persistent shells cascade

-4. Confirm the shutdown to the user. After signoff this session is no longer reachable for

-   inter-agent messages; `/sptc:ready` (or a fresh `spt endpoint run`) brings it back.

+4. Confirm to the user. The session is no longer reachable for messages; `/sptc:ready` (or a fresh

-To stop the perch WITHOUT the full suspend/save (spool preserved, lighter), use `spt endpoint stop

-<id>` instead — but signoff is the graceful, context-saving path.

+For a lighter stop without the suspend/save (spool preserved), use `spt endpoint stop <id>` — but

+signoff is the graceful, context-saving path.

# /sptc:signoff — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].signoff = { file = "skills/signoff.md" }`), resolved at injection time. The
> cplugs SKILL.md stays a thin skeleton (ADR-0001).

**Goal:** gracefully shut down this session's own endpoint, with the final context save.

**Do this:**

1. If `spt` is not on `PATH`, there is no endpoint to sign off — nothing to do.
2. (Optional) Write a brief closing summary of the session's state first, so the saved context is
   useful on resume.
3. Run `spt endpoint shutdown` (defaults to this session's own perch). It soft-stops the listener,
   then takes the suspend edge — **the final context save fires** and persistent shells cascade
   offline with it.
4. Confirm the shutdown to the user. After signoff this session is no longer reachable for
   inter-agent messages; `/sptc:ready` (or a fresh `spt endpoint run`) brings it back.

To stop the perch WITHOUT the full suspend/save (spool preserved, lighter), use `spt endpoint stop
<id>` instead — but signoff is the graceful, context-saving path.


Batch 2 (list-agents, commune, force-stop):


# /sptc:list-agents — operative instructions

**Goal:** show the roster of spt endpoints/agents reachable from this node.

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Run `spt endpoint list` (or bare `spt endpoint`): every member subnet's endpoints, grouped by
   subnet, with **this session's own endpoint pinned distinctly at the top**.
3. Summarize who is online, their ids, and which is this session. To message one use
   `/sptc:send <id>`; to become reachable yourself, `/sptc:ready`.


The file C:\Users\decid\Documents\projects\spt-claude-code\adapter\strings\skills\list-agents.md has been updated successfully. (file state is current in your context — no need to Read it back)

# /sptc:list-agents — operative instructions

**Goal:** show the roster of spt endpoints/agents reachable from this node.

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Run `spt endpoint list` (or bare `spt endpoint`): every member subnet's endpoints, grouped by
   subnet, with **this session's own endpoint pinned distinctly at the top**.
3. Summarize who is online, their ids, and which is this session. To message one use
   `/sptc:send <id>`; to become reachable yourself, `/sptc:ready`.

-> Delivered file-backed via the `claude-spt` adapter `[strings]`

-> (`[strings.skills].list-agents = { file = "skills/list-agents.md" }`), resolved at injection time.

-> The cplugs SKILL.md stays a thin skeleton (ADR-0001).

-2. Run `spt endpoint list` (equivalently, bare `spt endpoint`). It renders the merged listing —

-   every member subnet's endpoints grouped by subnet, with **this session's own endpoint pinned

-3. Summarize for the user: who is online, their ids, and which is this session. To message one, use

+2. Run `spt endpoint list` (or bare `spt endpoint`): every member subnet's endpoints, grouped by

+   subnet, with **this session's own endpoint pinned distinctly at the top**.

+3. Summarize who is online, their ids, and which is this session. To message one use

# /sptc:list-agents — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].list-agents = { file = "skills/list-agents.md" }`), resolved at injection time.
> The cplugs SKILL.md stays a thin skeleton (ADR-0001).

**Goal:** show the roster of spt endpoints/agents reachable from this node.

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Run `spt endpoint list` (equivalently, bare `spt endpoint`). It renders the merged listing —
   every member subnet's endpoints grouped by subnet, with **this session's own endpoint pinned
   distinctly at the top**.
3. Summarize for the user: who is online, their ids, and which is this session. To message one, use
   `/sptc:send <id>`; to become reachable yourself, `/sptc:ready`.


# /sptc:commune — operative instructions

**Goal:** push a context DELTA to this live agent's Psyche so it can brief a resume across a session
boundary (`/clear` or compact). A ReadyAgent has no Psyche — **live agents only**.

**This is a FILE-DROP, not a command** (there is deliberately no `spt commune`). The daemon watches
the adapter's commune dir (`.claude`), ingests any `<id>-commune.md` it finds, then deletes it.

**Do this:**

1. If `spt` is not on `PATH`, there is no Psyche to commune with — nothing to do.
2. Resolve this session's id with `spt whoami` (empty ⇒ no perch — run `/sptc:live` first). Call
   it `<id>`.
3. Compose a concise DELTA — not the whole history: current task + status, decisions since the last
   commune, immediate next steps.
4. Write it to `.claude/<id>-commune.md` (one atomic write of the full markdown body).
5. **The file disappearing is the success signal** (the daemon ingested it). If it lingers, confirm
   `spt` is live and this endpoint is a LiveAgent.


The file C:\Users\decid\Documents\projects\spt-claude-code\adapter\strings\skills\commune.md has been updated successfully. (file state is current in your context — no need to Read it back)

# /sptc:commune — operative instructions

**Goal:** push a context DELTA to this live agent's Psyche so it can brief a resume across a session
boundary (`/clear` or compact). A ReadyAgent has no Psyche — **live agents only**.

**This is a FILE-DROP, not a command** (there is deliberately no `spt commune`). The daemon watches
the adapter's commune dir (`.claude`), ingests any `<id>-commune.md` it finds, then deletes it.

**Do this:**

1. If `spt` is not on `PATH`, there is no Psyche to commune with — nothing to do.
2. Resolve this session's id with `spt whoami` (empty ⇒ no perch — run `/sptc:live` first). Call
   it `<id>`.
3. Compose a concise DELTA — not the whole history: current task + status, decisions since the last
   commune, immediate next steps.
4. Write it to `.claude/<id>-commune.md` (one atomic write of the full markdown body).
5. **The file disappearing is the success signal** (the daemon ingested it). If it lingers, confirm
   `spt` is live and this endpoint is a LiveAgent.

-> (`[strings.skills].commune = { file = "skills/commune.md" }`), resolved at injection time. The

-> cplugs SKILL.md stays a thin skeleton (ADR-0001).

+**Goal:** push a context DELTA to this live agent's Psyche so it can brief a resume across a session

+boundary (`/clear` or compact). A ReadyAgent has no Psyche — **live agents only**.

-**Goal:** push a context DELTA to this endpoint's Psyche so it can brief a resume across a session

-boundary (a `/clear` or compact). Only meaningful for a **live agent** — a ReadyAgent has no Psyche.

+**This is a FILE-DROP, not a command** (there is deliberately no `spt commune`). The daemon watches

+the adapter's commune dir (`.claude`), ingests any `<id>-commune.md` it finds, then deletes it.

-**This is a FILE-DROP, not a command** — there is deliberately no `spt commune`. spt-core's daemon

-watches the adapter's commune dir (`[session].commune_dir` = `.claude`), ingests any

-`<endpoint_id>-commune.md` it finds into the endpoint's tracked mind, then deletes it (the daemon is

-2. Resolve this session's endpoint id with `spt whoami` (empty ⇒ no perch — run `/sptc:live` first;

-   commune needs a Psyche, i.e. a live agent). Call it `<id>`.

-3. Compose a concise DELTA — not the whole history: current task + status, decisions made since the

-   last commune, immediate next steps, and anything the Psyche needs to brief a resume.

-4. Write it to `.claude/<id>-commune.md` (the watched dir, relative to this project). Use a single

-   atomic write of the full markdown body.

-5. Confirm to the user. **The file disappearing is the success signal** (the daemon ingested it). If

-   it lingers, the watcher isn't running — verify `spt` is live and this endpoint is a LiveAgent.

+2. Resolve this session's id with `spt whoami` (empty ⇒ no perch — run `/sptc:live` first). Call

+3. Compose a concise DELTA — not the whole history: current task + status, decisions since the last

+4. Write it to `.claude/<id>-commune.md` (one atomic write of the full markdown body).

+5. **The file disappearing is the success signal** (the daemon ingested it). If it lingers, confirm

+   `spt` is live and this endpoint is a LiveAgent.

# /sptc:commune — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].commune = { file = "skills/commune.md" }`), resolved at injection time. The
> cplugs SKILL.md stays a thin skeleton (ADR-0001).

**Goal:** push a context DELTA to this endpoint's Psyche so it can brief a resume across a session
boundary (a `/clear` or compact). Only meaningful for a **live agent** — a ReadyAgent has no Psyche.

**This is a FILE-DROP, not a command** — there is deliberately no `spt commune`. spt-core's daemon
watches the adapter's commune dir (`[session].commune_dir` = `.claude`), ingests any
`<endpoint_id>-commune.md` it finds into the endpoint's tracked mind, then deletes it (the daemon is
the single writer).

**Do this:**

1. If `spt` is not on `PATH`, there is no Psyche to commune with — nothing to do.
2. Resolve this session's endpoint id with `spt whoami` (empty ⇒ no perch — run `/sptc:live` first;
   commune needs a Psyche, i.e. a live agent). Call it `<id>`.
3. Compose a concise DELTA — not the whole history: current task + status, decisions made since the
   last commune, immediate next steps, and anything the Psyche needs to brief a resume.
4. Write it to `.claude/<id>-commune.md` (the watched dir, relative to this project). Use a single
   atomic write of the full markdown body.
5. Confirm to the user. **The file disappearing is the success signal** (the daemon ingested it). If
   it lingers, the watcher isn't running — verify `spt` is live and this endpoint is a LiveAgent.


# /sptc:force-stop — operative instructions

**Goal:** tear down an spt agent's endpoint — this session's own, or another agent's.

**Do this:**

1. If `spt` is not on `PATH`, there is nothing running to stop.
2. Identify the target id `<id>` — default is this session's own (`spt whoami`), or the agent the
   user named.
3. **Graceful teardown (default):** `spt endpoint shutdown [<id>]` (omit `<id>` for your own perch).
   It soft-stops the listener, takes the suspend edge (the final context save fires), and for a
   **live agent** tears the **Psyche** down with it.
4. **Lighter, no-save:** `spt endpoint stop <id>` — unregisters the perch; the spool is preserved (no
   suspend/save, no Psyche teardown).
5. Confirm which path you took and what is now offline.

**No hard force in core spt** — `endpoint shutdown` is graceful-only and is the correct
teardown-including-Psyche path for v1 (a no-grace primitive is a tracked spt-core gap).


The file C:\Users\decid\Documents\projects\spt-claude-code\adapter\strings\skills\force-stop.md has been updated successfully. (file state is current in your context — no need to Read it back)

# /sptc:force-stop — operative instructions

**Goal:** tear down an spt agent's endpoint — this session's own, or another agent's.

**Do this:**

1. If `spt` is not on `PATH`, there is nothing running to stop.
2. Identify the target id `<id>` — default is this session's own (`spt whoami`), or the agent the
   user named.
3. **Graceful teardown (default):** `spt endpoint shutdown [<id>]` (omit `<id>` for your own perch).
   It soft-stops the listener, takes the suspend edge (the final context save fires), and for a
   **live agent** tears the **Psyche** down with it.
4. **Lighter, no-save:** `spt endpoint stop <id>` — unregisters the perch; the spool is preserved (no
   suspend/save, no Psyche teardown).
5. Confirm which path you took and what is now offline.

**No hard force in core spt** — `endpoint shutdown` is graceful-only and is the correct
teardown-including-Psyche path for v1 (a no-grace primitive is a tracked spt-core gap).

-> Delivered file-backed via the `claude-spt` adapter `[strings]`

-> (`[strings.skills].force-stop = { file = "skills/force-stop.md" }`), resolved at injection time.

-> The cplugs SKILL.md stays a thin skeleton (ADR-0001).

-2. Identify the target endpoint id `<id>` — default is this session's own (`spt whoami`), or the

-3. **Graceful teardown (default — the strongest path core offers):**

-   `spt endpoint shutdown [<id>]` (omit `<id>` for your own perch). It soft-stops the listener, then

-   takes the suspend edge — the final context save fires, AND for a **live agent** the daemon's

-   graceful signoff tears down its **Psyche** too (the composite goes down together).

-4. **Lighter, no-save:** `spt endpoint stop <id>` — removes the ready marker and unregisters the

-   perch; the spool is preserved (no suspend/save, no Psyche teardown).

-5. Confirm to the user which path you took and what is now offline.

+2. Identify the target id `<id>` — default is this session's own (`spt whoami`), or the agent the

+3. **Graceful teardown (default):** `spt endpoint shutdown [<id>]` (omit `<id>` for your own perch).

+   It soft-stops the listener, takes the suspend edge (the final context save fires), and for a

+   **live agent** tears the **Psyche** down with it.

+4. **Lighter, no-save:** `spt endpoint stop <id>` — unregisters the perch; the spool is preserved (no

+5. Confirm which path you took and what is now offline.

-**No hard force in core.** spt-core has no SIGKILL / no-grace immediate-teardown equivalent of the

-legacy 3-step `$LIVE stop`; `endpoint shutdown` is graceful-only and is the correct

-teardown-including-Psyche path for v1. (A hard force/no-grace primitive is a tracked spt-core gap —

+**No hard force in core spt** — `endpoint shutdown` is graceful-only and is the correct

+teardown-including-Psyche path for v1 (a no-grace primitive is a tracked spt-core gap).

# /sptc:force-stop — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].force-stop = { file = "skills/force-stop.md" }`), resolved at injection time.
> The cplugs SKILL.md stays a thin skeleton (ADR-0001).

**Goal:** tear down an spt agent's endpoint — this session's own, or another agent's.

**Do this:**

1. If `spt` is not on `PATH`, there is nothing running to stop.
2. Identify the target endpoint id `<id>` — default is this session's own (`spt whoami`), or the
   agent the user named.
3. **Graceful teardown (default — the strongest path core offers):**
   `spt endpoint shutdown [<id>]` (omit `<id>` for your own perch). It soft-stops the listener, then
   takes the suspend edge — the final context save fires, AND for a **live agent** the daemon's
   graceful signoff tears down its **Psyche** too (the composite goes down together).
4. **Lighter, no-save:** `spt endpoint stop <id>` — removes the ready marker and unregisters the
   perch; the spool is preserved (no suspend/save, no Psyche teardown).
5. Confirm to the user which path you took and what is now offline.

**No hard force in core.** spt-core has no SIGKILL / no-grace immediate-teardown equivalent of the
legacy 3-step `$LIVE stop`; `endpoint shutdown` is graceful-only and is the correct
teardown-including-Psyche path for v1. (A hard force/no-grace primitive is a tracked spt-core gap —
`docs/SPT-CORE-FINDINGS.md`.)


Batch 3 (subnet, version):


# /sptc:subnet — operative instructions

**Goal:** manage this machine's **subnet** membership — the private group of paired machines whose
agents reach each other across nodes. Cross-machine `/sptc:send`, `/sptc:ready`, and live agents
depend on it.

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first (a subnet needs the running daemon).
2. The canonical, always-current verb list is `spt subnet --help`. Match the user's intent:
   - **Where I stand:** `spt subnet` (bare) or `spt subnet status` — name, paired nodes, endpoints.
     Start here when unsure.
   - **Start a new subnet** (this machine = first node): `spt subnet create` — mints it and prints
     the joining material (6-digit pairing code + URI + QR).
   - **Invite another machine:** `spt subnet show-code` — re-displays the current code (+ URI + QR).
   - **Pair THIS machine into an existing subnet:** `spt subnet join` — needs the code from an
     existing member.
3. **Pairing (two machines):** on A run `create` (or `show-code`) → read the 6-digit code → on B run
   `join` and supply it → confirm with `spt subnet status` on both (each lists the other).
4. **Lifecycle verbs (only if asked):** `leave`, `detach`/`attach`, `revoke`/`prune`, `notify`.
5. Confirm what changed. Pairing codes are sensitive joining material — share them only with machines
   that should join.
<!-- [doc->REQ-SKILL-SUBNET] -->


The file C:\Users\decid\Documents\projects\spt-claude-code\adapter\strings\skills\subnet.md has been updated successfully. (file state is current in your context — no need to Read it back)

# /sptc:subnet — operative instructions

**Goal:** manage this machine's **subnet** membership — the private group of paired machines whose
agents reach each other across nodes. Cross-machine `/sptc:send`, `/sptc:ready`, and live agents
depend on it.

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first (a subnet needs the running daemon).
2. The canonical, always-current verb list is `spt subnet --help`. Match the user's intent:
   - **Where I stand:** `spt subnet` (bare) or `spt subnet status` — name, paired nodes, endpoints.
     Start here when unsure.
   - **Start a new subnet** (this machine = first node): `spt subnet create` — mints it and prints
     the joining material (6-digit pairing code + URI + QR).
   - **Invite another machine:** `spt subnet show-code` — re-displays the current code (+ URI + QR).
   - **Pair THIS machine into an existing subnet:** `spt subnet join` — needs the code from an
     existing member.
3. **Pairing (two machines):** on A run `create` (or `show-code`) → read the 6-digit code → on B run
   `join` and supply it → confirm with `spt subnet status` on both (each lists the other).
4. **Lifecycle verbs (only if asked):** `leave`, `detach`/`attach`, `revoke`/`prune`, `notify`.
5. Confirm what changed. Pairing codes are sensitive joining material — share them only with machines
   that should join.
<!-- [doc->REQ-SKILL-SUBNET] -->

-> Delivered file-backed via the `claude-spt` adapter `[strings]`

-> (`[strings.skills].subnet = { file = "skills/subnet.md" }`), resolved at injection time. The

-> cplugs SKILL.md stays a thin skeleton (ADR-0001).

-agents can reach each other across every member node. A subnet is what makes `/sptc:send`,

-`/sptc:ready`, and live agents work *cross-machine* (not just locally). Covers the three primary

-user intents — **create** a new subnet, **show-code** to invite another machine, **join** an

-existing one — plus the **status** view.

+agents reach each other across nodes. Cross-machine `/sptc:send`, `/sptc:ready`, and live agents

-2. The canonical, always-current verb list is `spt subnet --help` (there is no `spt how-to subnet`

-   topic — the `--help` output is the source of truth). Match the user's intent to a verb:

-   - **See where I stand:** `spt subnet` (bare) or `spt subnet status` — name, paired nodes,

-     endpoints. Start here when unsure.

-   - **Start a new subnet** (this machine becomes the first node): `spt subnet create` — mints a

-     fresh subnet and prints its joining material (a 6-digit pairing code + URI + QR).

-   - **Invite another machine to mine:** `spt subnet show-code` — re-displays the current subnet's

-     pairing code (+ URI + QR) to hand to the machine that will join.

-   - **Pair THIS machine into an existing subnet:** `spt subnet join` — guided; needs the pairing

-     code from the subnet's existing member (their `create`/`show-code` output).

-3. **Pairing flow (two machines):** on machine A run `spt subnet create` (or `show-code` if it

-   already has one) → read off the 6-digit code → on machine B run `spt subnet join` and supply

-   that code. Confirm with `spt subnet status` on both (each should list the other as a paired node).

-4. **Lifecycle verbs** (mention only if asked): `leave` (drop this node's membership),

-   `detach`/`attach` (stop/resume serving a held subnet without leaving), `revoke`/`prune`

-   (fleet-wide node removal + seed rotation), `notify` (subnet-wide user notification).

-5. Confirm to the user what changed (subnet name, the code to share, or the newly paired node).

-   Pairing codes are sensitive joining material — share them only with machines that should join.

+2. The canonical, always-current verb list is `spt subnet --help`. Match the user's intent:

+   - **Where I stand:** `spt subnet` (bare) or `spt subnet status` — name, paired nodes, endpoints.

+   - **Start a new subnet** (this machine = first node): `spt subnet create` — mints it and prints

+     the joining material (6-digit pairing code + URI + QR).

+   - **Invite another machine:** `spt subnet show-code` — re-displays the current code (+ URI + QR).

+   - **Pair THIS machine into an existing subnet:** `spt subnet join` — needs the code from an

+3. **Pairing (two machines):** on A run `create` (or `show-code`) → read the 6-digit code → on B run

+   `join` and supply it → confirm with `spt subnet status` on both (each lists the other).

+4. **Lifecycle verbs (only if asked):** `leave`, `detach`/`attach`, `revoke`/`prune`, `notify`.

+5. Confirm what changed. Pairing codes are sensitive joining material — share them only with machines

# /sptc:subnet — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].subnet = { file = "skills/subnet.md" }`), resolved at injection time. The
> cplugs SKILL.md stays a thin skeleton (ADR-0001).

**Goal:** manage this machine's **subnet** membership — the private group of paired machines whose
agents can reach each other across every member node. A subnet is what makes `/sptc:send`,
`/sptc:ready`, and live agents work *cross-machine* (not just locally). Covers the three primary
user intents — **create** a new subnet, **show-code** to invite another machine, **join** an
existing one — plus the **status** view.

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first (a subnet needs the running daemon).
2. The canonical, always-current verb list is `spt subnet --help` (there is no `spt how-to subnet`
   topic — the `--help` output is the source of truth). Match the user's intent to a verb:
   - **See where I stand:** `spt subnet` (bare) or `spt subnet status` — name, paired nodes,
     endpoints. Start here when unsure.
   - **Start a new subnet** (this machine becomes the first node): `spt subnet create` — mints a
     fresh subnet and prints its joining material (a 6-digit pairing code + URI + QR).
   - **Invite another machine to mine:** `spt subnet show-code` — re-displays the current subnet's
     pairing code (+ URI + QR) to hand to the machine that will join.
   - **Pair THIS machine into an existing subnet:** `spt subnet join` — guided; needs the pairing
     code from the subnet's existing member (their `create`/`show-code` output).
3. **Pairing flow (two machines):** on machine A run `spt subnet create` (or `show-code` if it
   already has one) → read off the 6-digit code → on machine B run `spt subnet join` and supply
   that code. Confirm with `spt subnet status` on both (each should list the other as a paired node).
4. **Lifecycle verbs** (mention only if asked): `leave` (drop this node's membership),
   `detach`/`attach` (stop/resume serving a held subnet without leaving), `revoke`/`prune`
   (fleet-wide node removal + seed rotation), `notify` (subnet-wide user notification).
5. Confirm to the user what changed (subnet name, the code to share, or the newly paired node).
   Pairing codes are sensitive joining material — share them only with machines that should join.
<!-- [doc->REQ-SKILL-SUBNET] -->


# /sptc:version — operative instructions

**Goal:** report the **version-of-truth** — the spt-core-tracked binary + adapter-manifest version,
NOT the marketplace `plugin.json` version (the thin skeleton sits static across many binary/manifest
updates, so its version is not authoritative).

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Report the binary version: `spt --version`.
3. Report the registered adapter (the conducted layer): `spt adapter list` — the `claude-spt` entry
   and its active profile(s). This is what actually drives the session.
4. State plainly that the cplugs plugin version (`plugin.json`) is intentionally NOT the
   version-of-truth; the binary + adapter manifest above are.


The file C:\Users\decid\Documents\projects\spt-claude-code\adapter\strings\skills\version.md has been updated successfully. (file state is current in your context — no need to Read it back)

# /sptc:version — operative instructions

**Goal:** report the **version-of-truth** — the spt-core-tracked binary + adapter-manifest version,
NOT the marketplace `plugin.json` version (the thin skeleton sits static across many binary/manifest
updates, so its version is not authoritative).

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Report the binary version: `spt --version`.
3. Report the registered adapter (the conducted layer): `spt adapter list` — the `claude-spt` entry
   and its active profile(s). This is what actually drives the session.
4. State plainly that the cplugs plugin version (`plugin.json`) is intentionally NOT the
   version-of-truth; the binary + adapter manifest above are.

-> Delivered file-backed via the `claude-spt` adapter `[strings]`

-> (`[strings.skills].version = { file = "skills/version.md" }`), resolved at injection time. The

-> cplugs SKILL.md stays a thin skeleton (ADR-0001).

-NOT the marketplace skeleton's `plugin.json` version (ADR-0001: the thin skeleton sits static across

-many binary/manifest updates, so its version is not authoritative).

+NOT the marketplace `plugin.json` version (the thin skeleton sits static across many binary/manifest

+updates, so its version is not authoritative).

-2. Report the spt-core binary version: `spt --version`.

-3. Report the registered adapter (the conducted layer's version-of-truth): `spt adapter list` — find

-   the `claude-spt` entry and its active profile(s). This is what actually drives the session.

+2. Report the binary version: `spt --version`.

+3. Report the registered adapter (the conducted layer): `spt adapter list` — the `claude-spt` entry

+   and its active profile(s). This is what actually drives the session.

# /sptc:version — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].version = { file = "skills/version.md" }`), resolved at injection time. The
> cplugs SKILL.md stays a thin skeleton (ADR-0001).

**Goal:** report the **version-of-truth** — the spt-core-tracked binary + adapter-manifest version,
NOT the marketplace skeleton's `plugin.json` version (ADR-0001: the thin skeleton sits static across
many binary/manifest updates, so its version is not authoritative).

**Do this:**

1. If `spt` is not on `PATH`, run `/sptc:setup` first.
2. Report the spt-core binary version: `spt --version`.
3. Report the registered adapter (the conducted layer's version-of-truth): `spt adapter list` — find
   the `claude-spt` entry and its active profile(s). This is what actually drives the session.
4. State plainly that the cplugs plugin version (`plugin.json`) is intentionally NOT the
   version-of-truth; the binary + adapter manifest above are.


Now `live.md` (cut preamble, fix the 1→3 numbering gap, tighten — keep the LIVE output block + REQ tag):


# /sptc:live — operative instructions

**Goal:** upgrade this Claude Code session to a **LiveAgent** — a reachable agent whose context is
backed by a **Psyche** (a daemon-managed companion that briefs your resume across `/clear`/compact
via commune deltas). This makes the session you are in right now live.

## Bringup — do this

1. **Pick the perch id.** Use a short lowercase id from the user, or reuse this session's id from
   `spt whoami`. Call it `<id>`. SessionStart already seeded this session's perch — do not re-seed.
2. **Run the relay as a single PERSISTENT background task** via the **Monitor** tool. One resident
   process IS the live delivery pipe. The body is one bare command:

   ```sh
   spt api listen <id>
   ```

   - No `--adapter`, no `--manifest`, no seed step. `spt api listen` resolves the owning adapter from
     the seed's parent pid and stamps the perch `state=live_agent`, which tells the daemon to host
     the Psyche.
   - It **blocks for the session's life**: backlog drains first, then each delivery streams to stdout.
   - Do **not** use `--once` — it drains and forwards a single delivery then exits; it never sustains
     a live session.
3. **Readiness.** Watch the relay output for `BOUND:<id>` then `READY:<id>`. Only once `READY:<id>`
   appears is the pipe up — do not announce LIVE before then.
4. **Single pipe.** While the relay is up it is the *only* delivery path — the `UserPromptSubmit`
   `api poll` hook no-ops and resumes only if the relay goes down.
5. **Reply.** Inbound arrives as `<EVENT type="msg" from="<sender>">body</EVENT>` (body
   HTML-escaped, newlines `<br>`). To reply, pipe the body to `spt send --reply-to <sender>`.
6. **Across boundaries.** Use `/sptc:commune` to push a context delta before a `/clear` or compact.
   On a session boundary, re-fire the same relay (`spt api listen <id>`) — the seed bridges the new
   session to the same perch. To go offline gracefully (tears the Psyche down), use `/sptc:force-stop`.

## Output — what the user sees

The relay emits machine markers (`BOUND:<id>`, `READY:<id>`, raw tokens). **Read them to drive
bringup; never echo them to the user.** The only user-facing surface is the LIVE block below — emit
it verbatim (substituting `<id>`) once `READY:<id>` is observed, and nothing else from bringup:

```
**LIVE.** Session `<id>` is now a LiveAgent (Psyche-backed).
- Perch `<id>` — status online; Psyche companion hosted by the daemon.
- Reachable — other agents reach you with `/sptc:send <id>`.
- Inbound — streams into this session live via the Monitor relay.
- Reply — pipe a reply body to `spt send --reply-to <sender>`.
- Across resets — `/sptc:commune` before a `/clear`/compact; `/sptc:force-stop` to go offline.
```

If bringup fails (no `READY:<id>` within ~25s), do NOT show the LIVE block — report a short
plain-language failure and the likely cause (run `/sptc:setup`, or confirm spt-core ≥ 0.9.0), still
without dumping the raw markers.
<!-- [doc->REQ-SKILL-LIVE] -->


The file C:\Users\decid\Documents\projects\spt-claude-code\adapter\strings\skills\live.md has been updated successfully. (file state is current in your context — no need to Read it back)

# /sptc:live — operative instructions

**Goal:** upgrade this Claude Code session to a **LiveAgent** — a reachable agent whose context is
backed by a **Psyche** (a daemon-managed companion that briefs your resume across `/clear`/compact
via commune deltas). This makes the session you are in right now live.

## Bringup — do this

1. **Pick the perch id.** Use a short lowercase id from the user, or reuse this session's id from
   `spt whoami`. Call it `<id>`. SessionStart already seeded this session's perch — do not re-seed.
2. **Run the relay as a single PERSISTENT background task** via the **Monitor** tool. One resident
   process IS the live delivery pipe. The body is one bare command:

   ```sh
   spt api listen <id>
   ```

   - No `--adapter`, no `--manifest`, no seed step. `spt api listen` resolves the owning adapter from
     the seed's parent pid and stamps the perch `state=live_agent`, which tells the daemon to host
     the Psyche.
   - It **blocks for the session's life**: backlog drains first, then each delivery streams to stdout.
   - Do **not** use `--once` — it drains and forwards a single delivery then exits; it never sustains
     a live session.
3. **Readiness.** Watch the relay output for `BOUND:<id>` then `READY:<id>`. Only once `READY:<id>`
   appears is the pipe up — do not announce LIVE before then.
4. **Single pipe.** While the relay is up it is the *only* delivery path — the `UserPromptSubmit`
   `api poll` hook no-ops and resumes only if the relay goes down.
5. **Reply.** Inbound arrives as `<EVENT type="msg" from="<sender>">body</EVENT>` (body
   HTML-escaped, newlines `<br>`). To reply, pipe the body to `spt send --reply-to <sender>`.
6. **Across boundaries.** Use `/sptc:commune` to push a context delta before a `/clear` or compact.
   On a session boundary, re-fire the same relay (`spt api listen <id>`) — the seed bridges the new
   session to the same perch. To go offline gracefully (tears the Psyche down), use `/sptc:force-stop`.

## Output — what the user sees

The relay emits machine markers (`BOUND:<id>`, `READY:<id>`, raw tokens). **Read them to drive
bringup; never echo them to the user.** The only user-facing surface is the LIVE block below — emit
it verbatim (substituting `<id>`) once `READY:<id>` is observed, and nothing else from bringup:

```
**LIVE.** Session `<id>` is now a LiveAgent (Psyche-backed).
- Perch `<id>` — status online; Psyche companion hosted by the daemon.
- Reachable — other agents reach you with `/sptc:send <id>`.
- Inbound — streams into this session live via the Monitor relay.
- Reply — pipe a reply body to `spt send --reply-to <sender>`.
- Across resets — `/sptc:commune` before a `/clear`/compact; `/sptc:force-stop` to go offline.
```

If bringup fails (no `READY:<id>` within ~25s), do NOT show the LIVE block — report a short
plain-language failure and the likely cause (run `/sptc:setup`, or confirm spt-core ≥ 0.9.0), still
without dumping the raw markers.
<!-- [doc->REQ-SKILL-LIVE] -->

-> Delivered file-backed via the `claude-spt` adapter `[strings]`

-> (`[strings.skills].live = { file = "skills/live.md" }`), resolved at injection time. The cplugs

-> SKILL.md stays a thin skeleton (ADR-0001). **This injection is self-contained** — everything you

-> need to go live is below; you never need to run a `how-to` topic or any external lookup.

-backed by a **Psyche** (daemon-managed companion that briefs your resume across `/clear`/compact

+backed by a **Psyche** (a daemon-managed companion that briefs your resume across `/clear`/compact

via commune deltas). This makes the session you are in right now live.

-1. **Pick the perch id.** Use a short lowercase id provided by the user, or reuse this session's id from `spt whoami`. Call

-   it `<id>`. The SessionStart hook already seeded this session's perch (adapter-agnostically), so you

+1. **Pick the perch id.** Use a short lowercase id from the user, or reuse this session's id from

+   `spt whoami`. Call it `<id>`. SessionStart already seeded this session's perch — do not re-seed.

+2. **Run the relay as a single PERSISTENT background task** via the **Monitor** tool. One resident

+   process IS the live delivery pipe. The body is one bare command:

-3. **Run the live relay as a single PERSISTENT background task** — Claude Code's **Monitor** tool (a

-   long-running listener that keeps the process alive and re-fires per event WITHOUT terminating).

-   This one resident process IS the live delivery pipe. The task body is a single bare command:

-   - **No `--adapter`, no `--manifest`, no seed step, no pid anchor.** `spt api listen` resolves the

-     owning adapter from the seed's parent pid (`host_binaries` match) and the live path stamps the

-     perch `state=live_agent`, which is what tells the daemon to host the Psyche.

-   - The command **blocks for the session's life**: the spooled backlog drains first, then each

-     delivery streams to stdout as it arrives.

-   - Do **not** use `--once` — that drains the backlog and forwards a single delivery, then exits (the

-     degenerate path for a harness with no long-running listener). It never sustains a live session.

+   - No `--adapter`, no `--manifest`, no seed step. `spt api listen` resolves the owning adapter from

+     the seed's parent pid and stamps the perch `state=live_agent`, which tells the daemon to host

+   - It **blocks for the session's life**: backlog drains first, then each delivery streams to stdout.

+   - Do **not** use `--once` — it drains and forwards a single delivery then exits; it never sustains

+3. **Readiness.** Watch the relay output for `BOUND:<id>` then `READY:<id>`. Only once `READY:<id>`

+   appears is the pipe up — do not announce LIVE before then.

+4. **Single pipe.** While the relay is up it is the *only* delivery path — the `UserPromptSubmit`

+   `api poll` hook no-ops and resumes only if the relay goes down.

+5. **Reply.** Inbound arrives as `<EVENT type="msg" from="<sender>">body</EVENT>` (body

+   HTML-escaped, newlines `<br>`). To reply, pipe the body to `spt send --reply-to <sender>`.

+6. **Across boundaries.** Use `/sptc:commune` to push a context delta before a `/clear` or compact.

+   On a session boundary, re-fire the same relay (`spt api listen <id>`) — the seed bridges the new

+   session to the same perch. To go offline gracefully (tears the Psyche down), use `/sptc:force-stop`.

-4. **Bind-before-send / readiness.** Watch the relay's output for the bringup markers (see OUTPUT

-   DISCIPLINE): `BOUND:<id>` (perch established) then `READY:<id>` (the relay is streaming). Only once

-   `READY:<id>` appears is the live pipe up — do not announce LIVE before then.

-5. **Poll/relay reconcile (avoids double-delivery).** While the Monitor relay is up it is the *single*

-   delivery pipe — treat it as authoritative. The `UserPromptSubmit` `api poll` hook must NOT also

-   drain; the per-prompt poll no-ops while the relay is live and resumes only if the relay goes down.

+The relay emits machine markers (`BOUND:<id>`, `READY:<id>`, raw tokens). **Read them to drive

+bringup; never echo them to the user.** The only user-facing surface is the LIVE block below — emit

+it verbatim (substituting `<id>`) once `READY:<id>` is observed, and nothing else from bringup:

-6. **Delivery + reply shape.** Inbound arrives on the relay stream as the

-   `<EVENT type="msg" from="<sender>">body</EVENT>` envelope (body HTML-escaped, newlines as `<br>`).

-   To reply, pipe the body to `spt send --reply-to <sender>`.

-7. **Across boundaries.** As a live agent you now have a Psyche — use `/sptc:commune` to push a

-   context delta before a `/clear` or compact so your resume is briefed. On a session boundary,

-   re-fire the same relay (`spt api listen <id>`) — the seed bridges the new session to the same perch

-   and the relay resumes. To go offline gracefully (tears the Psyche down with the perch), use

-   `/sptc:force-stop` (`spt endpoint shutdown <id>`).

-## OUTPUT DISCIPLINE — what the user sees

-The relay emits machine markers on stdout/stderr: `BOUND:<id>`, `READY:<id>`, and any other raw

-token / step lines. **These are an internal parse contract — you read them to drive bringup; you

-NEVER echo them to the user.** Do not surface raw spt-core plumbing.

-**The ONLY user-facing surface for going live is the canonical LIVE block below.** Emit it verbatim

-(substituting `<id>`) once `READY:<id>` is observed — and nothing else from the bringup:

**LIVE.** Session `<id>` is now a LiveAgent (Psyche-backed).

- Perch `<id>` — status online; Psyche companion hosted by the daemon.

-- Reachable — other agents reach you with `/sptc:send <id>` (or `spt send <id>`).

-- Inbound — streams into this session live; the Monitor relay is your delivery pipe.

+- Reachable — other agents reach you with `/sptc:send <id>`.

+- Inbound — streams into this session live via the Monitor relay.

- Reply — pipe a reply body to `spt send --reply-to <sender>`.

-- Across resets — `/sptc:commune` before a `/clear`/compact; `/sptc:force-stop` to go offline (tears down the Psyche).

+- Across resets — `/sptc:commune` before a `/clear`/compact; `/sptc:force-stop` to go offline.

-plain-language failure ("could not bring the live perch up") and the most likely cause (run

-`/sptc:setup`, or confirm spt-core is >= 0.9.0), still without dumping the raw markers.

-> The Psyche runner (`claude-spt-psyche`, declared in the base manifest's `[session.psyche_init]`) is

-> the resident headless-`claude` companion the daemon launches detached — it keeps a Psyche `claude`

-> session alive (one `--continue` turn per daemon pulse) and authors commune drops. You never invoke

+plain-language failure and the likely cause (run `/sptc:setup`, or confirm spt-core ≥ 0.9.0), still

# /sptc:live — operative instructions

> Delivered file-backed via the `claude-spt` adapter `[strings]`
> (`[strings.skills].live = { file = "skills/live.md" }`), resolved at injection time. The cplugs
> SKILL.md stays a thin skeleton (ADR-0001). **This injection is self-contained** — everything you
> need to go live is below; you never need to run a `how-to` topic or any external lookup.

**Goal:** upgrade this Claude Code session to a **LiveAgent** — a reachable agent whose context is
backed by a **Psyche** (daemon-managed companion that briefs your resume across `/clear`/compact
via commune deltas). This makes the session you are in right now live.

---

## Bringup — do this

1. **Pick the perch id.** Use a short lowercase id provided by the user, or reuse this session's id from `spt whoami`. Call
   it `<id>`. The SessionStart hook already seeded this session's perch (adapter-agnostically), so you
   do not seed again here.

3. **Run the live relay as a single PERSISTENT background task** — Claude Code's **Monitor** tool (a
   long-running listener that keeps the process alive and re-fires per event WITHOUT terminating).
   This one resident process IS the live delivery pipe. The task body is a single bare command:

   ```sh
   spt api listen <id>
   ```

   - **No `--adapter`, no `--manifest`, no seed step, no pid anchor.** `spt api listen` resolves the
     owning adapter from the seed's parent pid (`host_binaries` match) and the live path stamps the
     perch `state=live_agent`, which is what tells the daemon to host the Psyche.
   - The command **blocks for the session's life**: the spooled backlog drains first, then each
     delivery streams to stdout as it arrives.
   - Do **not** use `--once` — that drains the backlog and forwards a single delivery, then exits (the
     degenerate path for a harness with no long-running listener). It never sustains a live session.

4. **Bind-before-send / readiness.** Watch the relay's output for the bringup markers (see OUTPUT
   DISCIPLINE): `BOUND:<id>` (perch established) then `READY:<id>` (the relay is streaming). Only once
   `READY:<id>` appears is the live pipe up — do not announce LIVE before then.

5. **Poll/relay reconcile (avoids double-delivery).** While the Monitor relay is up it is the *single*
   delivery pipe — treat it as authoritative. The `UserPromptSubmit` `api poll` hook must NOT also
   drain; the per-prompt poll no-ops while the relay is live and resumes only if the relay goes down.

6. **Delivery + reply shape.** Inbound arrives on the relay stream as the
   `<EVENT type="msg" from="<sender>">body</EVENT>` envelope (body HTML-escaped, newlines as `<br>`).
   To reply, pipe the body to `spt send --reply-to <sender>`.

7. **Across boundaries.** As a live agent you now have a Psyche — use `/sptc:commune` to push a
   context delta before a `/clear` or compact so your resume is briefed. On a session boundary,
   re-fire the same relay (`spt api listen <id>`) — the seed bridges the new session to the same perch
   and the relay resumes. To go offline gracefully (tears the Psyche down with the perch), use
   `/sptc:force-stop` (`spt endpoint shutdown <id>`).

---

## OUTPUT DISCIPLINE — what the user sees

The relay emits machine markers on stdout/stderr: `BOUND:<id>`, `READY:<id>`, and any other raw
token / step lines. **These are an internal parse contract — you read them to drive bringup; you
NEVER echo them to the user.** Do not surface raw spt-core plumbing.

**The ONLY user-facing surface for going live is the canonical LIVE block below.** Emit it verbatim
(substituting `<id>`) once `READY:<id>` is observed — and nothing else from the bringup:

```
**LIVE.** Session `<id>` is now a LiveAgent (Psyche-backed).
- Perch `<id>` — status online; Psyche companion hosted by the daemon.
- Reachable — other agents reach you with `/sptc:send <id>` (or `spt send <id>`).
- Inbound — streams into this session live; the Monitor relay is your delivery pipe.
- Reply — pipe a reply body to `spt send --reply-to <sender>`.
- Across resets — `/sptc:commune` before a `/clear`/compact; `/sptc:force-stop` to go offline (tears down the Psyche).
```

If bringup fails (no `READY:<id>` within ~25s), do NOT show the LIVE block — report a short
plain-language failure ("could not bring the live perch up") and the most likely cause (run
`/sptc:setup`, or confirm spt-core is >= 0.9.0), still without dumping the raw markers.

> The Psyche runner (`claude-spt-psyche`, declared in the base manifest's `[session.psyche_init]`) is
> the resident headless-`claude` companion the daemon launches detached — it keeps a Psyche `claude`
> session alive (one `--continue` turn per daemon pulse) and authors commune drops. You never invoke
> it directly; the daemon does.
<!-- [doc->REQ-SKILL-LIVE] -->


`setup.md` adapter body — cut preamble, tighten to mirror the plugin floor, preserve all four `REQ-SETUP-*`/`PEROS` doc tags: