@krtclcdy/tersio 2.25.6 → 2.25.7

package/dist/extensions/shared/rtk-eligible.js

@@ -0,0 +1,84 @@
+// Eligible command heads, taken from rtk's own contract rather than a hardcoded guess.
+// `rtk rewrite <probe>` prints a rewrite and exits 0 or 3 when rtk handles the command,
+// and exits 1 when no equivalent exists. Each probe below is a representative workload
+// command, because subcommand-scoped tools such as `gh` rewrite `gh pr list` but not `gh`.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { normalizeRtkVersion, tersioDataPath } from './utils.js';
+/** Verified against rtk 1.0.1; the drift test fails when rtk's set moves. */
+export const FALLBACK_ELIGIBLE_HEADS = [
+    'rtk', 'git', 'gh', 'glab', 'docker', 'kubectl', 'psql', 'aws', 'bunx', 'npx',
+    'pytest', 'mypy', 'cat', 'grep', 'rg', 'find', 'tree', 'diff', 'ls', 'ast-grep',
+    'wget', 'prettier', 'playwright', 'prisma', 'jest', 'vitest', 'ctest', 'lint',
+    'wc', 'tsc', 'curl', 'cargo', 'npm', 'pnpm', 'bun', 'go', 'ruff', 'next',
+    'dotnet', 'oc', 'jq', 'make',
+];
+const PROBES = {
+    git: 'git log', gh: 'gh pr list', glab: 'glab mr list', docker: 'docker ps',
+    kubectl: 'kubectl get pods', psql: 'psql --version', aws: 'aws --version',
+    bunx: 'bunx --version', npx: 'npx --version', pytest: 'pytest --version',
+    mypy: 'mypy --version', cat: 'cat README.md', grep: 'grep rtk README.md',
+    rg: 'rg rtk README.md', find: 'find . -name x', tree: 'tree .', diff: 'diff a b',
+    ls: 'ls -la', 'ast-grep': 'ast-grep --version', wget: 'wget --version',
+    prettier: 'prettier --version', playwright: 'playwright --version', prisma: 'prisma --version',
+    jest: 'jest --version', vitest: 'vitest --version', ctest: 'ctest --version',
+    lint: 'lint .', wc: 'wc -l x', tsc: 'tsc --version', curl: 'curl --version',
+    cargo: 'cargo test', npm: 'npm run build', pnpm: 'pnpm run build', bun: 'bun run test',
+    go: 'go test ./...', ruff: 'ruff check .', next: 'next build', dotnet: 'dotnet build',
+    oc: 'oc get pods', jq: 'jq . x', make: 'make',
+};
+function probe(bin, command) {
+    try {
+        const out = execFileSync(bin, ['rewrite', command], { encoding: 'utf8', timeout: 5000, windowsHide: true });
+        return out.trim().length > 0;
+    }
+    catch (e) {
+        // Non-zero exit throws; exit 3 still prints a rewrite, exits 1 and 2 do not.
+        const err = e;
+        if (err.status !== 0 && err.status !== 3)
+            return false;
+        return String(err.stdout ?? '').trim().length > 0;
+    }
+}
+/** One set of heads for this rtk build, read straight from its rewrite contract. */
+export function deriveEligibleHeads(bin) {
+    const heads = new Set(['rtk']);
+    for (const [head, command] of Object.entries(PROBES)) {
+        if (probe(bin, command))
+            heads.add(head);
+    }
+    return heads;
+}
+function rtkVersion(bin) {
+    try {
+        return normalizeRtkVersion(execFileSync(bin, ['--version'], { encoding: 'utf8', timeout: 5000, windowsHide: true }));
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Heads rtk rewrites, cached per binary version so an upgrade re-derives once.
+ * Without a binary, or on any read failure, the verified fallback stands.
+ */
+export function eligibleHeads(bin) {
+    if (!bin)
+        return new Set(FALLBACK_ELIGIBLE_HEADS);
+    const version = rtkVersion(bin);
+    const file = tersioDataPath('rtk-eligible.json', 'rtk-eligible.json');
+    try {
+        const cached = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (cached.version === version && Array.isArray(cached.heads) && cached.heads.every((h) => typeof h === 'string')) {
+            return new Set(cached.heads);
+        }
+    }
+    catch { /* derive below */ }
+    const heads = deriveEligibleHeads(bin);
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, `${JSON.stringify({ version, heads: [...heads] })}\n`, 'utf8');
+    }
+    catch { /* the cache is best-effort */ }
+    return heads;
+}

package/dist/extensions/shared/rtk-gain.js

@@ -1,4 +1,4 @@
-// Savings read from rtk history, never estimated; modes bench in docs/BENCHMARK.md.
+// Savings read from rtk history, never estimated; modes bench in docs/BENCHMARK_GUIDE.md.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';

package/dist/extensions/shared/sqlite.js

@@ -1,14 +1,9 @@
-// One place that runs SQL against a database file.
-//
-// Bun and Node 22.5+ carry SQLite in process, so the `sqlite3` binary is a fallback rather than a
-// requirement: hosts without it kept silently reading nothing. Reads come back exactly as the sqlite3
-// CLI printed them -- rows on their own lines, cells joined by tabs, NULL an empty cell, one trailing
-// newline -- because every caller already parses that shape. The engine rungs take one statement per
-// read, so a caller with several queries calls once per query.
-//
-// The write path leaves the journal mode alone. The store's own schema sets WAL so a reader (the
-// dashboard) never blocks a writer, and changing the mode needs exclusive access: with a reader holding
-// the file the pragma fails, which is a failure reported after the caller's rows have already committed.
+// One place that runs SQL against a database file. Bun and Node 22.5+ carry SQLite in process, so the
+// `sqlite3` binary is a fallback: hosts without it kept silently reading nothing. Reads return the sqlite3
+// CLI shape (one row per line, cells tab-joined, NULL an empty cell) because every caller parses that.
+// The write path leaves the journal mode alone: the schema sets WAL so a reader never blocks a writer,
+// and the pragma needs exclusive access, so with a reader holding the file it fails after the caller's
+// rows have already committed (see docs/ERRORS.md).
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
@@ -51,8 +46,7 @@ function engine() {
     catch { /* not Bun, or no SQLite in this build */ }
     try {
         const { DatabaseSync } = requireOptional('node:sqlite');
-        // Rows arrive keyed by column name unless the statement returns arrays. A duplicate name collapses
-        // its key and shifts every later cell, so a Node that cannot return arrays is no engine at all.
+        // Rows arrive keyed by column name unless the statement returns arrays: a duplicate name collapses its key and shifts every later cell, so a Node that cannot return arrays is no engine.
         const probe = new DatabaseSync(':memory:');
         try {
             if (typeof probe.prepare('SELECT 1').setReturnArrays !== 'function')

package/dist/extensions/shared/status.js

@@ -26,8 +26,7 @@ function statusUi(ctx) {
 let remembered;
 let lastText;
 let lastUi;
-// Paint the host footer bar; same text on the same UI is skipped, a new ctx repaints it.
-// One key only: the combo line already names the caveman mode, and a second key renders as a second footer line.
+// Paint the host footer bar; same text on the same UI is skipped. One key only: the combo line already names the caveman mode, and a second key renders as a second footer line.
 export function announceStatus(ctx) {
     const state = getSharedComboState();
     const text = formatStatus(state);

package/dist/extensions/shared/usage-ledger.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from './utils.js';
+import { eligibleHeads } from './rtk-eligible.js';
 import { sqliteRead } from './sqlite.js';
 export function ledgerPath() {
     const override = process.env.TERSIO_USAGE_FILE;
@@ -196,6 +197,60 @@ export function dayKey(ts) {
     const p = (n) => String(n).padStart(2, '0');
     return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
 }
+// OpenCode tool parts carry the command in the message blob; sqliteRead is line-based, so newlines are flattened in SQL.
+const OC_BASH_CMD = "replace(replace(json_extract(j.value,'$.state.input.command'), char(10), ' '), char(13), ' ')";
+const OC_BASH_TOOL = "json_extract(j.value,'$.type')='tool' AND (json_extract(j.value,'$.name')='bash' OR json_extract(j.value,'$.name')='shell')";
+const ocBashLegacy = `SELECT message.id, json_extract(message.data,'$.sessionID'), ${OC_BASH_CMD} FROM message, json_each(message.data,'$.content') j WHERE json_extract(message.data,'$.role')='assistant' AND ${OC_BASH_TOOL}`;
+const ocBashCurrent = `SELECT session_message.id, session_message.session_id, ${OC_BASH_CMD} FROM session_message, json_each(session_message.data,'$.content') j WHERE session_message.type='assistant' AND ${OC_BASH_TOOL}`;
+/** Every executed bash command in an OpenCode db, v2 first and the legacy table second. */
+export function readOpencodeBashRows(db) {
+    const rows = [];
+    try {
+        if (!fs.existsSync(db))
+            return rows;
+        let out = '';
+        try {
+            out += sqliteRead(db, ocBashCurrent);
+        }
+        catch { /* no v2 table */ }
+        try {
+            out += sqliteRead(db, ocBashLegacy);
+        }
+        catch { /* no legacy table */ }
+        for (const line of out.split('\n')) {
+            if (!line.trim())
+                continue;
+            const [id, sessionId, command] = line.split('\t');
+            if (typeof command !== 'string' || !command.trim())
+                continue;
+            rows.push({ id: id ?? '', sessionId: sessionId ?? '', command });
+        }
+    }
+    catch { /* an unreadable db is a skip, not a failure */ }
+    return rows;
+}
+// Pre-v2 OpenCode stores one message per JSON file; the same tool-part shape holds the command.
+function opencodeFileBash(file) {
+    try {
+        const message = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const parts = Array.isArray(message.content) ? message.content : [];
+        const commands = [];
+        for (const part of parts) {
+            const p = part;
+            if (p?.type !== 'tool')
+                continue;
+            if (p.name !== 'bash' && p.name !== 'shell')
+                continue;
+            const command = p.state?.input?.command;
+            if (typeof command === 'string' && command)
+                commands.push(command);
+        }
+        return { commands, sessionId: typeof message.sessionID === 'string' ? message.sessionID : '' };
+    }
+    catch {
+        return { commands: [], sessionId: '' };
+    }
+}
 export function walkJsonl(dir, out, cap, ext = '.jsonl') {
     let entries;
     try {
@@ -217,11 +272,6 @@ export function walkJsonl(dir, out, cap, ext = '.jsonl') {
 // Recent rows are a newest-first window over lifetime history; aggregates keep everything.
 export const RECENT_LIMIT = 2000;
 const FREE_SUFFIX = /(?::free|-free)$/i;
-const RTK_ELIGIBLE_HEADS = new Set([
-    'rtk', 'git', 'grep', 'rg', 'find', 'cat', 'ls', 'tree', 'diff', 'log',
-    'npm', 'npx', 'pnpm', 'bun', 'bunx', 'cargo', 'go', 'python', 'pytest',
-    'ruff', 'mypy', 'docker', 'kubectl', 'psql', 'aws', 'gh', 'glab', 'wc',
-]);
 export function newSessionAccum() {
     return { byModel: {}, byDay: {}, byDayModel: {}, byTool: {}, byModelMessages: {}, byHost: {}, byAgent: {}, byAgentMessages: {}, byModelMeasured: {}, byModelCostMessages: {}, totals: zeroBreakdown(), messages: 0, costMeasured: 0, recent: [], recentFloor: Number.POSITIVE_INFINITY };
 }
@@ -569,7 +619,17 @@ export function agentOfSessionText(text) {
     return 'main';
 }
 const adoptionFileCache = new Map();
-function parseAdoptionFile(file) {
+function countBashCommands(commands, eligible, counts) {
+    for (const command of commands) {
+        counts.bashCalls += 1;
+        const head = leadBinary(command);
+        if (eligible.has(head))
+            counts.eligibleCalls += 1;
+        if (head === 'rtk')
+            counts.rtkCalls += 1;
+    }
+}
+function parseAdoptionFile(file, eligible) {
     const counts = { bashCalls: 0, eligibleCalls: 0, rtkCalls: 0 };
     let text;
     try {
@@ -578,7 +638,7 @@ function parseAdoptionFile(file) {
     catch {
         return { counts, sessions: 0 };
     }
-    let sawBash = false;
+    const commands = [];
     for (const line of text.split('\n')) {
         if (!line.includes('tool_execution_start'))
             continue;
@@ -587,24 +647,22 @@ function parseAdoptionFile(file) {
             if (row.type !== 'custom' || row.customType !== 'tool_execution_start' || row.data?.toolName !== 'bash')
                 continue;
             const command = row.data.args?.command;
-            if (typeof command !== 'string')
-                continue;
-            sawBash = true;
-            counts.bashCalls += 1;
-            const head = leadBinary(command);
-            if (RTK_ELIGIBLE_HEADS.has(head))
-                counts.eligibleCalls += 1;
-            if (head === 'rtk')
-                counts.rtkCalls += 1;
+            if (typeof command === 'string')
+                commands.push(command);
         }
         catch { /* skip corrupt line */ }
     }
-    return { counts, sessions: sawBash ? 1 : 0 };
+    countBashCommands(commands, eligible, counts);
+    return { counts, sessions: commands.length > 0 ? 1 : 0 };
 }
 export function clearRtkAdoptionCache() {
     adoptionFileCache.clear();
 }
 export function readRtkAdoption() {
+    // The eligible set comes from rtk's rewrite contract, cached per binary version.
+    const eligible = eligibleHeads(resolveRtkBinary());
+    // A cached count is only valid for the head set that produced it.
+    const headsKey = [...eligible].sort().join(',');
     const files = [];
     for (const dir of sessionsDirs())
         walkJsonl(dir, files, 2000);
@@ -626,9 +684,9 @@ export function readRtkAdoption() {
             continue;
         }
         let entry = adoptionFileCache.get(file);
-        if (!entry || entry.size !== stat.size || entry.mtimeMs !== stat.mtimeMs) {
-            const parsed = parseAdoptionFile(file);
-            entry = { size: stat.size, mtimeMs: stat.mtimeMs, counts: parsed.counts };
+        if (!entry || entry.size !== stat.size || entry.mtimeMs !== stat.mtimeMs || entry.heads !== headsKey) {
+            const parsed = parseAdoptionFile(file, eligible);
+            entry = { size: stat.size, mtimeMs: stat.mtimeMs, heads: headsKey, counts: parsed.counts };
             adoptionFileCache.set(file, entry);
             sessions += parsed.sessions;
         }
@@ -639,6 +697,30 @@ export function readRtkAdoption() {
         eligibleCalls += entry.counts.eligibleCalls;
         rtkCalls += entry.counts.rtkCalls;
     }
+    // OpenCode keeps its own store: a v2 sqlite db, or one JSON file per message before v2.
+    const opencode = { bashCalls: 0, eligibleCalls: 0, rtkCalls: 0 };
+    const opencodeSessions = new Set();
+    if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DB !== undefined) {
+        for (const row of readOpencodeBashRows(opencodeDbPath())) {
+            countBashCommands([row.command], eligible, opencode);
+            if (row.sessionId)
+                opencodeSessions.add(row.sessionId);
+        }
+    }
+    const ocFiles = [];
+    if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DIR !== undefined) {
+        walkJsonl(opencodeSessionsDir(), ocFiles, 5000, '.json');
+        for (const file of ocFiles) {
+            const parsed = opencodeFileBash(file);
+            countBashCommands(parsed.commands, eligible, opencode);
+            if (parsed.sessionId)
+                opencodeSessions.add(parsed.sessionId);
+        }
+    }
+    bashCalls += opencode.bashCalls;
+    eligibleCalls += opencode.eligibleCalls;
+    rtkCalls += opencode.rtkCalls;
+    sessions += opencodeSessions.size;
     const missedCalls = Math.max(0, eligibleCalls - rtkCalls);
     return { sessions, bashCalls, eligibleCalls, rtkCalls, missedCalls, adoptionPct: eligibleCalls ? (rtkCalls / eligibleCalls) * 100 : 0 };
 }

package/extensions/caveman/index.ts

@@ -8,8 +8,12 @@ import { readCavemanDefault } from '../shared/plugin-settings.ts';
 import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
 
 const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
-// Upstream ships one skill per register: default, ultracave, megacave.
-const RULE_FILES = { lite: 'rule.md', full: 'rule.md', ultra: 'rule-ultra.md', 'megacave-lite': 'rule-megacave.md', 'megacave-full': 'rule-megacave.md', 'megacave-ultra': 'rule-megacave.md' };
+// `rule.md`, `rule-ultra.md`, and `rule-megacave.md` track upstream's three registers: `rule.md` is bundled with
+// one host-adapted line, and the other two are fetched from upstream on install and updated in-session.
+// `lite`, `megacave-lite`, and `megacave-ultra` are our forks of upstream's rows at 84cc3c1, so they are
+// bundled rather than fetched. rule-ultra.md and rule-megacave.md are never edited here: the in-session
+// updater rewrites them from upstream and restores the backup when the write does not match.
+const RULE_FILES = { lite: 'rule-lite.md', full: 'rule.md', ultra: 'rule-ultra.md', 'megacave-lite': 'rule-megacave-lite.md', 'megacave-full': 'rule-megacave.md', 'megacave-ultra': 'rule-megacave-ultra.md' };
 
 const DEFAULT_MODE = 'off';
 

package/extensions/caveman/rule-lite.md

@@ -0,0 +1,77 @@
+---
+name: lightcave
+description: >
+  Caveman at its lightest register: no filler and no hedging, with articles and
+  full sentences kept. Professional but tight. Use for /caveman lite, or the lite
+  part of a Combo preset. Stays on until "stop caveman" or "normal mode".
+source: >
+  Upstream JuliusBrussee/caveman, skills/caveman/SKILL.md at 84cc3c1, the "Intensity" table, row `lite`.
+  The row reads: "No filler/hedging. Keep articles + full sentences. Professional but tight"
+  The worked example under it is this register's model answer. The floor, the break-the-rules list,
+  and the pre-send check come from the same body. Adapted for Tersio's hosts and hook; no rule here
+  is Tersio's own.
+---
+
+# lightcave
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die. This is the light register: sentences stay sentences and articles stay, and the words that carry nothing go.
+
+## Persistence
+
+Every response, whole session, until "stop caveman" or "normal mode". Unsure if still on? It is. `/caveman status` reports the mode and changes nothing: relay the hook's `Caveman mode: <mode>` value when present. With no hook, report the mode you followed, or `off` if caveman was turned off or never active, plus `(not tracked by this host)`.
+
+## What changes at lite
+
+Drop filler, hedging, pleasantries, recap, and closers. Keep articles, keep full sentences, keep punctuation. Professional but tight.
+
+Bad: "Sure! I'd be happy to help. The issue you're experiencing is likely caused by an inline object prop."
+Good: "Your component re-renders because you create a new object reference on each render. Wrap it in `useMemo`."
+
+## Floor
+
+Never cut: code blocks, commands, paths, API names, error strings (verbatim). not/never/no/only/except. Numbers and units. The user's language. One term per thing. No invented abbreviations, no arrows. Existing comments in files you edit: never delete or shorten one you were not asked to change.
+
+## Rules
+
+### 1. Answer first
+
+Answer, then reason, then next step. Pattern: `[thing] [action] [reason]. [next step].`
+
+### 2. Kill ceremony
+
+No greeting, hedging, pleasantries, recap, or closer. No "Sure!", "Let me", "I'll now", "Hope this helps". No just/really/basically/actually/simply.
+
+### 3. Short word
+
+"fix" not "implement a solution for". Standard acronyms fine (DB, API, HTTP). Invented abbreviations not (cfg, impl, fn): same tokens, harder read. No arrows.
+
+### 4. One idea per sentence
+
+20 words max, active voice, imperative for instructions, pronoun only with an obvious referent. Compression and clarity conflict? Clarity wins.
+
+### 5. Payload verbatim
+
+Code blocks unchanged. Commands, paths, API names exact. Errors quoted exact, shortest decisive line only. A code change in chat shows the changed lines plus 1-2 lines of context, not the whole file, unless the user asks for the whole file or most of it changes.
+
+### 6. Tool runs: bounded status
+
+No text between routine calls. One line before a multi-step run, one line per phase change, one line with the result at the end. Otherwise text before a call only to clarify, warn, or disambiguate.
+
+### 7. User's language
+
+Compress the style, not the language. An explicit reply-language instruction wins. Never switch because of quoted text. Technical terms and errors stay verbatim.
+
+### 8. Never perform caveman
+
+No "caveman mode on", no "me think", no "Caveman:" prefix, no normal answer plus caveman copy. No decorative tables or emoji.
+
+## When to break the rules
+
+Plain prose, then resume: security warning. Irreversible action, confirmed first. Step order a sentence could scramble. User confused or repeats the question. Anything persisted outside chat — code, comments, commits, docs, issues, PRs, tickets, memory files, third-party messages — with `/caveman-compress`, where the host offers it, exempt. A status line or confirmation the harness asks for. A question you ask the user, with its options.
+
+## Pre-send check
+
+1. First sentence announces what you will do? Delete.
+2. Last sentence recaps or offers help? Delete.
+3. Any filler or hedging left? Cut it.
+4. Every code span, path, number, and error verbatim? Any sentence with two readings is a full sentence.

package/extensions/caveman/rule-megacave-lite.md

@@ -0,0 +1,59 @@
+---
+name: megacave-lite
+description: >
+  Megacave at its lightest register: semi-classical 文言文 flavour with grammar
+  structure kept, filler and hedging dropped. Use for /caveman megacave-lite. Stays
+  on until "stop caveman" or "normal mode".
+source: >
+  Upstream JuliusBrussee/caveman, skills/caveman/SKILL.md at 84cc3c1, the "Intensity" table, row `wenyan-lite`.
+  The row reads: "Semi-classical. Drop filler/hedging but keep grammar structure, classical register"
+  The worked example under it is this register's model answer. The Floor comes from upstream
+  skills/megacave/SKILL.md at main. Adapted for Tersio's hosts and hook; no rule here is Tersio's own.
+---
+
+# megacave-lite
+
+以文言答，而語法具存。技術之實皆存，唯贅言與游移去之。
+
+Semi-classical register with grammar kept. Drop filler, hedging, pleasantries, recap, and closers. Keep the subject, keep the object order, and keep the punctuation the sentence needs. Classical particles (之、乃、為、其、則、故、以) replace connective phrases, but the sentence still reads in order.
+
+Bad: 「當然，我很樂意協助您。您遇到的問題大概是因為每次渲染都建立了新的物件參照。」
+Good: 「組件頻重繪，以每繪新生對象參照故。以 `useMemo` 包之。」
+
+## Floor
+
+Never cut or translate: code, commands, paths, API names, error strings, in their original script. Negation (不, 非, 勿, 未, 毋). Numbers and units, Arabic numerals. One term per thing. A clause ambiguous in 文言 becomes 白話. Existing comments in files you edit: never delete or shorten unless asked.
+
+## Rules
+
+### 1. Classical flavour, modern grammar
+
+半文言, not 白話. Subject, verb, and object stay where a reader expects them. One particle, one relation.
+
+### 2. Drop filler and hedging only
+
+No 當然, 我想, 可能, 基本上, 其實. No pleasantries, no recap, no closer. Articles and sentence structure stay.
+
+### 3. One idea per sentence
+
+Short sentences, one relation each. Any clause with two readings becomes a full sentence.
+
+### 4. Payload in original script
+
+Code blocks, commands, paths, API names, and error strings stay verbatim, in their original script.
+
+### 5. Tool runs: bounded status
+
+One line in, one out. Nothing between calls unless direction changes, confirmation is needed, or a security or irreversible step is ahead.
+
+### 6. Never perform caveman
+
+No 「文言模式啟」, no modern answer plus classical copy. 半文言 not shorter than 白話 for a sentence? Use 白話.
+
+## When to break the rules
+
+白話 or the user's language, full sentences, then resume: security warning. Irreversible action, confirmed first. Any clause with two readings. User confused. Question to the user, with its options. Anything persisted outside chat — code, comments, commits, docs, issues, PRs, tickets, memory, third-party messages — with `/caveman-compress`, where the host offers it, exempt. A status line or confirmation the harness asks for.
+
+## Pre-send check
+
+Identifiers verbatim, original script? Negations present? Two readings? 白話. Flavour word left? Cut.

package/extensions/caveman/rule-megacave-ultra.md

@@ -0,0 +1,59 @@
+---
+name: megacave-ultra
+description: >
+  Megacave at maximum compression: extreme abbreviation while keeping the
+  classical Chinese feel. Use for /caveman megacave-ultra. Stays on until
+  "stop caveman" or "normal mode".
+source: >
+  Upstream JuliusBrussee/caveman, skills/caveman/SKILL.md at 84cc3c1, the "Intensity" table, row `wenyan-ultra`.
+  The row reads: "Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse"
+  The worked example under it is this register's model answer. The Floor comes from upstream
+  skills/megacave/SKILL.md at main. Adapted for Tersio's hosts and hook; no rule here is Tersio's own.
+---
+
+# megacave-ultra
+
+以文言答，極簡其辭。技術之實皆存，唯字去之。
+
+Extreme abbreviation, classical feel. Subjects, copulas, and connectives all go; one mark carries one relation. Arrows for causality. Maximum compression, ultra terse.
+
+Bad: 「因為每次渲染都建立了新的物件參照，所以組件會重新渲染。請用 useMemo 包起來。」
+Good: 「新參照→重繪。`useMemo` Wrap。」
+
+## Floor
+
+Never cut or translate: code, commands, paths, API names, error strings, in their original script. Negation (不, 非, 勿, 未, 毋). Numbers and units, Arabic numerals. One term per thing. A clause ambiguous in 文言 becomes 白話. Existing comments in files you edit: never delete or shorten unless asked.
+
+## Rules
+
+### 1. Extreme abbreviation
+
+Drop subjects, copulas, connectives, and any word the sentence survives without. One mark per relation: → for cause, 、 for a list, 。 to stop.
+
+### 2. Classical feel
+
+Terse noun phrases and classical word order wherever a shorter form exists. A particle only when no shorter mark can carry the relation.
+
+### 3. Each fact once
+
+No restating, no summary after a list. Code change: changed lines plus context, not the whole file.
+
+### 4. Payload in original script
+
+Never abbreviate an identifier to save characters. Code blocks, commands, paths, API names, and error strings stay verbatim, in their original script.
+
+### 5. Tool runs
+
+One line in, one out. Nothing between calls unless the harness asks or a security or irreversible step is ahead.
+
+### 6. Never perform caveman
+
+No announcement, no mangled characters for flavour. Abbreviation not shorter than the sentence? Use the sentence.
+
+## When to break the rules
+
+白話 or the user's language, full sentences, then resume: security warning. Irreversible action, confirmed first. Any clause with two readings. User confused. Question to the user, with its options. Anything persisted outside chat — code, comments, commits, docs, issues, PRs, tickets, memory, third-party messages — with `/caveman-compress`, where the host offers it, exempt. A status line or confirmation the harness asks for.
+
+## Pre-send check
+
+Identifiers verbatim, original script? Negations present? Two readings? 白話. Flavour character? Cut.

package/extensions/caveman/rule.md

@@ -77,7 +77,7 @@ Plain prose, then resume:
 2. Irreversible action. Confirm in full sentences first.
 3. Step order a fragment could scramble.
 4. User confused or repeats the question.
-5. Anything persisted outside chat: code, comments, commits, docs, issues, PRs, tickets, memory files, third-party messages. `/caveman-compress` exempt.
+5. Anything persisted outside chat: code, comments, commits, docs, issues, PRs, tickets, memory files, third-party messages. `/caveman-compress`, where the host offers it, is exempt.
 6. Harness asks for a status line or confirmation. Give it. Harness decides *when* you speak, caveman decides *how*.
 7. You ask the user a question or offer options. Full sentences, so the answer comes back right first time.
 

package/extensions/combo/index.ts

@@ -51,8 +51,11 @@ function piHasUpstreamPonytail(): boolean {
   }
 }
 
+// Each level's own rule, quoted from the installed Ponytail so a host that cannot resolve the package still gets the right register: `lite` builds what was asked and offers the smaller option, and only `ultra` questions the request.
 const PONYTAIL_FALLBACK_INTENSITY: Record<string, string> = {
-  lite: 'Prefer the simplest correct solution.',
+  lite: 'Build what was asked. Name the smaller option in one line and let the user pick.',
+  full: 'The rules above. Default.',
+  ultra: 'Also question the request: before building, push back on any part the need does not justify.',
 };
 
 // Fallback text when Ponytail cannot be found; exported for its own test.
@@ -81,6 +84,15 @@ async function loadPonytailInstructions(mode: string): Promise<string> {
   return ponytailFallback(mode);
 }
 
+// What a fresh session starts from: a stored per-mode default wins, and with none the Combo preset supplies all four. pstackDefault counts as its own default, so a session that stores only it still honors it instead of losing it to the preset's `off`.
+function savedModes(): { caveman: string; rtk: string; ponytail: string; pstack: string } {
+  const hasModeDefaults = ['cavemanDefault', 'rtkDefault', 'ponytailDefault', 'pstackDefault'].some((key) => key in readPluginSettings());
+  const preset = COMBO_LEVELS[readComboDefault()];
+  return hasModeDefaults
+    ? { caveman: readCavemanDefault(), rtk: readRtkDefault() ? 'on' : 'off', ponytail: readPonytailDefault(), pstack: readPstackDefault() }
+    : { caveman: preset.caveman, rtk: preset.rtk, ponytail: preset.ponytail, pstack: preset.pstack };
+}
+
 export default function comboToggleExtension(pi: ExtensionApi): void {
   setExtensionLabel(pi, 'Combo session toggle (all four add-ons)');
 
@@ -99,14 +111,9 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
     pi.appendEntry?.('combo-level', { level });
   }
   function restoreConfiguredDefaults(): void {
-    const settings = readPluginSettings();
-    const hasModeDefaults = ['cavemanDefault', 'rtkDefault', 'ponytailDefault'].some((key) => key in settings);
     const combo = readComboDefault();
     const preset = COMBO_LEVELS[combo];
-    // A stored per-mode default wins; with none, the preset supplies all four.
-    const modes = hasModeDefaults
-      ? { caveman: readCavemanDefault(), rtk: readRtkDefault() ? 'on' : 'off', ponytail: readPonytailDefault(), pstack: readPstackDefault() }
-      : { caveman: preset.caveman, rtk: preset.rtk, ponytail: preset.ponytail, pstack: preset.pstack };
+    const modes = savedModes();
     setSharedComboModes(modes);
     if (modes.caveman === 'off' && modes.rtk === 'off' && modes.ponytail === 'off' && modes.pstack === 'off') return;
     pi.appendEntry?.('caveman-mode', { mode: modes.caveman });
@@ -216,6 +223,18 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
     // The configured defaults apply when a fresh session has no persisted mode state.
     const entries = sessionEntries(ctx);
     if (!hasModeState(entries) && (ctx?.hasUI || OPENCODE)) restoreConfiguredDefaults();
+    else if (!hasModeState(entries)) {
+      // A headless root session (`host -p`) has no UI to publish the bridge, and Ponytail reads only
+      // the bridge, so it never loaded: a benchmark on omp measured Block 0 for every Ponytail level and
+      // for the Ponytail part of every Combo. Publish the saved modes only while the bridge is clear:
+      // once a parent or a toggle has published, the bridge carries that session's own choice and a
+      // subagent branch must keep inheriting it. All four go together, because Caveman, RTK, and pstack
+      // already restored their own levels and a disagreeing bridge resets them.
+      const shared = getSharedComboState();
+      if (shared.caveman === 'off' && shared.rtk === 'off' && shared.ponytail === 'off' && shared.pstack === 'off') {
+        setSharedComboModes(savedModes());
+      }
+    }
     // Announced last, so any default above is reflected.
     announceStatus(ctx);
   });
@@ -231,6 +250,7 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
 
   pi.on<SystemPromptEvent>('before_agent_start', async (event, ctx) => {
     if (ctx?.hasUI) reconcile(ctx);
+    // Shared state, with no marker check: the marker is a sentence copied out of the host binary, so matching on it would drop Ponytail after a host reworded the line.
     const mode = getSharedComboState().ponytail;
     // On pi, an installed upstream pi-extension is the sole injector, so Tersio only falls back with none.
     if (isPiProcess() && piHasUpstreamPonytail()) return;

package/extensions/pstack/index.ts

@@ -23,7 +23,9 @@ function buildInstruction(): string {
   try { body = readFileSync(join(PSTACK_DIR, RULE_FILE), 'utf8'); } catch {
     return `pstack mode requested, but ${RULE_FILE} is missing. Run: tersio doctor --fix extensions`;
   }
-  cachedInstruction = `pstack mode active for this session.\n${body}`;
+  // The rule body names the files by relative path, so one line gives the directory they sit in.
+  const home = `Leaves, playbooks, and skills live at: ${PSTACK_DIR} — \`principles/<title>.md\`, \`playbooks/<title>.md\`, \`skills/<name>/SKILL.md\`, \`references/<title>.md\`.`;
+  cachedInstruction = `pstack mode active for this session.\n${body}\n${home}`;
   return cachedInstruction;
 }
 

package/extensions/pstack/playbooks/authoring-a-skill.md

@@ -0,0 +1,12 @@
+### Authoring or modifying a skill
+
+**You own the skill's voice.**
+
+1. Use the **create-skill** skill (the host's built-in for authoring SKILL.md files).
+2. Validate the skill: frontmatter has `name` and `description`, referenced files exist, cross-skill links resolve.
+3. Test cases if structural. Skip if subjective.
+4. Run **Opening a PR**.
+
+When in doubt, delete. Keep only prose that changes a decision. Tell it to do the thing and skip the reason. Explain only when the rule is confusing without one. Match tone to scope. Point at structural sources (types, READMEs, config) per the **encode-lessons-in-structure** principle skill. Delegate to other skills by path. Don't restate. A workflow you keep hitting but isn't captured → propose a new skill.
+
+**Reply:** summary of the skill, key design decisions, validation notes.