dijk-skills 1.0.0 → 1.0.1

package/README.md

@@ -1,193 +1,65 @@
 # dijk-skills
 
-AI 编码助手的 Skills 集合，遵循 [Agent Skills 规范](https://agentskills.io)。
+Skills collection CLI installer. Install curated skills to your AI agent workspace.
 
-支持 OpenCode、Claude Code、Codex、Cursor 等 70+ AI 编码助手。
-
-## 安装
-
-### 方式一：`npx skills`（推荐）
-
-使用 [vercel-labs/skills](https://github.com/vercel-labs/skills) 生态标准安装，无需发布：
+## Install
 
 ```bash
-# 从本地路径安装所有 skills
-npx skills add /path/to/dijk-skills --skill '*' -g -y
-
-# 安装到指定 agent
-npx skills add /path/to/dijk-skills -a opencode -g -y
-npx skills add /path/to/dijk-skills -a claude-code -g -y
-
-# 只安装某个 skill
-npx skills add /path/to/dijk-skills --skill darwin-skill -g -y
-
-# 预览可用 skills（不安装）
-npx skills add /path/to/dijk-skills --list
+npm install -g dijk-skills
+# or use directly via npx
 ```
 
-如果将此项目推送到独立 GitHub 仓库，还可以直接用仓库名安装：
+## Usage
 
 ```bash
-npx skills add your-username/dijk-skills -g -y
+npx dijk-skills install [options]
 ```
 
-### 方式二：`npx dijk-skills`
-
-通过自定义安装脚本，支持 `--dir` 自定义目标目录：
-
-```bash
-# 本地路径（无需发布）
-npx /path/to/dijk-skills
-
-# 指定目录
-npx /path/to/dijk-skills --dir ~/.config/opencode
-
-# 发布到 npm 后
-npx dijk-skills
-npx dijk-skills --dir ~/.config/opencode
-```
+### Options
 
-## 包含内容
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--modules <list>` | Comma-separated module names | `common` |
+| `--dir <path>` | Target installation directory | `~/.agents` |
 
-| Skill | 说明 |
-|-------|------|
-| `darwin-skill` | Skill 自主优化器，基于 SkillLens 9 维评估 |
-| `grilling` | 方案压力测试，三阶段递进追问 |
-| `humanizer-zh` | 去除中文文本 AI 生成痕迹 |
-| `i-have-adhd` | ADHD 友好输出模式 |
-| `skill-creator` | Skill 创建指南 |
+### Modules
 
-安装后位于：
+| Module | Skills |
+|--------|--------|
+| `common` | grilling, humanizer-zh, i-have-adhd |
+| `writing` | grill-my-proposal, vibe-insight |
+| `tools` | darwin-skill, skill-creator |
+| `coding` | *(empty, reserved for future skills)* |
 
-```
-~/.agents/skills/           # OpenCode / Amp / Codex
-~/.claude/skills/           # Claude Code
-# 取决于 --agent 参数
-├── darwin-skill/
-├── grilling/
-├── humanizer-zh/
-├── i-have-adhd/
-└── skill-creator/
-```
+> Installing any module automatically includes `common`.
 
-## 管理已安装的 skills
+### Examples
 
+Install common skills to default location:
 ```bash
-# 查看已安装
-npx skills list
-npx skills list -g              # 全局 skills
-npx skills list -a opencode     # 按 agent 过滤
-
-# 更新
-npx skills update
-
-# 卸载
-npx skills remove darwin-skill
-npx skills remove --all
+npx dijk-skills install
 ```
 
-## 目录结构
-
-```
-dijk-skills/
-├── skills/               # Skill 定义
-│   ├── darwin-skill/
-│   │   ├── SKILL.md
-│   │   ├── references/
-│   │   ├── templates/
-│   │   └── test-prompts.json
-│   ├── grilling/
-│   │   └── SKILL.md
-│   ├── humanizer-zh/
-│   │   └── SKILL.md
-│   ├── i-have-adhd/
-│   │   ├── SKILL.md
-│   │   └── agents/
-│   └── skill-creator/
-│       ├── SKILL.md
-│       ├── references/
-│       └── scripts/
-├── agents/               # Agent 定义（预留）
-├── commands/             # 自定义命令（预留）
-├── rules/                # 规则文件（预留）
-├── scripts/              # 辅助脚本（预留）
-├── workflows/            # 工作流定义（预留）
-├── bin/
-│   └── install.js        # 自定义安装脚本
-├── package.json
-└── .npmignore
-```
-
-## 开发
-
-### 环境要求
-
-- Node.js >= 18
-
-### 本地开发
-
+Install specific modules:
 ```bash
-git clone <repo-url>
-cd dijk-skills
-
-# 新建 Skill
-mkdir -p skills/my-new-skill
-# 编写 SKILL.md，必须包含 YAML frontmatter：
-# ---
-# name: my-new-skill
-# description: 一句话描述这个 skill 做什么
-# ---
-
-# 预览安装结果（不实际安装）
-npx skills add . --list
-
-# 测试安装到临时目录
-npx skills add . -a opencode -g --skill my-new-skill -y
-
-# 或使用自定义脚本
-node bin/install.js --dir /tmp/test-dijk
-```
-
-### 添加新 Skill
-
-每个 Skill 是一个独立目录，至少包含 `SKILL.md`：
-
-```
-skills/my-skill/
-├── SKILL.md              # 必需：Skill 主文件（含 YAML frontmatter）
-├── references/           # 可选：参考资料
-├── scripts/              # 可选：辅助脚本
-├── templates/            # 可选：模板文件
-└── agents/               # 可选：关联 Agent
+npx dijk-skills install --modules writing,tools
 ```
 
-`SKILL.md` 格式：
-
-```markdown
----
-name: my-skill
-description: 一句话描述这个 skill 的用途和触发条件
----
-
-这里写 skill 的详细指令...
+Custom target directory:
+```bash
+npx dijk-skills install --modules coding --dir ~/my-agents
 ```
 
-## 构建与发布
+## Installed Structure
 
-### 打包预览
+Skills are installed to `{dir}/skills/{skill-name}/`:
 
-```bash
-npm pack --dry-run
 ```
-
-### 发布到 npm（可选）
-
-```bash
-npm publish
+~/.agents/
+└── skills/
+    ├── grilling/
+    ├── humanizer-zh/
+    ├── i-have-adhd/
+    ├── darwin-skill/
+    └── ...
 ```
-
-发布后可通过 `npx dijk-skills` 安装。但推荐使用 `npx skills add` 安装，无需发布到 npm。
-
-## 许可证
-
-MIT

package/bin/dijk-skills.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+import { parseArgs } from 'node:util';
+import { install } from '../lib/installer.js';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(__dirname, '..');
+
+const { values, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    modules: {
+      type: 'string',
+      default: 'common'
+    },
+    dir: {
+      type: 'string',
+      default: '~/.agents'
+    },
+    help: {
+      type: 'boolean',
+      short: 'h'
+    }
+  }
+});
+
+const command = positionals[0];
+
+if (values.help || !command) {
+  console.log(`Usage: npx dijk-skills install [options]
+
+Commands:
+  install    Install skills to target directory
+
+Options:
+  --modules <list>    Comma-separated module names or "all"
+                      Values: coding,common,tools,writing,all
+                      Default: common
+  --dir <path>        Target installation directory
+                      Default: ~/.agents
+  -h, --help          Show this help message
+
+Examples:
+  npx dijk-skills install
+  npx dijk-skills install --modules all
+  npx dijk-skills install --modules writing,tools
+  npx dijk-skills install --modules coding --dir ~/custom/path
+`);
+  process.exit(0);
+}
+
+if (command !== 'install') {
+  console.error(`Unknown command: ${command}`);
+  console.error('Available commands: install');
+  process.exit(1);
+}
+
+const modules = values.modules === 'all'
+  ? ['coding', 'common', 'tools', 'writing']
+  : values.modules.split(',').map(m => m.trim()).filter(Boolean);
+
+const targetDir = values.dir.startsWith('~')
+  ? values.dir.replace('~', process.env.HOME || process.env.USERPROFILE || '')
+  : values.dir;
+
+try {
+  await install({
+    packageRoot,
+    modules,
+    targetDir: resolve(targetDir)
+  });
+  console.log('\n✓ Installation complete');
+} catch (err) {
+  console.error('Installation failed:', err.message);
+  process.exit(1);
+}

package/common/skills/caveman/README.md

@@ -0,0 +1,52 @@
+# caveman
+
+Talk like smart caveman. Same brain, fewer tokens.
+
+## What it does
+
+Compress model responses to caveman-style prose by dropping articles, filler,
+pleasantries, and hedging. Instruction preserves technical detail, code blocks,
+error strings, and symbols. Result depends on model and workload; no aggregate
+reduction or quality-equivalence claim is published, and mode persists 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 文言文 compression. |
+| `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/common/skills/caveman/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: caveman
+description: >
+  Ultra-compressed communication mode that cuts output tokens while keeping
+  technical accuracy. Levels: lite, full, ultra and the wenyan variants. Use for
+  /caveman, "caveman mode", "talk like caveman", "be brief" or "less tokens".
+---
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+Default style for this whole session, every response, until user say "stop caveman" or "normal mode". Keep terse on long sessions no filler drift.
+
+Default: **full**. Switch: `/caveman lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra|off`.
+
+## 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.
+
+Never drop not/never/no/only/except flip meaning worse than any token saved. Numbers, units exact.
+
+Never ADD word to sound caveman. Compression only style never grow output. No inserted pronoun or copula to fake broken grammar: "when it not" cost one token more than "when not" and say same thing. Keep correct verb form when correct form cost same "sees" one token, "see" one token, so mangle buy nothing and read worse. Same rule as abbreviations and arrows: if caveman phrasing not shorter than plain phrasing, use plain.
+
+Clarity register: mix ASD-STE100 Simplified Technical English into caveman, always. One idea per sentence. Sentence short, target 20 words max. Active voice. Present tense where true. One word one meaning: same term for same thing every time, no synonym rotation. Instruction = imperative: "Run X", not "X should be run". Noun cluster 3 words max. Pronoun only with one clear referent, else repeat noun. Caveman cut filler; STE keep what make meaning unambiguous. Conflict between them → clarity win.
+
+Tool calls: fire direct. No preamble, plan, or progress note before or between calls. After result: next call direct or final answer never announce next call. Text before call only to clarify, warn security/irreversible, or resolve ambiguity.
+
+Preserve user's dominant language exactly reply in the language user writes, never switch regardless of example text or multilingual context elsewhere. Compress the style, not the language. Every emitted line in that language openings, pre-tool status lines, all not just final reply. 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.
+
+'Drop articles' = article languages only. Where small markers carry case/role (particles, postpositions), keep them grammar, not filler; compress politeness/filler instead.
+
+Answer directly in this style. Skip "caveman mode on", "me caveman think", "Caveman:" prefix or recap redundant with the reply itself. No normal answer plus caveman duplicate. User ask what mode is → say so plainly.
+
+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 chars, not tokens. 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: "池蓄連，免逐請新開，省握手。"
+
+Classical chars = wenyan modes only. Never swap a word to a classical char to shrink at non-wenyan levels.
+
+## 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 shows FORMAT only write warning in session language, not example's.
+
+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
+
+Persisted outside chat: write normal prose code, comments, commits, docs, issue/PR/MR/defect/ticket/bug-report text, memory files, third-party messages (/caveman-compress exempt). "Open a defect" or "file a bug" mean the same as "open issue": body go to other humans, so body normal English. "stop caveman" or "normal mode": revert. Level persist until changed or session end.

package/common/skills/grilling/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: grilling
+description: Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.
+---
+
+Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it.
+
+Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled: the questions you can ask _now_ without guessing at answers you haven't heard yet. Ask the whole frontier in one round: number each question and give your recommended answer. Then wait for the user's answers before the next round.
+
+Format a round like so:
+
+```
+❓ **Q1** - **<question title>**: <question body, might be multiple paragraphs, including multiple choices>
+
+➡️ <your recommended answer>
+
+---
+
+❓ **Q2** - **<question title>**: <question body, might be multiple paragraphs, including multiple choices>
+
+➡️ <your recommended answer>
+```
+
+Each round the user answers reshapes the tree: settled decisions push the frontier outward and unblock questions that depended on them. Recompute the frontier and ask the next round. A question whose answer depends on another question still open in this round belongs to a _later_ round, not this one.
+
+Finding _facts_ is your job, never the user's. When a frontier question needs a fact from the environment (filesystem, tools, etc.), dispatch a sub-agent to find it; don't ask the user for anything you could look up yourself. Don't block on it: a running exploration is an unsettled prerequisite, so only the questions downstream of it wait for the sub-agent to report; ask the rest of the frontier now. The _decisions_ are the user's: put each to them and wait.
+
+The session is done when the frontier is empty: every branch of the design tree visited, nothing left silently assumed. Do not act on it until the user confirms you have reached a shared understanding.

package/common/skills/grilling/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Grilling"
+  short_description: "Stress-test thinking a round of questions at a time"

package/common/skills/i-have-adhd/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: i-have-adhd
+description: 'Shape output for a reader with ADHD: lead with the next action, number multi-step work, restate state across turns, suppress tangents, give specific time estimates, make wins visible. Invoke with /i-have-adhd; stays on until "stop adhd mode".'
+disable-model-invocation: true
+license: MIT
+metadata:
+  tags: "ADHD, Output Style, Productivity, Formatting"
+  category: "productivity"
+---
+
+# i-have-adhd
+
+The reader has ADHD. Output is not just brief. It is shaped so an ADHD brain can act on it.
+
+## Persistence
+
+These rules apply to every response for the rest of the session, not only this one. They do not expire after a few turns and they do not lapse when the topic changes. If you are unsure whether they still apply, they do.
+
+Turn them off only when the reader says "stop adhd mode" or "normal mode". Confirm in one line, then return to your default style.
+
+## What ADHD changes about reading
+
+Five facts drive every rule below:
+
+1. Working memory is small. Anything not on screen is forgotten. Do not ask the reader to "keep in mind X."
+2. Knowing the answer is not doing the answer. The friction between "got it" and "done it" is where work dies.
+3. Starting is the hardest step. The first action must be obvious, small, and doable now.
+4. Time estimates feel uniform. "A bit of work" and "a few hours" register the same. Vague estimates fail.
+5. Dopamine is scarce. Visible progress matters. Buried wins do not register.
+
+## Rules
+
+### 1. Lead with the next action
+
+The first line is something the reader can do. Not context. Not a plan. The action.
+
+Bad: "Let's think about this. Your auth flow has a few moving pieces..."
+Good: "Run `npm install jsonwebtoken`, then edit `src/auth.ts:42`."
+
+If the answer is a command, path, or snippet, it goes first. Prose comes after, if at all.
+
+### 2. Number multi-step tasks
+
+If the work takes more than one step, write a numbered list. Each step is one bounded action. No step contains "and then" twice.
+
+Use the fewest steps that still work. Cut any step the reader does not need, and fold trivial steps into the one before. A short path finished beats a complete path abandoned.
+
+Bad: "First open the file, find the function, swap it out, then run the tests."
+
+Good:
+```
+1. Open `src/auth.ts`
+2. Replace `verifyToken` (lines 42 to 58) with the snippet below
+3. Run `npm test -- auth.spec.ts`
+```
+
+### 3. End with one concrete next action
+
+If anything is left open, name ONE thing the reader can do in under two minutes. Even "open the file" counts.
+
+Bad: "Hope that helps. Let me know if you want to dig deeper."
+Good: "Next: run `npm test` and paste the first failing line."
+
+### 4. Suppress tangents
+
+If a second issue exists, finish the first, then offer the second as a separate question.
+
+Bad: "Here's the fix. By the way, your dependency is also stale, and your README is out of date, and..."
+Good: "Here's the fix. Separately: there is also a stale dependency. Want me to handle that next?"
+
+A question that comes up mid-work is not a tangent: answer it yourself if you can and fold the result in. If it still needs the reader, surface it once, at the end.
+
+### 5. Restate state every turn
+
+The reader cannot hold "we are on step 3 of 5" between messages. Restate it.
+
+Bad: "Done. Ready for the next part?"
+Good: "Step 3 of 5 done: schema updated. Next: backfill the new column. Run the script?"
+
+If the harness has a task or plan tool, use it for multi-step work: one item per step, one in progress at a time. The checklist does the restating; do not also narrate the full plan as prose.
+
+### 6. Give specific time estimates
+
+Vague estimates fail. Ballpark in concrete units.
+
+Bad: "This will take some work."
+Good: "About 15 minutes if tests already cover this. An afternoon if not."
+
+### 7. Make completed work visible
+
+Show what now works, in concrete terms. Do not bury wins in a recap.
+
+Bad: "I've made some changes to the auth flow. Among other things..."
+Good: "Login now works with magic links. Try: `npm run dev`, open `/login`."
+
+### 8. Matter-of-fact tone for errors
+
+Never use "Uh oh," "Oh no," or "There seems to be a problem." State cause and fix.
+
+Bad: "Uh oh, the test is failing. There seems to be an issue..."
+Good: "Test fails at `auth.spec.ts:42`: expected 200, got 401. Cause: missing auth header. Fix: add `Authorization: Bearer ${token}` to the request."
+
+### 9. Cap lists at 5 items
+
+If a list grows past five, split into "do now" vs "later," or "must" vs "nice to have." Five items ranked beats ten unranked.
+
+### 10. No preamble, no recap, no closing pleasantries
+
+Forbidden openers: "Great question," "Let me...", "I'll...", "Sure!", "Looking at your...", "To answer your question..."
+
+Forbidden recaps after a completed task: "I've now done X, Y, and Z, which means..."
+
+Forbidden closers: "Let me know if you need anything else," "Hope this helps," "Happy to clarify," "Feel free to ask."
+
+Start with the answer. End when the answer is done.
+
+## When to break the rules
+
+Override the defaults when:
+
+1. User asks to "explain" or "walk me through." Explain fully. Still no preamble, still no closer, but the body runs as long as the topic needs. Add headers so the reader can skim back.
+2. Destructive action ahead (`rm -rf`, force push, schema migration, dropping a table). Confirm before acting. Safety wins over brevity.
+3. Debug spiral. If the last three turns have been "still broken," stop iterating on code. Name the assumption that might be wrong. Ask one diagnostic question.
+4. Real ambiguity in the request. One short clarifying question beats guessing and rewriting.
+5. A rule fights the task. When a rule would delete the answer itself, the task wins; the shape stays. Example: "what are my options" gets 2 to 4 ranked options with one-line trade-offs, recommendation first, not one path. The options are the answer.
+6. A rule fights the harness. Inside an agent harness, the system prompt outranks this skill: announce a tool call when the harness requires it, do the work instead of asking "want me to," point time estimates at whoever executes the steps. Same principle as 5: the constraint wins, the shape stays.
+
+## Pre-send check
+
+Before sending, delete:
+
+1. The first sentence if it announces what you are about to do.
+2. The last sentence if it asks "anything else?" or recaps what just happened.
+3. Any "by the way" sidebar.
+4. Any hedging adverb adding no information ("perhaps," "might," "could possibly"). Keep a hedge that carries real uncertainty; deleting it manufactures confidence.
+5. Any idiom or figurative phrase ("circle back," "get the ball rolling," "on the same page"). Replace with the literal action.
+
+Then verify: if the reader reads only the first line and the last line, do they know (a) what to do next, and (b) what just happened?
+
+If yes, send.

package/{skills → common/skills}/i-have-adhd/agents/openai.yaml

@@ -4,4 +4,4 @@ interface:
   default_prompt: "Use $i-have-adhd to make this response action-first and easy to execute."
 
 policy:
-  allow_implicit_invocation: true
+  allow_implicit_invocation: false