@tokelang-lite/claude-code-skill 1.0.0

package/install/install.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+/*
+ * Tokelang Claude Code skill — NPX installer.
+ *
+ *   npx @tokelang-lite/claude-code-skill
+ *
+ * What it does (no external npm dependencies — built-in modules only):
+ *   1. Detect this host's platform/arch and pick the matching release artifact name.
+ *   2. Download that static `tokelang-cli` binary from the tokelang-cli GitHub release,
+ *      verify it against the release's combined SHA256SUMS, mark it executable.
+ *   3. Assemble the plugin (skills + hooks + statusline + resolver) at
+ *      `~/.claude/skills/tokelang/`, dropping the binary into its `bin/`.
+ *
+ * Install target = a personal-scope *skills-directory plugin*: any folder under
+ * `~/.claude/skills/` that has a `.claude-plugin/plugin.json` loads automatically as
+ * `tokelang@skills-dir` on the next session — no `claude` CLI call, no marketplace, and no
+ * workspace-trust gate (personal scope). It is discovered in place (not copied to a cache),
+ * so the binary we place in `bin/` is exactly what the hooks run.
+ *
+ * Env overrides (mainly for offline installs / the Phase-2b gate / CI):
+ *   TOKELANG_LOCAL_BIN   path to a prebuilt binary to use instead of downloading
+ *   TOKELANG_DOWNLOAD_BASE   release asset base URL (default: the tokelang-cli GitHub release)
+ *   TOKELANG_CLI_VERSION   version → release tag `v<version>` (default: package version)
+ *   TOKELANG_INSTALL_DIR   install fully somewhere else (default: $CLAUDE_CONFIG_DIR or ~/.claude → /skills/tokelang)
+ * Flags: --dry-run (resolve + report, touch nothing), --force (reinstall), --help.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const https = require('https');
+const crypto = require('crypto');
+
+const PKG_ROOT = path.resolve(__dirname, '..');
+const PKG = require(path.join(PKG_ROOT, 'package.json'));
+
+const ARGS = process.argv.slice(2);
+const DRY_RUN = ARGS.includes('--dry-run');
+const FORCE = ARGS.includes('--force');
+
+if (ARGS.includes('--help') || ARGS.includes('-h')) {
+  console.log(
+    [
+      'Tokelang Claude Code skill installer',
+      '',
+      'Usage: npx @tokelang-lite/claude-code-skill [--dry-run] [--force]',
+      '',
+      '  --dry-run   Show what would happen; change nothing.',
+      '  --force     Reinstall even if already present.',
+      '',
+      'Installs to ~/.claude/skills/tokelang/ (override with TOKELANG_INSTALL_DIR).',
+    ].join('\n'),
+  );
+  process.exit(0);
+}
+
+// ---- platform → release artifact name --------------------------------------------------
+// Names MUST match the skill resolver (skill bin/tokelang-cli): tokelang-cli-<os>-<arch>,
+// os = `uname -s` lowercased (windows shells normalized to "windows"), arch = `uname -m`.
+function resolveArtifact() {
+  const platform = os.platform(); // 'linux' | 'darwin' | 'win32'
+  const arch = os.arch(); // 'x64' | 'arm64' | ...
+  const table = {
+    'linux:x64': 'tokelang-cli-linux-x86_64',
+    'darwin:arm64': 'tokelang-cli-darwin-arm64',
+    'darwin:x64': 'tokelang-cli-darwin-x86_64',
+    'win32:x64': 'tokelang-cli-windows-x86_64.exe',
+  };
+  const artifact = table[`${platform}:${arch}`];
+  if (!artifact) {
+    fail(
+      `unsupported platform ${platform}/${arch}.\n` +
+        'Supported: linux x64, macOS arm64/x64, Windows x64.\n' +
+        'Build from source instead: cargo build --release -p tokelang-cli',
+    );
+  }
+  return artifact;
+}
+
+function fail(msg) {
+  console.error(`\n✗ tokelang install failed: ${msg}\n`);
+  process.exit(1);
+}
+
+// ---- download (follows GitHub's redirect to the asset storage host) --------------------
+function download(url, redirectsLeft = 5) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, { headers: { 'User-Agent': 'tokelang-installer' } }, (res) => {
+        const { statusCode, headers } = res;
+        if (statusCode >= 300 && statusCode < 400 && headers.location) {
+          if (redirectsLeft <= 0) return reject(new Error('too many redirects'));
+          res.resume();
+          return resolve(download(headers.location, redirectsLeft - 1));
+        }
+        if (statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`HTTP ${statusCode} for ${url}`));
+        }
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () => resolve(Buffer.concat(chunks)));
+      })
+      .on('error', reject);
+  });
+}
+
+function sha256(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+// ---- recursive copy with a per-file filter ---------------------------------------------
+function copyTree(src, dest, filter) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      copyTree(path.join(src, entry), path.join(dest, entry), filter);
+    }
+  } else {
+    if (filter && !filter(src)) return;
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+    // Preserve executability for the resolver + hook/statusline scripts.
+    if (src.endsWith('.sh') || path.basename(src) === 'tokelang-cli') {
+      fs.chmodSync(dest, 0o755);
+    }
+  }
+}
+
+async function main() {
+  const artifact = resolveArtifact();
+  const version = process.env.TOKELANG_CLI_VERSION || PKG.version;
+  const tag = `v${version}`;
+  const base =
+    process.env.TOKELANG_DOWNLOAD_BASE ||
+    `https://github.com/tokelang/tokelang-cli/releases/download/${tag}`;
+
+  const installDir =
+    process.env.TOKELANG_INSTALL_DIR ||
+    path.join(
+      process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'),
+      'skills',
+      'tokelang',
+    );
+  const binDir = path.join(installDir, 'bin');
+  const binDest = path.join(binDir, artifact);
+
+  console.log(`Tokelang Claude Code skill v${PKG.version}`);
+  console.log(`  platform : ${os.platform()}/${os.arch()} → ${artifact}`);
+  console.log(`  binary   : ${process.env.TOKELANG_LOCAL_BIN || `${base}/${artifact}`}`);
+  console.log(`  install  : ${installDir}`);
+
+  if (fs.existsSync(installDir) && !FORCE && !DRY_RUN) {
+    console.log(
+      `\n• Already installed at ${installDir}. Re-run with --force to reinstall.\n` +
+        '  Restart Claude Code or run /reload-plugins if it is not active yet.',
+    );
+    return;
+  }
+
+  // 1) Obtain + verify the binary buffer before touching the install dir.
+  let binBuf;
+  if (process.env.TOKELANG_LOCAL_BIN) {
+    binBuf = fs.readFileSync(process.env.TOKELANG_LOCAL_BIN);
+    console.log(`  using local binary (${binBuf.length} bytes), skipping download/verify`);
+  } else if (DRY_RUN) {
+    console.log('\n[dry-run] would download + SHA-256 verify the binary, then assemble the plugin.');
+    return;
+  } else {
+    console.log('\n→ downloading binary …');
+    binBuf = await download(`${base}/${artifact}`).catch((e) =>
+      fail(`could not download ${artifact}: ${e.message}\n(is the ${tag} release published?)`),
+    );
+    console.log('→ verifying checksum …');
+    // The release publishes a single combined SHA256SUMS (one `<hash>  <name>` line per
+    // artifact), not per-file .sha256 sidecars. Fetch it once and pick our artifact's line.
+    const sumText = await download(`${base}/SHA256SUMS`).catch((e) =>
+      fail(`could not download SHA256SUMS: ${e.message}`),
+    );
+    let expected = null;
+    for (const line of sumText.toString('utf8').split('\n')) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 2) continue;
+      const name = parts.slice(1).join(' ').replace(/^\*/, ''); // strip binary-mode '*' marker
+      if (name === artifact) {
+        expected = parts[0].toLowerCase();
+        break;
+      }
+    }
+    if (!expected) fail(`no SHA256SUMS entry for ${artifact}`);
+    const actual = sha256(binBuf).toLowerCase();
+    if (!/^[0-9a-f]{64}$/.test(expected) || expected !== actual) {
+      fail(`checksum mismatch for ${artifact}\n  expected ${expected}\n  actual   ${actual}`);
+    }
+    console.log(`  ok (sha256 ${actual.slice(0, 16)}…)`);
+  }
+
+  if (DRY_RUN) {
+    console.log('\n[dry-run] verified; would now write the plugin. Nothing changed.');
+    return;
+  }
+
+  // 2) Fresh assemble: clear our own dir, copy the plugin tree (resolver yes, prebuilt
+  //    platform binaries no — those are downloaded fresh), then drop in this host's binary.
+  fs.rmSync(installDir, { recursive: true, force: true });
+  fs.mkdirSync(installDir, { recursive: true });
+
+  const PLUGIN_PARTS = [
+    '.claude-plugin',
+    'skills',
+    'hooks',
+    'statusline',
+    'settings.json',
+    'README.md',
+    'LICENSE',
+  ];
+  for (const part of PLUGIN_PARTS) {
+    const src = path.join(PKG_ROOT, part);
+    if (fs.existsSync(src)) copyTree(src, path.join(installDir, part));
+  }
+  // bin/: copy only the resolver wrapper, never any prebuilt tokelang-cli-<os>-<arch>.
+  copyTree(path.join(PKG_ROOT, 'bin'), binDir, (f) => path.basename(f) === 'tokelang-cli');
+
+  // 3) The downloaded/local binary for THIS host.
+  fs.mkdirSync(binDir, { recursive: true });
+  fs.writeFileSync(binDest, binBuf);
+  fs.chmodSync(binDest, 0o755);
+
+  console.log(`\n✓ Installed tokelang@skills-dir → ${installDir}`);
+  console.log('\nNext:');
+  console.log('  • Restart Claude Code (or run /reload-plugins) to activate it.');
+  console.log('  • Verify:  claude plugin list   (look for tokelang@skills-dir)');
+  console.log('  • Disable: claude plugin disable tokelang@skills-dir   (or delete the folder)');
+  console.log('\nOptional — per-prompt INPUT compression (non-interactive):');
+  console.log(`  alias claude='${binDest.replace(artifact, 'tokelang-cli')} wrap claude'`);
+}
+
+main().catch((e) => fail(e && e.message ? e.message : String(e)));

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@tokelang-lite/claude-code-skill",
+  "version": "1.0.0",
+  "description": "NPX installer for the Tokelang Claude Code plugin: downloads the matching static tokelang-cli binary and installs the plugin (skills + hooks + statusline) as a personal skills-directory plugin. Compresses context files and subagent prompts locally before they reach the model. Apache 2.0.",
+  "homepage": "https://tokelang.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tokelang/claude-code-skill"
+  },
+  "license": "Apache-2.0",
+  "author": "Tokelang",
+  "type": "commonjs",
+  "bin": {
+    "tokelang-install": "install/install.js"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "scripts": {
+    "test": "node install/install.js --dry-run"
+  },
+  "files": [
+    ".claude-plugin/",
+    "skills/",
+    "hooks/",
+    "statusline/",
+    "bin/tokelang-cli",
+    "settings.json",
+    "install/",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "claude-code",
+    "plugin",
+    "tokens",
+    "compression",
+    "prompt-engineering",
+    "cost-reduction"
+  ]
+}

package/settings.json

@@ -0,0 +1,13 @@
+{
+  "tokelang.level": "2",
+  "tokelang.custom": {
+    "subagent_input": true,
+    "subagent_input.depth": "lite",
+    "subagent_input.min_chars": 200,
+    "output_style": "lite"
+  },
+  "statusLine": {
+    "command": "${CLAUDE_PLUGIN_ROOT}/statusline/savings.sh"
+  },
+  "_comment": "Default install ships at level 2 (Balanced) per v1.0.0 build plan (Option B revision 2026-06-01). Level 2 enables subagent (Task tool) input compression + lite output style guide. NOTE: Claude Code's plugin hook contract does NOT allow user-input compression — for that, use `alias claude='tokelang-cli wrap claude'` separately. To turn the skill off entirely: set tokelang.level to 'off'. To uninstall: claude plugin uninstall tokelang. The .custom block is only used when tokelang.level is 'custom'."
+}

package/skills/tokelang/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: tokelang
+description: >
+  Compress your context files, your subagent invocations, and your model's responses
+  via a style guide. Controlled by a level dial (L1 / L2 / L3) plus a semantic validator
+  that refuses to compress when meaning would be lost.
+  For real input compression (every prompt you type), use the separate `tokelang-cli wrap`
+  alias — Claude Code's plugin hooks cannot rewrite user input directly.
+  Open source under Apache 2.0. Auto-activates on session start. Disable: /tokelang-level off
+---
+
+# Tokelang for Claude Code
+
+This skill compresses tokens at three points where Claude Code's plugin hooks make it possible:
+
+1. **Context files** — your `CLAUDE.md`, agent personas, RAG headers (one-shot via `/tokelang-compress <file>`)
+2. **Subagent invocations** — the prompt argument passed to the `Task` tool gets compressed before the subagent receives it (PreToolUse hook)
+3. **Output style** — system-context injection at session start nudges the model to respond briefly (SessionStart hook)
+
+For **user-input compression** (compressing every prompt you type), use the separate `tokelang-cli wrap` command — Claude Code's plugin hook contract is additive only and cannot rewrite user input. See the README "Wrap mode for real input compression" section for setup.
+
+## Why compress at all
+
+Compressed prompts don't just save money. They make the model **think better**. From Hakim 2026 ([arXiv:2604.00025](https://arxiv.org/abs/2604.00025), "Brevity Constraints Reverse Performance Hierarchies in Language Models"):
+
+> "Constraining large models to produce brief responses improves accuracy by 26 percentage points and reduces performance gaps by up to two-thirds. Most critically, brevity constraints completely reverse performance hierarchies on mathematical reasoning and scientific knowledge benchmarks."
+
+The verbose English you usually write masks the model's reasoning capacity. Compression strips the parsing tax. We give you that compression automatically, with a validator that refuses to drop semantic content.
+
+## The level dial — what's ON by default
+
+You install Tokelang at **Level 2 (Balanced)**. The skill side does this automatically:
+
+| Surface | Level 2 behavior |
+|---|---|
+| Context files | Untouched until you run `/tokelang-compress <file>` |
+| Subagent inputs (Task tool prompt) | Compressed automatically every Task invocation |
+| Output style | Lite — "be concise, drop hedges and filler" injected into system context |
+| **User input** | **Not touched by the skill.** Use `tokelang-cli wrap` for that. |
+
+If even the output-style nudge feels too aggressive, dial back:
+
+```
+/tokelang-level 1     → output style guide only; subagent compression off
+/tokelang-level off   → skill stays loaded but does nothing
+/tokelang-level 3     → + aggressive output style
+```
+
+The setting persists across sessions in `~/.claude/settings.json` under `"tokelang.level"`.
+
+## Persistence
+
+Active every response unless you say "stop tokelang" or run `/tokelang-level off`. The skill does not "drift off" after many turns and will not silently disable itself.
+
+The engine runs locally — your prompts do NOT leave your machine. The hosted API at tokelang.com is a separate product (used by the dashboard); the CLI bundled with this skill is fully offline-capable.
+
+## Validator — why nothing important gets dropped
+
+Every compression candidate (file compression OR subagent input) passes through a semantic validator before replacing the original. The validator checks:
+
+- **Content recall** — 0.85 minimum for context files, 0.90 minimum for subagent inputs (subagents are higher-stakes than per-turn prompts)
+- **Hard zones** — negations (`not`, `never`, `only`), numeric thresholds, code blocks, URLs, file paths, regex literals, quoted strings, contract vocabulary (`shall`, `must`) — never rewritten
+
+If the validator rejects a candidate, the original passes through unchanged. **Tokelang never compresses past what the model can still reason about.**
+
+## Slash commands
+
+| Command | What it does |
+|---|---|
+| `/tokelang-compress <file>` | Compress a context file (CLAUDE.md, agent persona, etc.) with `.original.md` backup. Reversible via `/tokelang-restore`. |
+| `/tokelang-restore <file>` | Restore a compressed file from its `.original.md` backup. |
+| `/tokelang-stats` | Show savings for current session: tokens saved, % reduction, equivalent $ cost. |
+| `/tokelang-level [1\|2\|3\|off]` | Change compression aggressiveness. |
+
+## What this skill will NOT do
+
+- **Compress your typed input via plugin** — Claude Code's UserPromptSubmit hook is additive-only. For real input compression, use `tokelang-cli wrap` alias (one line of shell config; see README).
+- **Compress tool results** — Claude Code's PostToolUse hook is additive-only. Tool results pass through to the next turn as-is.
+- **Touch your output text** — the model speaks however it wants; we only nudge via style guide. No post-processing.
+- **Compress sensitive content** — Task subagent prompts that look like security warnings, credentials, or irreversible actions auto-skip compression (escape hatch).
+- **Hide what it's doing** — `/tokelang-stats` always tells you exactly what's been compressed and by how much. Statusline shows cumulative savings.
+- **Phone home** — engine runs locally. Nothing sent to tokelang.com unless you explicitly use the hosted API.
+
+## Off-switch summary (so you can always disable)
+
+Quickest: type `/tokelang-level off` in any session.
+Persistent: edit `~/.claude/settings.json`, set `"tokelang.level": "off"`.
+Uninstall: `claude plugin uninstall tokelang`.
+
+There is no telemetry. There is no usage limit. The skill is yours to use, modify, or fork (Apache 2.0).

package/skills/tokelang-compress/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: tokelang-compress
+description: >
+  Compress a context file (CLAUDE.md, .cursorrules, agent persona, RAG header, etc.) in
+  place with an automatic .original.md backup. Uses the local Tokelang engine (OptA→MEC)
+  in default mode for code-dense instruction docs; validator-gated, with negations and
+  protected spans preserved. Reversible via /tokelang-restore.
+  Trigger: /tokelang-compress <filepath>
+---
+
+# Compress a context file
+
+Compresses a context file with the local engine's **default mode (the OptA→MEC chain)**. Config/instruction files (CLAUDE.md, `.cursorrules`, agent personas) are *code-dense*, and the engine's `context_file` mode passes them through at near-0% — so this command uses `default`, which compresses them ~17–31% while the validator preserves negations, numbers, code, URLs, and other protected spans. (`--mode context_file` is the right choice only for *prose-heavy* system prompts / RAG headers, where its higher recall floor applies without no-opping.)
+
+The original file is preserved as `<filename>.original.md` in the same directory. You can revert any time via `/tokelang-restore <filepath>`.
+
+## Trigger
+
+- `/tokelang-compress <filepath>` — explicit
+- "compress my CLAUDE.md" — natural language
+- "shrink this context file" — natural language
+
+## Process
+
+1. Verify the file exists and is a supported type (`.md`, `.txt`, `.rst`, or extensionless markdown). Code/config files (`.json`, `.yaml`, `.toml`, `.py`, `.rs`) are explicitly rejected — wrong target for context compression.
+
+2. Read the file and check size. Files <500 chars are usually not worth compressing; warn and ask before proceeding.
+
+3. Run the local Tokelang binary in default mode (OptA→MEC):
+   ```bash
+   "${CLAUDE_PLUGIN_ROOT}/bin/tokelang-cli" compress --mode default < <filepath>
+   ```
+   (For a prose-heavy system-prompt file rather than a code-dense instruction doc, use `--mode context_file` instead.)
+
+4. The engine is validator-gated: it returns the compressed form only when the content-recall floor holds and every protected span survives — negations, numbers, fenced code (byte-identical), URLs, inline code, contract vocab. If any check fails, the engine passes the **original through unchanged**, so a rejected compression simply yields the original file, never a lossy one.
+
+5. Write the compressed version over the original file. Save the original as `<filename>.original.md` (a Claude Code marker file — do not edit by hand).
+
+6. Print a summary:
+   ```
+   Compressed CLAUDE.md
+   Before: 1,247 tokens (cl100k_base)
+   After:  812 tokens
+   Saved:  435 tokens (35%)
+   Backup: CLAUDE.md.original.md
+   ```
+
+## What this command does NOT do
+
+- Compress code files (use file type guard; rejects `.json`, `.yaml`, `.toml`, etc.)
+- Auto-compress without user-initiated trigger
+- Modify the file in any way other than running it through the engine
+- Send file contents to the hosted API (local engine only)
+
+## Failure modes (and how the tool handles them)
+
+| Situation | Behavior |
+|---|---|
+| File doesn't exist | Error: print path and abort |
+| File is wrong type | Error: explain that context_file mode is for prose, suggest manual editing |
+| File <500 chars | Warn + ask confirmation; small files yield small savings |
+| Validator rejects compression | Print the failed invariant; leave original file untouched; suggest user review |
+| `.original.md` already exists | Ask whether to overwrite the existing backup |
+
+## Example
+
+```
+> /tokelang-compress CLAUDE.md
+
+Reading CLAUDE.md... 1247 cl100k tokens.
+Compressing in context_file mode...
+Validator: recall 0.91 ✓ | headings 7/7 ✓ | code blocks 3/3 ✓ | URLs 4/4 ✓
+Writing compressed file (812 tokens).
+Backup saved to CLAUDE.md.original.md.
+
+Saved 435 tokens (35%). Restore with: /tokelang-restore CLAUDE.md
+```

package/skills/tokelang-level/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: tokelang-level
+description: >
+  Change Tokelang's compression aggressiveness. L1 = output style guide only. L2 = + Task
+  subagent prompt compression (default on install). L3 = + aggressive output style.
+  "off" = skill loaded but inert. Setting persists in ~/.claude/settings.json.
+  For user-input compression (every prompt you type), use the separate `tokelang-cli wrap`
+  command — see README. Trigger: /tokelang-level [1|2|3|off]
+---
+
+# Change compression level
+
+Switch between four preset compression levels. Setting persists across sessions in `~/.claude/settings.json` under `"tokelang.level"`.
+
+## Trigger
+
+- `/tokelang-level [1|2|3|off]` — explicit
+- `/tokelang-level` (no arg) — show current level + describe each
+- "turn tokelang down" / "be less aggressive" — natural language (interpret as one step down)
+- "disable tokelang" / "turn it off" — natural language → set to off
+
+## Level matrix (revised 2026-06-01 for Option B)
+
+| Level | Context files (slash cmd) | Subagent inputs (Task tool) | Output style guide |
+|---|---|---|---|
+| **L1** Safe | via `/tokelang-compress` | **off** | "lite" — be concise |
+| **L2** Balanced (default install) | via `/tokelang-compress` | **on**, lite depth | "lite" — be concise |
+| **L3** Aggressive | via `/tokelang-compress` | **on**, medium depth | "medium" — fragments OK, drop articles |
+| **off** | via `/tokelang-compress` | **off** | **off** (no style guide injection) |
+
+Note: `/tokelang-compress` works at every level (it's user-initiated). Level only controls the *automatic* hooks (SessionStart style guide + PreToolUse Task compression).
+
+**For real user-input compression**, you need `tokelang-cli wrap claude` as an alias. This is outside the skill's level dial. See README "Wrap mode" section.
+
+## Process
+
+1. Parse argument. Accept `1`, `2`, `3`, `off` (case-insensitive). Other input → print usage.
+2. Read `~/.claude/settings.json`. If `"tokelang"` block missing, create it.
+3. Set `"tokelang.level"`. Save settings.
+4. Confirm:
+   ```
+   Tokelang level changed: 2 (Balanced) → 1 (Safe).
+   Subagent compression: OFF
+   Output style guide: lite (be concise)
+   Context-file compression: still available via /tokelang-compress
+   ```
+5. Hook scripts read this setting on every fire — change takes effect on the next Task invocation. No restart needed.
+
+## Custom level (advanced)
+
+`~/.claude/settings.json` supports per-dial overrides via a `tokelang.custom` object. Example:
+
+```json
+{
+  "tokelang.level": "custom",
+  "tokelang.custom": {
+    "subagent_input": true,
+    "subagent_input.depth": "medium",
+    "output_style": "lite"
+  }
+}
+```
+
+When `"tokelang.level": "custom"`, the dials in `custom` are used directly.
+
+## Off semantics
+
+`"tokelang.level": "off"` keeps the skill loaded (slash commands still work, statusline still shows lifetime stats) but the hooks become no-ops. No subagent compression, no style-guide injection. Use this for sessions where you want Tokelang fully dormant without uninstalling.
+
+To uninstall completely: `claude plugin uninstall tokelang`.
+
+## Example
+
+```
+> /tokelang-level
+
+Current: 2 (Balanced)
+  Subagent compression:   ON (lite depth)
+  Output style guide:     lite (be concise)
+
+Levels:
+  1 / Safe       — output style only; subagent compression off
+  2 / Balanced   — + subagent compression (DEFAULT)
+  3 / Aggressive — + medium-depth subagent + aggressive output style
+  off            — skill loaded but inert; hooks are no-ops
+
+For input compression (every prompt you type):
+  alias claude='tokelang-cli wrap claude'
+
+Switch with: /tokelang-level <1|2|3|off|custom>
+```

package/skills/tokelang-restore/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: tokelang-restore
+description: >
+  Restore a context file from its .original.md backup created by /tokelang-compress.
+  Reverses any compression performed on the file.
+  Trigger: /tokelang-restore <filepath>
+---
+
+# Restore a compressed file
+
+Reverses `/tokelang-compress` by replacing the compressed file with its `.original.md` backup. The backup file is deleted after successful restoration.
+
+## Trigger
+
+- `/tokelang-restore <filepath>` — explicit
+- "undo tokelang on CLAUDE.md" — natural language
+- "restore the original" (only if context makes the target file unambiguous) — natural language
+
+## Process
+
+1. Verify `<filepath>.original.md` exists. If not, abort with: "No backup found for <filepath>. Was this file compressed by Tokelang?"
+
+2. Verify `<filepath>` exists and was compressed (we expect a marker comment at the top of compressed files — TBD format).
+
+3. Replace `<filepath>` with the contents of `<filepath>.original.md`.
+
+4. Delete `<filepath>.original.md` after successful copy.
+
+5. Print confirmation:
+   ```
+   Restored CLAUDE.md from CLAUDE.md.original.md.
+   Backup deleted.
+   ```
+
+## What this command does NOT do
+
+- Restore from arbitrary backups (only `.original.md` siblings)
+- Restore files that were never compressed by Tokelang
+- Auto-trigger when the model touches a compressed file (user must invoke)
+
+## Failure modes
+
+| Situation | Behavior |
+|---|---|
+| No `.original.md` backup exists | Error: explain and abort |
+| File doesn't show our compression marker | Warn: "This file may not have been compressed by Tokelang. Restore anyway? (y/n)" |
+| Backup older than compressed file (modified-after-compression) | Warn: "You may have edited the compressed version since. Restore will lose your edits. Proceed? (y/n)" |
+| Backup file is empty | Error: backup looks corrupted; abort |
+
+## Example
+
+```
+> /tokelang-restore CLAUDE.md
+
+Restored CLAUDE.md (1247 cl100k tokens) from CLAUDE.md.original.md.
+Backup deleted.
+```