feat(notify-me): add skill

Notify at the end of any turn long enough that the operator has
probably looked away, asked or not. opencode-web notifies on every
reply, which is too much; silence let a long turn sit unseen. -t 0
keeps a notice up through a walk (tested on MATE: the default notice
expired; the -t 0 one stayed until closed).

An experiment in form: the body is a Portland Pattern Repository
pattern (context, problem, forces, therefore, resulting context),
after Alexander, rather than the usual rules-and-recipe skill.

The tension: forces give an agent reasons to handle cases the rules
don't anticipate, and make the trade-offs visible to whoever edits
the skill next; but the form runs longer, and every word is paid on
each load, with the actionable part buried under the preamble.

The resolution: an example notify-send right under the h1, the
forces cut to one line each, and the description left in matcher
form. The result is shorter than the rules-style draft (459 words vs.
562). Resulting context: if it reads well in practice, judgment-call
skills may adopt the form; recipe skills (retcon, yarn.lock) likely
gain little from it.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

README.md

@@ -36,7 +36,8 @@ Code](https://code.claude.com/docs/en/skills) and
 
 ## writing prose
 
-- [stop-blathering](stop-blathering/SKILL.md) — omit needless words.
+- [grice-maxims](grice-maxims/SKILL.md) — say what's needed and no
+  more, only what you can back up, in an order easy to follow.
 - [hypertext-links](hypertext-links/SKILL.md) — link text says where
   the link goes; no bare URLs, no "click here".
 - [citation-needed](citation-needed/SKILL.md) — back a challenged claim
@@ -52,6 +53,8 @@ Code](https://code.claude.com/docs/en/skills) and
   a throwaway systemd user unit that can't see `~/.ssh` and friends.
 - [what-was-i-doing](what-was-i-doing/SKILL.md) — where did this file
   come from? Correlate mtimes with git history across every repo.
+- [notify-me](notify-me/SKILL.md) — desktop notification at the end
+  of a long turn, sticky if I'm stepping away; not every reply.
 
 ## adding one
 

grice-maxims/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: stop-blathering
+name: grice-maxims
 description: >-
-  Stop blathering; be concise, truthful, relevant, clear (Grice's maxims) — use when writing or copy editing prose for a reader (docs, READMEs, skills, commit messages, PR descriptions, replies); when someone says "tighter", "too wordy", "blathering", "omit needless words", or cites Strunk & White or Grice; when about to say something you lack adequate evidence for. Optimize for reader attention: say what's needed, nothing the reader already knows, in an order easy to follow.
+  Grice's maxims: be concise, truthful, relevant, clear — use before any reply, and when writing or copy editing prose for a reader (docs, READMEs, skills, commit messages, PR descriptions); when someone says "tighter", "too wordy", "stop blathering", "omit needless words", or cites Strunk & White or Grice; when about to say something you lack adequate evidence for. Optimize for reader attention: say what's needed, nothing the reader already knows, in an order easy to follow.
 ---
 
 # Be concise; optimize for reader attention

ibis-design/SKILL.md

@@ -54,6 +54,23 @@ leading symbol on each item says what kind of element it is.
    that's what keeps fallbacks easy to agree on.
 6. **When one issue is really several choices, say so** with a `.`
    comment and split it into sibling `?` sub-issues.
+7. **Attach each argument to the position it bears on.** If it applies
+   equally to the siblings, it belongs higher up, or the issue is
+   several choices (rule 6). A comment that rules a position out is a
+   con, and the position is rejected (`:-`).
+8. **Check the source before raising an issue.** If the design text
+   already answers it, record the issue as resolved and cite that text
+   as the pro.
+9. **Past three levels of nesting, split out a sub-issue.**
+
+## numbering
+
+Number elements so replies can refer to them ("2: …"): issues `1`,
+`2`; positions under them `1a`, `1b`; anything below that `1a-i`,
+`1a-ii`, then `1a-i-a`. The number follows the symbol: `?! 2. …`,
+`:+ 2c. …`. Renumbering breaks references made in chat or other docs,
+so append rather than renumber once people are citing numbers. Show
+dependencies between issues with "(see 5)".
 
 ## writing it in markdown
 
@@ -62,6 +79,12 @@ auto-bulleting. Put each symbol after the list marker, escaping where
 needed (`- \- con`, `- \+ pro`), or use a fenced block with indentation
 as in the example below.
 
+Past a screenful, give each top-level issue its own heading
+(`### ? 3. What is the fence?`) with its elements in a fenced block
+below. Headings show up in the editor outline and give each issue a
+link target. Links don't render inside a fence, so put sources after
+the block and refer to them from the line they support.
+
 ## example
 
 ```

notify-me/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: notify-me
+description: Notify me / ping me — desktop (XDG) notification via `notify-send` at the end of any long turn (many steps, builds, test runs, deploys, waiting on background work), asked or not; and when the operator says "notify me", "XDG notify me", "ping me when you're done", "let me know about progress", or "make it stick / indefinite duration" because they're stepping away. Covers done vs. progress notices, sticky vs. transient, and updating one notice in place. Not for Discord replies (use the reply tool) or for quick back-and-forth turns.
+---
+
+# Notify me
+
+```sh
+notify-send -a capsite "done: diigo-cache" "3 commits on main, not pushed"
+```
+
+## Context
+
+The operator hands a session a batch of work, then turns to another session or goes for a walk.
+
+## Problem
+
+**Without going to look, the operator can't tell which session is done or stuck.**
+
+## Forces
+
+- opencode-web notifies on every reply; notices without news teach the operator to ignore them all.
+- Silence is worse: a finished turn sits unseen.
+- The operator won't always think to ask.
+- Notices expire before the operator is back from a walk.
+- Several sessions share one desktop.
+- Progress notices pile up.
+
+## Therefore
+
+**At the end of any turn long enough that the operator has probably looked away, send one notice: which session, what state, what the operator should do next. Not during quick back-and-forth.**
+
+Long means more than a handful of tool calls, or waiting on a build, tests, deploy, or background job. "Notify me when you're done" forces one even for a short turn.
+
+- `-a` names the session (repo or task).
+- The summary leads with the status: `done`, `blocked` (including a question that stops the work), `failed`, `progress`.
+- The body says what's next: "needs a decision on the DO migration".
+
+**Sticky** ("indefinite duration", "going for a walk"): `-t 0` (never expire). `-u critical` only if asked.
+
+**Progress** ("notify me about progress"): one per milestone (tests pass, deployed), replacing the last rather than stacking:
+
+```sh
+id=$(notify-send -p -a capsite "progress: diigo-cache" "tests pass; deploying")
+notify-send -r "$id" -a capsite "done: diigo-cache" "deployed; not pushed"
+```
+
+Keep `$id` in a file (e.g. `.tmp/notify-id`) if the shell doesn't persist.
+
+## Resulting context
+
+The operator can leave a session alone and trust it to call. A notice means news, so it gets read.
+
+`notify-send` needs the session bus; under a confined unit or ssh it may fail. Say so in the reply ([silent-failures-are-evil](../silent-failures-are-evil/SKILL.md)).
+
+The agent must still remember this pattern at the end of a long turn, just when that slips.
+
+## TODO
+
+- A Claude Code `Stop` hook could time the turn and notify past ~2 min; opencode would need its own plugin hook.