dsh-caveman 0.1.0

package/THIRD_PARTY_NOTICES

@@ -0,0 +1,37 @@
+Third-party notices for dsh-caveman
+====================================
+
+This package bundles skills under `skills/`. Their provenance:
+
+- `skills/caveman-*` (caveman, caveman-commit, caveman-compress,
+  caveman-help, caveman-review, caveman-stats): derived from / inspired by
+  the open-source caveman toolkit
+  (https://github.com/JuliusBrussee/caveman), which declares an MIT license
+  ("this MIT license covers this repo"). The Python scripts under
+  `skills/caveman-compress/scripts/` are covered by that MIT declaration.
+  Redistributed under MIT with gratitude to the original author.
+
+- `skills/cavecrew`: original work of this package's authors.
+
+MIT License
+-----------
+
+Copyright (c) 2026 dsh-caveman contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cordis.patch.yml

@@ -0,0 +1,5 @@
+# dsh-caveman bundle patch: one host row (mode state, command, prompt section);
+# the client half is served through the dsh.client declaration in package.json.
+- insert:
+    - id: caveman
+      name: dsh-caveman

package/lib/client.js

@@ -0,0 +1,71 @@
+window.__ModuleLoader__.load({
+  id: "dsh-caveman",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+    Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+    const React = require("react");
+
+    // Badge display is centralized in dsh-badges: this plugin only registers
+    // a badge descriptor (projection key + pure appearance renderer). The
+    // renderer maps the 'caveman' projection value to badge appearance, or
+    // null when the mode is off. Functionality (projection unit, /caveman
+    // command, prompt-section injection) lives in the host half.
+    const inject = ["slots"];
+
+    function apply(ctx) {
+      // The badge registry is provided by dsh-badges. Bundle activation order
+      // is not guaranteed (no inject edge), so registering inside the dock
+      // slots.inject callback can still race it. Retry with a growing backoff
+      // until the registry appears (idempotent: registry.register is a Map
+      // set). Stops after ~2 minutes; a missing registry only costs a badge.
+      const register = () => {
+        const registry = ctx.get("badgeRegistry");
+        if (registry === undefined) return false;
+        registry.register({
+          key: "caveman",
+          projection: "caveman",
+          title: "Click to cycle caveman mode: off -> lite -> full -> ultra",
+          onClick: (sessionId) => {
+            if (!sessionId) return;
+            try {
+              fetch("/caveman/toggle", {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ sessionId }),
+              }).catch(() => {});
+            } catch (e) {
+              /* fetch unavailable: no-op */
+            }
+          },
+          render: (value) => {
+            const mode = value && typeof value === "object" ? value.mode : undefined;
+            const on = mode && mode !== "off";
+            const label = !on
+              ? "[CAVEMAN:OFF]"
+              : mode === "full"
+                ? "[CAVEMAN]"
+                : "[CAVEMAN:" + mode.toUpperCase() + "]";
+            return on
+              ? { label, color: "#d97706", bg: "rgba(217,119,6,.14)" }
+              : { label, color: "#6b7280", bg: "rgba(107,114,128,.12)" };
+          },
+        });
+        return true;
+      };
+      const tryRegister = (delayMs) => {
+        if (register()) return;
+        if (typeof setTimeout !== "function" || delayMs > 15000) return;
+        setTimeout(() => tryRegister(delayMs * 2), delayMs);
+      };
+      ctx.slots.inject("conversation.input.dock", () => {
+        if (register()) return;
+        Promise.resolve().then(() => tryRegister(500));
+      });
+    }
+
+    exports.apply = apply;
+    exports.inject = inject;
+    return module.exports;
+  },
+});

package/lib/index.js

@@ -0,0 +1,193 @@
+// dsh-caveman: per-session caveman communication mode.
+// - sessionProjections unit 'caveman' folds `caveman/change` session events
+//   (default 'full'; per-session by construction, no cross-agent sharing)
+// - /caveman command and plain-text "caveman <mode>" directive (agent/pre-step)
+//   append the change event; directive-only user messages are consumed
+// - system-prompt section injects the current mode as an overriding directive
+// - composer dock badge (client half, lib/client.js) renders via
+//   useProjection('caveman')
+//
+// OUT-OF-REPO EVENT VOCABULARY:
+// `caveman/change` is not in the harness's static KNOWN_SESSION_EVENT_TYPES
+// (generated in @deepseek-ai/dsh-session), so a session log containing it is
+// refused on load unless the type is registered or the event carries
+// `ignorable: true` (append() cannot set that flag). We register the type at
+// apply() time on the SAME module instance the persistence loader imports
+// (both resolve to <workspace>/node_modules/@deepseek-ai/dsh-session), so
+// every boot WITH this plugin can read back its events. Logs written before
+// this fix were repaired in place by .dsh/scripts/repair-caveman-events.py /
+// fix-d8b43aa8.py (ignorable: true injected, 2-frame zstd layout).
+import { z } from 'zod'
+import { KNOWN_SESSION_EVENT_TYPES } from '@deepseek-ai/dsh-session'
+
+export const name = 'caveman'
+// Hard dependency on the HTTP route registry for the badge-click toggle
+// route (same rationale as dsh-rtk's inject).
+export const inject = ['webServer']
+
+const VALID = ['off', 'lite', 'full', 'ultra', 'wenyan-lite', 'wenyan-full', 'wenyan-ultra']
+const DIRECTIVE_RE = /^\/?caveman\s+(off|lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra)$/i
+const OFF_RE = /^(stop\s+caveman|normal\s+mode)$/i
+
+const schema = z.object({ mode: z.enum(VALID) })
+
+function parseDirective(text) {
+  if (typeof text !== 'string') return null
+  const t = text.trim()
+  const m = DIRECTIVE_RE.exec(t)
+  if (m) return m[1].toLowerCase()
+  if (OFF_RE.test(t)) return 'off'
+  return null
+}
+
+function directiveOf(message) {
+  const blocks = message && message.content
+  if (!Array.isArray(blocks) || blocks.length === 0) return null
+  for (const b of blocks) {
+    if (!b || typeof b !== 'object' || b.type !== 'text') return null
+  }
+  return parseDirective(blocks.map((b) => b.text).join(''))
+}
+
+export function apply(ctx) {
+  // Register our event type on the shared KNOWN set so session logs
+  // containing `caveman/change` load in any boot that mounts this plugin.
+  try {
+    KNOWN_SESSION_EVENT_TYPES.add('caveman/change')
+  } catch (err) {
+    console.warn('[caveman] could not register event type:', err && err.message)
+  }
+
+  const projections = ctx.get('sessionProjections')
+
+  if (projections !== undefined) {
+    projections.register({
+      key: 'caveman',
+      schema,
+      stateVersion: 1,
+      init: () => ({ mode: 'full' }),
+      apply: (state, event) => {
+        if (!event || event.type !== 'caveman/change') return state
+        const mode = event.data && typeof event.data.mode === 'string' ? event.data.mode : ''
+        if (!VALID.includes(mode) || state.mode === mode) return state
+        return { mode }
+      },
+      view: (state) => ({ mode: state.mode }),
+    })
+  }
+
+  const commands = ctx.get('commands')
+  if (commands !== undefined) {
+    commands.register({
+      name: 'caveman',
+      description: 'Set caveman communication mode',
+      input: { hint: 'lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra|off' },
+      handler: (invocation) => {
+        const mode = invocation.rawInput.trim().toLowerCase()
+        if (!VALID.includes(mode)) {
+          return { kind: 'error', text: 'Invalid mode: "' + invocation.rawInput.trim() + '". Valid: ' + VALID.join('|') }
+        }
+        invocation.agent.session.append('caveman/change', { mode })
+        return { kind: 'success', text: mode === 'off' ? 'Caveman mode: off' : 'Caveman mode: ' + mode }
+      },
+    })
+  }
+
+  ctx.on('agent/pre-step', (payload, next) => {
+    if (!payload || !payload.agent || !Array.isArray(payload.messages)) return next()
+    let mode = null
+    const kept = []
+    for (const m of payload.messages) {
+      const parsed = directiveOf(m)
+      if (parsed !== null) mode = parsed
+      else kept.push(m)
+    }
+    if (mode === null) return next()
+    payload.agent.session.append('caveman/change', { mode })
+    if (kept.length === 0) return { kind: 'reject' }
+    return { kind: 'enter', messages: kept }
+  })
+
+  // ---- badge click toggle: POST /caveman/toggle { sessionId } -------------
+  // The composer badge's onClick cycles the mode off -> lite -> full -> ultra
+  // -> off through the same caveman/change event path as /caveman on|off, so
+  // UI, projection, and prompt-section all agree via the session log.
+  const CYCLE = ['off', 'lite', 'full', 'ultra']
+  const webServer = ctx.get('webServer')
+  if (webServer !== undefined) {
+    try {
+      webServer.register({
+      kind: 'exact',
+      path: '/caveman/toggle',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') {
+          res.writeHead(405)
+          res.end()
+          return
+        }
+        let raw = ''
+        try {
+          for await (const chunk of req) raw += chunk
+        } catch (e) {
+          res.writeHead(400)
+          res.end(JSON.stringify({ ok: false, error: 'bad body' }))
+          return
+        }
+        let sessionId
+        try {
+          sessionId = JSON.parse(raw || '{}').sessionId
+        } catch (e) {
+          sessionId = undefined
+        }
+        const store = ctx.get('sessions')
+        const session = typeof sessionId === 'string' && store !== undefined ? store.get(sessionId) : undefined
+        if (session === undefined) {
+          res.writeHead(404)
+          res.end(JSON.stringify({ ok: false, error: 'session not found' }))
+          return
+        }
+        let mode = 'full'
+        if (projections !== undefined) {
+          try {
+            const value = projections.snapshot(session).values.caveman
+            if (value && typeof value.mode === 'string') mode = value.mode
+          } catch (e) {
+            mode = 'full'
+          }
+        }
+        const at = CYCLE.indexOf(mode)
+        const next = CYCLE[(at === -1 ? 0 : at) + 1] === undefined ? CYCLE[0] : CYCLE[at + 1]
+        session.append('caveman/change', { mode: next })
+        res.writeHead(200, { 'content-type': 'application/json' })
+        res.end(JSON.stringify({ ok: true, mode: next }))
+      },
+      })
+    } catch (e) {
+      console.error('[caveman] /caveman/toggle route registration failed:', e && e.message)
+    }
+  }
+
+  const systemPrompt = ctx.get('systemPrompt')
+  if (systemPrompt !== undefined) {
+    systemPrompt.section({
+      name: 'caveman-mode',
+      order: 50,
+      text: (context) => {
+        const agent = context && context.agent
+        if (!agent || projections === undefined) return ''
+        let mode = 'full'
+        try {
+          const value = projections.snapshot(agent.session).values.caveman
+          if (value && typeof value.mode === 'string') mode = value.mode
+        } catch (err) {
+          mode = 'full'
+        }
+        if (mode === 'off') return ''
+        const tag = mode === 'full' ? '[CAVEMAN]' : '[CAVEMAN:' + mode.toUpperCase() + ']'
+        return tag + ' Current user-set communication style. Follow the caveman skill rules at intensity "' + mode + '" for every response; this overrides any default in AGENTS.md.'
+      },
+    })
+  }
+
+  console.log('[caveman] host active (event projection + KNOWN registration)')
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "dsh-caveman",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "description": "Per-session caveman mode state (session projection unit) + composer dock badge + /caveman command + prompt-section injection. Ships the caveman family skills.",
+  "license": "MIT",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "plugin",
+    "caveman",
+    "compression",
+    "token",
+    "cordis"
+  ],
+  "files": [
+    "lib",
+    "skills",
+    "cordis.patch.yml",
+    "THIRD_PARTY_NOTICES"
+  ],
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": []
+    }
+  }
+}

package/skills/cavecrew/README.md

@@ -0,0 +1,61 @@
+# cavecrew
+
+Decision guide. When to delegate to caveman subagents instead of doing the work inline.
+
+## What it does
+
+Tells the main thread when to spawn a caveman-style subagent versus the vanilla equivalent. The win: subagent tool-results inject back into main context verbatim, and caveman output is roughly 1/3 the size of vanilla prose. Across 20 delegations in one session, that is the difference between context exhaustion and finishing the task.
+
+Three subagents:
+
+| Subagent | Job | Use when |
+|----------|-----|----------|
+| `cavecrew-investigator` | Locate code (read-only) | "Where is X defined / what calls Y / list uses of Z" |
+| `cavecrew-builder` | Surgical edit, 1-2 files | Scope is obvious, ≤2 files. Refuses 3+ file scope. |
+| `cavecrew-reviewer` | Diff/file review | One-line findings with severity emoji |
+
+Use vanilla `Explore` or `Code Reviewer` when you want prose, architecture commentary, or rationale. Use main thread directly for one-line answers and 3+ file refactors.
+
+This skill is a decision guide, not a slash command. It activates when the conversation mentions delegation.
+
+## How to invoke
+
+Triggers on phrases like "delegate to subagent", "use cavecrew", "spawn investigator", "save context", "compressed agent output".
+
+## Example chaining
+
+Locate → fix → verify (most common):
+
+1. `cavecrew-investigator` returns site list (`path:line — symbol — note`)
+2. Main thread picks 1-2 sites, hands paths to `cavecrew-builder`
+3. `cavecrew-reviewer` audits the resulting diff
+
+Parallel scout: spawn 2-3 `cavecrew-investigator` calls in one message with different angles (defs, callers, tests). Aggregate in main.
+
+## Model overrides
+
+By default, `cavecrew-reviewer` and `cavecrew-investigator` pin `model: haiku` in their frontmatter; `cavecrew-builder` has no `model:` line (uses the API session default). Set env vars in your shell before launching Claude Code to override per-agent:
+
+| Env var | Agent |
+|---|---|
+| `CAVECREW_REVIEWER_MODEL` | `cavecrew-reviewer` |
+| `CAVECREW_BUILDER_MODEL` | `cavecrew-builder` |
+| `CAVECREW_INVESTIGATOR_MODEL` | `cavecrew-investigator` |
+
+Example — run reviewer on sonnet, keep others on default:
+
+```sh
+export CAVECREW_REVIEWER_MODEL=sonnet
+```
+
+Use the same model name strings you'd use in any Claude Code agent frontmatter (e.g. `haiku`, `sonnet`, `opus`).
+
+Overrides patch only the `model:` line in the installed agent's frontmatter; the prompt body is untouched and keeps receiving upstream updates. Plugin installs only — standalone hook installs have no local agent files to patch. Unset or blank = no change. The patch persists in the installed file until the plugin is updated or reinstalled.
+
+## See also
+
+- [`SKILL.md`](./SKILL.md) — full decision matrix and output contracts
+- [`agents/cavecrew-investigator.md`](../../agents/cavecrew-investigator.md)
+- [`agents/cavecrew-builder.md`](../../agents/cavecrew-builder.md)
+- [`agents/cavecrew-reviewer.md`](../../agents/cavecrew-reviewer.md)
+- [Caveman README](../../README.md) — repo overview

package/skills/cavecrew/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: cavecrew
+description: >
+  Decision guide for delegating to caveman-style subagents. Tells the main
+  thread WHEN to spawn `cavecrew-investigator` (locate code), `cavecrew-builder`
+  (1-2 file edit), or `cavecrew-reviewer` (diff review) instead of doing the
+  work inline or using vanilla `Explore`. Subagent output is caveman-compressed
+  so the tool-result injected back into main context is ~60% smaller — main
+  context lasts longer across long sessions.
+  Trigger: "delegate to subagent", "use cavecrew", "spawn investigator/builder/reviewer",
+  "save context", "compressed agent output".
+---
+
+Cavecrew = three subagent presets that emit caveman output. Same job as Anthropic defaults (`Explore`, edit-style agents, reviewer); difference is the tool-result they return is compressed, so main context shrinks per delegation.
+
+## When to use cavecrew vs alternatives
+
+| Task | Use |
+|---|---|
+| "Where is X defined / what calls Y / list uses of Z" | `cavecrew-investigator` |
+| Same but you also want suggestions/architecture commentary | `Explore` (vanilla) |
+| Surgical edit, ≤2 files, scope obvious | `cavecrew-builder` |
+| New feature / 3+ files / cross-cutting refactor | Main thread or `feature-dev:code-architect` |
+| Review diff, branch, or file for bugs | `cavecrew-reviewer` |
+| Deep code review with rationale + alternatives | `Code Reviewer` (vanilla) |
+| One-line answer you already know | Main thread, no subagent |
+
+Rule of thumb: **if you'd want the subagent's output in 1/3 the tokens, pick cavecrew. If you'd want prose, pick vanilla.**
+
+## Why this exists (the real win)
+
+Subagent tool results get injected into main context verbatim. A vanilla `Explore` that returns 2k tokens of prose costs 2k tokens of main-context budget every time. The same finding from `cavecrew-investigator` returns ~700 tokens. Across 20 delegations in one session that's the difference between context exhaustion and finishing the task.
+
+## Output contracts
+
+What main thread can rely on per agent:
+
+**`cavecrew-investigator`**
+```
+<Header>:
+- path:line — `symbol` — short note
+totals: <counts>.
+```
+Or `No match.` Always file-path-first, line-number-attached, backticked symbols. Safe to grep with `path:\d+`.
+
+**`cavecrew-builder`**
+```
+<path:line-range> — <change ≤10 words>.
+verified: <re-read OK | mismatch @ path:line>.
+```
+Or one of: `too-big.` / `needs-confirm.` / `ambiguous.` / `regressed.` (terminal first token).
+
+**`cavecrew-reviewer`**
+```
+path:line: <emoji> <severity>: <problem>. <fix>.
+totals: N🔴 N🟡 N🔵 N❓
+```
+Or `No issues.` Findings sorted file → line ascending.
+
+## Chaining patterns
+
+**Locate → fix → verify** (most common):
+1. `cavecrew-investigator` returns site list.
+2. Main thread picks 1-2 sites, hands paths to `cavecrew-builder`.
+3. `cavecrew-reviewer` audits the diff.
+
+**Parallel scout** (when investigation is broad):
+Spawn 2-3 `cavecrew-investigator` calls in one message (different angles: defs vs callers vs tests). Aggregate in main thread.
+
+**Single-shot edit** (when site is already known):
+Skip investigator. Hand exact path:line to `cavecrew-builder` directly.
+
+## What NOT to do
+
+- Don't use `cavecrew-builder` when you don't already know the file. Spawn investigator first or main thread will eat tokens passing context.
+- Don't chain `cavecrew-investigator → cavecrew-builder` for a 5-file refactor. Builder will return `too-big.` and you'll have wasted a turn.
+- Don't ask `cavecrew-reviewer` for "general feedback" — it returns findings only, no architecture opinions. Use `Code Reviewer` for that.
+- Don't expect prose. Cavecrew output is structured, sometimes terse to the point of cryptic. If a human will read it directly, paraphrase.
+
+## Auto-clarity (inherited)
+
+Subagents drop caveman → normal English for security warnings, irreversible-action confirmations, and any output where fragment ambiguity could be misread. Resume caveman after.

package/skills/caveman/README.md

@@ -0,0 +1,48 @@
+# caveman
+
+Talk like smart caveman. Same brain, fewer tokens.
+
+## What it does
+
+Compress every model response to caveman-style prose. Drops articles, filler, pleasantries, and hedging. Keeps every technical detail, code block, error string, and symbol exact. Cuts 65% of output tokens (measured) with full accuracy preserved. Mode persists for the whole session until changed or stopped.
+
+Six intensity levels:
+
+| Level | What change |
+|-------|-------------|
+| `lite` | Drop filler/hedging. Sentences stay full. Professional but tight. |
+| `full` | Default. Drop articles, fragments OK, short synonyms. |
+| `ultra` | Bare fragments. Abbreviations (DB, auth, fn). Arrows for causality. |
+| `wenyan-lite` | Classical Chinese register, light compression. |
+| `wenyan-full` | Maximum 文言文. 80-90% character reduction. |
+| `wenyan-ultra` | Extreme classical compression. |
+
+Auto-clarity rule: caveman drops to normal prose for security warnings, irreversible-action confirmations, multi-step sequences where fragment ambiguity risks misread, and when user repeats a question. Resumes after the clear part.
+
+## How to invoke
+
+```
+/caveman              # full mode (default)
+/caveman lite         # lighter compression
+/caveman ultra        # extreme compression
+/caveman wenyan       # classical Chinese
+stop caveman          # back to normal prose
+```
+
+## Example output
+
+Question: "Why does my React component re-render?"
+
+Normal prose:
+> Your component re-renders because you create a new object reference each render. Wrapping it in `useMemo` will fix the issue.
+
+Caveman (full):
+> New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`.
+
+Caveman (ultra):
+> Inline obj prop → new ref → re-render. `useMemo`.
+
+## See also
+
+- [`SKILL.md`](./SKILL.md) — full LLM-facing instructions
+- [Caveman README](../../README.md) — repo overview, install, benchmarks

package/skills/caveman/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: caveman
+description: >
+  Ultra-compressed communication mode. Cuts output tokens 65% (measured) by speaking like caveman
+  while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra,
+  wenyan-lite, wenyan-full, wenyan-ultra.
+  Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens",
+  "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.
+---
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active if unsure. Off only: "stop caveman" / "normal mode".
+
+Default: **full**. Switch: `/caveman lite|full|ultra`.
+
+## Rules
+
+Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). No tool-call narration, no decorative tables/emoji, no dumping long raw error logs unless asked — quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations (cfg/impl/req/res/fn) — tokenizer split them same as full word: zero token saved, reader still decode. Full word cheaper AND clearer. No causal arrows (→) either — own token, save nothing. Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Preserve user's dominant language. User write Portuguese → reply Portuguese caveman. User write Spanish → reply Spanish caveman. Compress the style, not the language. No forced English openings or status phrases. ALWAYS keep technical terms, code, API names, CLI commands, commit-type keywords (feat/fix/...), and exact error strings verbatim — unless user explicitly ask for translation.
+
+No self-reference. Never name or announce the style. No "caveman mode on", "me caveman think", no third-person caveman tags. Output caveman-only — never normal answer plus "Caveman:" recap. Exception: user explicitly ask what the mode is.
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
+
+## Intensity
+
+| Level | What change |
+|-------|------------|
+| **lite** | No filler/hedging. Keep articles + full sentences. Professional but tight |
+| **full** | Drop articles, fragments OK, short synonyms. Classic caveman. No tool-call narration, no decorative tables/emoji, no long raw error-log dumps unless asked. Standard acronyms OK; no invented abbreviations |
+| **ultra** | Strip conjunctions when cause-then-effect stay unambiguous. One word when one word enough. State each fact once. NO prose abbreviations (cfg/impl/req/res/fn/auth), NO arrows (X → Y) — measured zero token saving under tokenizer, cost decode clarity. Code symbols, function names, API names, error strings: never touch |
+| **wenyan-lite** | Semi-classical. Drop filler/hedging but keep grammar structure, classical register |
+| **wenyan-full** | Maximum classical terseness. Fully 文言文. 80-90% character reduction. Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其) |
+| **wenyan-ultra** | Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse |
+
+Example — "Why React component re-render?"
+- lite: "Your component re-renders because you create a new object reference each render. Wrap it in `useMemo`."
+- full: "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
+- ultra: "Inline obj prop, new ref, re-render. `useMemo`."
+- wenyan-lite: "組件頻重繪，以每繪新生對象參照故。以 useMemo 包之。"
+- wenyan-full: "每繪新生對象參照，故重繪；以 useMemo 包之則免。"
+- wenyan-ultra: "新參照則重繪。useMemo 包之。"
+
+Example — "Explain database connection pooling."
+- lite: "Connection pooling reuses open connections instead of creating new ones per request. Avoids repeated handshake overhead."
+- full: "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
+- ultra: "Pool reuse open DB connections. No per-request handshake."
+- wenyan-full: "池蓄已開之連，不逐請而新開，省握手之費。"
+- wenyan-ultra: "池蓄連，免逐請新開，省握手。"
+
+## Auto-Clarity
+
+Drop caveman when:
+- Security warnings
+- Irreversible action confirmations
+- Multi-step sequences where fragment order or omitted conjunctions risk misread
+- Compression itself creates technical ambiguity (e.g., `"migrate table drop column backup first"` — order unclear without articles/conjunctions)
+- User asks to clarify or repeats question
+
+Resume caveman after clear part done.
+
+Example — destructive op:
+> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
+> ```sql
+> DROP TABLE users;
+> ```
+> Caveman resume. Verify backup exist first.
+
+## Boundaries
+
+Code/commits/PRs: write normal. "stop caveman" or "normal mode": revert. Level persist until changed or session end.

package/skills/caveman-commit/README.md

@@ -0,0 +1,44 @@
+# caveman-commit
+
+Terse Conventional Commits. Why over what.
+
+## What it does
+
+Generates commit messages in Conventional Commits format. Subject ≤50 chars, hard cap 72. Imperative mood. Body only when the *why* is non-obvious or there are breaking changes. No AI attribution, no "this commit does X", no emoji unless the project uses them. Body always required for breaking changes, security fixes, data migrations, and reverts — future debuggers need the context.
+
+Outputs only the message. Does not stage, commit, or amend.
+
+## How to invoke
+
+```
+/caveman-commit
+```
+
+Also triggers on phrases like "write a commit", "commit message", "generate commit".
+
+## Example output
+
+Diff: new endpoint for user profile.
+
+```
+feat(api): add GET /users/:id/profile
+
+Mobile client needs profile data without the full user payload
+to reduce LTE bandwidth on cold-launch screens.
+
+Closes #128
+```
+
+Diff: breaking API rename.
+
+```
+feat(api)!: rename /v1/orders to /v1/checkout
+
+BREAKING CHANGE: clients on /v1/orders must migrate to /v1/checkout
+before 2026-06-01. Old route returns 410 after that date.
+```
+
+## See also
+
+- [`SKILL.md`](./SKILL.md) — full LLM-facing instructions
+- [Caveman README](../../README.md) — repo overview