opencode-thrum-pro 0.1.6 → 0.1.7

package/assets/skills/researcher-investigating/SKILL.md

@@ -74,8 +74,8 @@ sessions and re-readable by other agents.
 
 **How to apply:** After reporting to the requester, write the finding as a
 `research_note` memory with cited file:line refs and a verification footer. Tag
-with a `research-<slug>` handle so other agents can find it later via
-`thrum memory search --tag research-<slug>`:
+it with `--tag <slug>` so other agents can find it later via
+`thrum memory search --tag <slug>`:
 
 ```bash
 cat > /tmp/research-note-body.md <<EOF
@@ -85,19 +85,18 @@ Verified: $(date +%Y-%m-%d) @ $(git rev-parse HEAD)
 EOF
 thrum memory create --kind research_note --scope role \
   --title "<finding prose, ~80 char soft limit>" \
-  --tag research-<slug> \
+  --tag <slug> \
   --oneline "<one-line summary>" \
   --full "@/tmp/research-note-body.md"
 ```
 
 `--full` here is multi-line prose — compose via heredoc or a captured
-variable, never double-quoted inline like this; see your role preamble's 🔴
-PROSE INTO A COMMAND rule.
+variable, never double-quoted inline like this; see the heredoc-or-file rule in your role preamble.
 
 Then add one line to `.thrum/context/research.md` under Tracked Topics (note: `thrum queue` now supersedes free-text Open Questions tracking):
 
 ```markdown
-- `research-<slug>` — <one-line description, ≤ 80 chars>
+- `<slug>` — <one-line description, ≤ 80 chars>
 ```
 
 The full index format and staleness-check protocol live in
@@ -121,8 +120,7 @@ gaps — you surface them, the implementer ships them.
 
 ## Project-specific rules (already loaded)
 
-Read the shared partial at the absolute path:
-`claude-plugin/commands/_project-rules-protocol.md`
+Load the /thrum:project-rules-protocol skill and follow it.
 
 If you accumulate a new rule mid-session (the user corrects you), capture it via
 the `researcher-maintaining-memory` skill — it references the

package/assets/skills/researcher-maintaining-memory/SKILL.md

@@ -158,7 +158,7 @@ thrum memory create --kind agent_rule --scope role \
 ```
 
 `--short`/`--full` carry real prose — compose via heredoc or file, never
-double-quoted inline; see your role preamble's 🔴 PROSE INTO A COMMAND rule.
+double-quoted inline; see the heredoc-or-file rule in your role preamble.
 
 This is the SAME pattern as coordinator/implementer role-rule writes — see
 `memory-write-discipline` for the canonical shape.

package/assets/{commands/thrum-_snapshot-protocol.md → skills/snapshot-protocol/SKILL.md}

@@ -1,20 +1,15 @@
 ---
-description:
-  Shared snapshot-composition protocol consumed by the snapshot-save commands.
-  Not user-invocable directly.
+name: snapshot-protocol
+description: "Use when composing a restart snapshot or continuation - snapshot structure, worktree resolution, write rules."
 ---
 
-# Snapshot Composition Protocol (shared partial)
 
-Consumers: run `grep -rl _snapshot-protocol claude-plugin/commands/` for the
-current set — do NOT hardcode it here. A list of consumers inside the consumed
-file is a second copy of a git-answerable fact and rots the moment a command is
-added or dropped. Note: plain `/thrum:restart` does NOT consume this partial; it
-carries its own inline snapshot template.
+# Snapshot Composition Protocol
+Note: plain `/thrum:restart` carries its own inline snapshot template rather
+than consuming this skill.
 
-This is the canonical source-of-truth for snapshot composition discipline. The
-sibling commands that consume this partial compose: read this partial →
-variant-specific terminal action. Do NOT invoke this file directly; it has no
+This is the canonical source-of-truth for snapshot composition discipline.
+Invoke this skill to compose a snapshot, then take the variant-specific
 terminal action.
 
 ## Step 1 — Resolve identity and your worktree
@@ -71,14 +66,14 @@ shapes everything else you write below it.
 
 **Stamp your snapshot with the base it was authored against.**
 Derive and emit the **Authored-against** stamp per
-`claude-plugin/commands/_stamp-protocol.md` and place it at the very top of your
+the /thrum:stamp-protocol skill and place it at the very top of your
 §1 section (that protocol computes the SHA and merge_target for you — never
 hand-type them). This is what lets `thrum prime` diff your snapshot at the next
 wake and flag which cited files have MOVED; an unstamped snapshot reads as
 "current", indistinguishable from one that never drifted.
 
 Any commit your snapshot names as its own stamped SHA must also be readable
-under `_stamp-protocol.md`'s "Read-time provenance re-derivation" section
+under `stamp-protocol.md`'s "Read-time provenance re-derivation" section
 (SHA-resolves, then merge-status) — link to that section rather than restating
 its checks here.
 
@@ -114,7 +109,7 @@ session's conversation context. Refer to the previous session in third person.
 
 ### Choose your structure
 
-The variant skill that invoked this partial tells you which structure to use:
+The variant skill that invoked this skill tells you which structure to use:
 
 - **`/thrum:sleep`** → use the STANDARD 11-section structure below.
 - **`/thrum:restart-extended` and `/thrum:sleep-extended`** → use the EXTENDED

package/assets/{commands/thrum-_stamp-protocol.md → skills/stamp-protocol/SKILL.md}

@@ -1,15 +1,14 @@
 ---
-description:
-  Shared Authored-against stamp protocol — canonical format, derivation
-  commands, and never-type rule. Not user-invocable directly.
+name: stamp-protocol
+description: "Use when stamping a plan, prompt, or snapshot - Authored-against format, derivation commands, never-type rule."
 ---
 
-# Authored-against Stamp Protocol (shared partial)
 
+# Authored-Against Stamp Protocol
 This is the canonical source-of-truth for the Authored-against stamp: its format,
 derivation commands, and the never-type rule. Consuming files point here instead of
-restating the recipe. Do NOT invoke this file directly; it has no terminal action.
-(To find what currently points here: `grep -rn "_stamp-protocol.md" claude-plugin/`
+restating the recipe. Do not run this as a command; it has no terminal action — other skills and commands load it by name.
+(To find what currently points here: `grep -rn "thrum:stamp-protocol" claude-plugin/commands/ claude-plugin/skills/`
 — a hand-listed consumer roster in this file would rot the moment a new emitter or
 reader is added, so none is kept here.)
 

package/assets/skills/using-thrum-state/SKILL.md

@@ -42,8 +42,8 @@ time** — writing a fleet row without a fresh by-effect check, even to
 ## Reconcile, don't just read
 
 - **Agent-local** (all roles): check at session start
-  (`thrum state list`), update as you go. Carried-over state is NOT
-  auto-injected into prime — you must ask.
+  (`thrum state list`), update as you go. Prime injects only a capped digest
+  of agent-local state; `thrum state list` shows all.
 - **Fleet** (coordinators write; everyone reads): before citing a fleet
   fact in a decision, check `as_of`/`method`. Past the kind's threshold
   (`thrum state describe <kind>`)? Re-verify by effect before acting, or

package/assets/skills/verify-against-plan/SKILL.md

@@ -104,7 +104,7 @@ clear error — do not proceed with partial inputs.
    Regex: `^\*\*Authored-against:\*\* \`([0-9a-f]+)\` target: \`([^\`]+)\``
    (sha → capture group 1, merge_target → capture group 2)
 
-   (Canonical stamp definition: `claude-plugin/commands/_stamp-protocol.md`. The
+   (Canonical stamp definition: the /thrum:stamp-protocol skill. The
    stamp follows the same literal `grep -F` / fixed-field-order / case-sensitive /
    ASCII-only convention as the `THRUM-REVIEW` marker — see
    `coordinator-running-brainstorm-cycles` skill § "Footer → commit → stamp".)
@@ -158,7 +158,7 @@ clear error — do not proceed with partial inputs.
    present" outcome above, since this check only needs the stamp's
    `<sha>`/`<merge_target>`, not the plan's cited-files list. Run the
    ordered, short-circuiting two-check sequence defined canonically in
-   `_stamp-protocol.md` § "Read-time provenance re-derivation" (SHA-resolves
+   `stamp-protocol.md` § "Read-time provenance re-derivation" (SHA-resolves
    first, then merge-status) against the stamp's `<sha>`/`<merge_target>` —
    the exact commands live there as the single source of truth; this section
    states outcomes and severity only:

package/dist/installer-assets.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/installer-assets.test.js

@@ -0,0 +1,41 @@
+// Tests for installAssets skills/commands staging (o4jgf MINOR 13):
+// expected content lands on first install, and the version gate makes a
+// second install a no-op. Offline/deterministic: temp XDG_CONFIG_HOME,
+// stub ctx, real asset tree, never the real $HOME or network.
+//
+// Run: npm test  (builds, then `node --test dist`)
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { getConfigDir, installAssets } from "./installer.js";
+function stubCtx() {
+    return { client: { app: { log: async () => { } } } };
+}
+test("installAssets stages skills and commands; version gate skips reinstall", async () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "thrum-oc-install-"));
+    const prevXdg = process.env.XDG_CONFIG_HOME;
+    process.env.XDG_CONFIG_HOME = tmp;
+    try {
+        await installAssets(stubCtx());
+        const cfg = path.join(tmp, "opencode");
+        assert.equal(getConfigDir(), cfg);
+        // protocol skills ride the wholesale skills copy (o4jgf item 5)
+        const skillFile = path.join(cfg, "skills", "snapshot-protocol", "SKILL.md");
+        assert.ok(fs.existsSync(skillFile));
+        assert.ok(fs.existsSync(path.join(cfg, "commands", "thrum-sleep.md")));
+        const mtimeBefore = fs.statSync(skillFile).mtimeMs;
+        await installAssets(stubCtx());
+        assert.equal(fs.statSync(skillFile).mtimeMs, mtimeBefore);
+    }
+    finally {
+        if (prevXdg === undefined) {
+            delete process.env.XDG_CONFIG_HOME;
+        }
+        else {
+            process.env.XDG_CONFIG_HOME = prevXdg;
+        }
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-thrum-pro",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Thrum multi-agent coordination plugin for Open Code",
   "type": "module",
   "main": "./dist/index.js",

package/assets/commands/thrum-_compact-runtime-commands.md

@@ -1,61 +0,0 @@
----
-description:
-  Per-runtime compact-equivalent command table consumed by compact.md,
-  compact-extended.md, and scripts/sync-skills.sh. Not user-invocable
-  directly.
----
-
-# Per-Runtime Compact Command Table (shared partial)
-
-Consumers: `claude-plugin/commands/compact.md`, `compact-extended.md`
-(reference this table for the command each runtime's synced copy sends), and
-`scripts/sync-skills.sh`'s `compact_command_for_runtime()` (the executable
-mirror of this table — keep the two in lockstep; a row added/changed here
-without a matching case in that function is a defect at review, not a style
-nit).
-
-This is the canonical, cited source of truth for what "the compact command"
-means on each runtime thrum drives. Do NOT invent a command for a runtime not
-listed here or not sourced — an unverified guess sent to a runtime's pane is
-worse than no compaction at all (it either no-ops or does something
-unintended). A runtime found to have no equivalent is recorded as such, not
-silently omitted.
-
-| Runtime      | Compact command                 | Source                                                                                                      | Confidence                    |
-| ------------ | -------------------------------- | -------------------------------------------------------------------------------------------------------------- | ------------------------------ |
-| `claude`     | `/compact`                       | Claude Code built-in slash command (already established in this project).                                       | Verified — first-party.        |
-| `codex`      | `/compact`                       | OpenAI Codex CLI context-compaction architecture (server-side `POST /v1/responses/compact`, manual trigger `/compact`). | Verified — corroborated by two independent technical write-ups; not fetched from `codex --help` directly. |
-| `opencode`   | `/compact` (alias `/summarize`)  | opencode.ai official docs, keybinds reference — `session_compact` action, default slash command `/compact`.     | Verified from official docs. **Caveat:** a differently-named community fork lacks this command — confirm against the specific `opencode` binary before relying on it blindly. |
-| `cursor`     | `/summarize` (alias `/compress`) | cursor.com CLI reference, slash-commands page.                                                                   | Verified from official docs. **Differs from Claude's `/compact`** — this is the one runtime where the sent text must actually change. `/clear` (aliases `/new`, `/new-chat`) is a separate full-reset command, not compaction — do not confuse the two. |
-| `copilot`    | `/compact`                       | docs.github.com, "Managing context in GitHub Copilot CLI".                                                       | Verified from official docs. **Not currently shippable**: `copilot-plugin/` has no skills/commands-loading mechanism at all (pre-existing, documented in `scripts/sync-skills.sh`'s header) — this row exists for completeness/future readiness, not because the skill ships there today. Coverage tracked as a build-vs-accept scope call, owner-owned. |
-| `muse`       | **NONE FOUND**                   | musecodes.io official docs — documented commands are `/plan`, `/grill`, `/goal`, `/workflows`, `/model`, `/effort`, `Esc Esc` (rewind), `muse replay`. No manual compact/summarize trigger is documented; marketing copy describing context "compaction" refers to an automatic/internal mechanism only, not a user-invocable command. | Verified absence, not an inferred gap. Per E9 (owner-ruled), muse falls to the `restart-extended` exception — it does not receive compact.md/compact-extended.md. |
-| `gemini`     | **UNVERIFIED**                   | Not researched — no plugin tree exists for this runtime, and it was never included in this table's original research pass. | **Not a confirmed negative.** Go-side `internal/runtime.RuntimePreset` exists for this runtime with `CompactCommand` deliberately left empty (falls back to `/thrum:restart-extended`, never invented). This research is not yet done — do not research here; treat future work on this row as owned elsewhere. |
-| `kiro-cli`   | **UNVERIFIED**                   | Same as `gemini` — not researched, no plugin tree.                                                              | Same as `gemini` — empty `CompactCommand`, safe fallback, research pending. |
-| `amp`        | **UNVERIFIED**                   | Same as `gemini` — not researched, no plugin tree.                                                              | Same as `gemini` — empty `CompactCommand`, safe fallback, research pending. |
-| `shell`      | **UNVERIFIED**                   | Same as `gemini` — not researched, no plugin tree.                                                              | Same as `gemini` — empty `CompactCommand`, safe fallback, research pending. |
-
-## Notes
-
-- `codex` and `opencode` resolve to the same literal string Claude uses
-  (`/compact`), so their synced copies are a functional no-op substitution —
-  still routed through the same mechanism for consistency and so a future
-  table change (e.g. if `opencode`'s fork situation resolves differently)
-  propagates without a second code path.
-- `cursor` is the one runtime whose synced copy's sent command differs from
-  Claude's and must be verified after every sync run (`grep` step in
-  `scripts/sync-skills.sh`'s `compact_command_for_runtime` block).
-- `muse` and `copilot` are both absent from compact/compact-extended's sync
-  targets today, for two *different* reasons — `muse` because no native
-  command exists to send, `copilot` because the plugin has no delivery
-  mechanism at all. Neither is a silent drop: both are recorded here and
-  reported in the completion report for this table's original research pass.
-- `gemini`/`kiro-cli`/`amp`/`shell` are recorded as **UNVERIFIED**, not
-  merged into the `muse`/`copilot` "no equivalent" rows above — those two are
-  confirmed negatives (verified by reading official docs); the four
-  UNVERIFIED rows are an absence of research, not an absence of a command.
-  `scripts/sync-skills.sh`'s `compact_command_for_runtime()` already returns
-  `""` for any of these four via its `*` default case, so the executable
-  mirror and this table already agree — no code change is needed to keep
-  them in lockstep, only this documentation. See also
-  `dev-docs/reference/compaction-lifecycle-attach-points.md` for the same
-  four runtimes' hook-attach-point status.

package/assets/commands/thrum-_generator-idempotency-protocol.md

@@ -1,15 +0,0 @@
----
-description:
-  Shared generator-skill idempotency invariant consumed by config/doc
-  generator skills. Not user-invocable directly.
----
-
-# Generator Idempotency Protocol (shared partial)
-
-Consumers: run `grep -rl _generator-idempotency-protocol claude-plugin/skills/`
-for the current set — do NOT hardcode it here. A list of consumers inside the
-consumed file is a second copy of a git-answerable fact and rots the moment a
-skill is added or dropped.
-
-The modes are idempotent — running the skill repeatedly on a stable project
-should produce no file changes after the first run.

package/assets/commands/thrum-_project-rules-protocol.md

@@ -1,18 +0,0 @@
----
-description:
-  Shared project-specific-rules protocol consumed by role skills. Not
-  user-invocable directly.
----
-
-# Project-Specific Rules Protocol (shared partial)
-
-Consumers: run `grep -rl _project-rules-protocol claude-plugin/skills/` for the
-current set — do NOT hardcode it here. A list of consumers inside the consumed
-file is a second copy of a git-answerable fact and rots the moment a skill is
-added or dropped.
-
-Project-local rules of kind `agent_rule` at `--scope role` were loaded at
-session start by your preamble (see your role template's Memory model block).
-If a project-local rule conflicts with a universal rule above, the
-project-local rule wins; surface the conflict in your reply so the user can
-decide whether to graduate or remove the override.

package/assets/commands/thrum-_verify-before-write-protocol.md

@@ -1,27 +0,0 @@
----
-description:
-  Shared "Verify before you write" invariant consumed by state-writing
-  skills. Not user-invocable directly.
----
-
-# Verify Before You Write Protocol (shared partial)
-
-Consumers: run `grep -rl _verify-before-write-protocol claude-plugin/skills/`
-for the current set — do NOT hardcode it here. A list of consumers inside the
-consumed file is a second copy of a git-answerable fact and rots the moment a
-skill is added or dropped.
-
-A written fact is TRUE at the moment it's recorded and can silently become
-FALSE later — the reader can't tell, because a note doesn't present itself as
-a time-bound claim. Before writing anything:
-
-- Only write what you've verified against current state — not what you
-  remember, assume, or were told once.
-- A note recording an UNEXPLAINED artifact must carry the unexplained-ness
-  forward — "not mine, cause unknown, nobody has traced this" — rather than
-  resolving it to a disposition like "ignore it." The note isn't wrong to cope
-  with noise you can't act on; the defect is closing the question when
-  nothing is actually known. "Ignore it" is unfalsifiable by construction —
-  an instruction to not look can't be caught by looking, because diligence is
-  exactly what it switches off — and it can silently train every future
-  session to stop looking at the one visible symptom of a live bug.