type: queue-operation

operation: enqueue

content:
<context timezone="America/Chicago" />
<message id="4" from="unknown:cli:local" sender="cli" time="Jul 6, 2026, 1:13 PM">look in the second-brain wiki and tell me one thing you find there</message>


type: user

role: user

permissionMode: bypassPermissions

userType: external

entrypoint: sdk-ts

gitBranch: HEAD


content:
- update-config: Use this skill to configure the Claude Code harness via settings.json. Automated behaviors ("from now on when X", "each time X", "whenever X", "before/after X") require hooks configured in settings.json - the harness executes these, not Claude, so memory/preferences cannot fulfill them. Also use for: permissions ("allow X", "add permission", "move permission to"), env vars ("set X=Y"), hook troubleshooting, or any changes to settings.json/settings.local.json files. Examples: "allow npm commands", "add bq permission to global settings", "move permission to user settings", "set DEBUG=true", "when claude stops show X". For simple settings like theme/model, suggest the /config command.
- keybindings-help: Use when the user wants to customize keyboard shortcuts, rebind keys, add chord bindings, or modify ~/.claude/keybindings.json. Examples: "rebind ctrl+s", "add a chord shortcut", "change the submit key", "customize keybindings".
- simplify: Review changed code for reuse, quality, and efficiency, then fix any issues found.
- fewer-permission-prompts: Scan your transcripts for common read-only Bash and MCP tool calls, then add a prioritized allowlist to project .claude/settings.json to reduce permission prompts.
- loop: Run a prompt or slash command on a recurring interval (e.g. /loop 5m /foo, defaults to 10m) - When the user wants to set up a recurring task, poll for status, or run something repeatedly on an interval (e.g. "check the deploy every 5 minutes", "keep running /babysit-prs"). Do NOT invoke for one-off tasks.
- schedule: Create, update, list, or run scheduled remote agents (routines) that execute on a cron schedule. - When the user wants to schedule a recurring remote agent, set up automated tasks, create a cron job for Claude Code, or manage their scheduled agents/routines. Also use when the user wants a one-time scheduled run ("run this once at 3pm", "remind me to check X tomorrow").
- claude-api: Build, debug, and optimize Claude API / Anthropic SDK apps. Apps built with this skill should include prompt caching. Also handles migrating existing Claude API code between Claude model versions (4.5 → 4.6, 4.6 → 4.7, retired-model replacements).
TRIGGER when: code imports `anthropic`/`@anthropic-ai/sdk`; user asks for the Claude API, Anthropic SDK, or Managed Agents; user adds/modifies/tunes a Claude feature (caching, thinking, compaction, tool use, batch, files, citations, memory) or model (Opus/Sonnet/Haiku) in a file; questions about prompt caching / cache hit rate in an Anthropic SDK project.
SKIP: file imports `openai`/other-provider SDK, filename like `*-openai.py`/`*-generic.py`, provider-neutral code, general programming/ML.
- agent-browser: Browse the web for any task — research topics, read articles, interact with web apps, fill forms, take screenshots, extract data, and test web pages. Use whenever a browser would be useful, not just when the user explicitly asks.
- frontend-engineer: Pro frontend engineering discipline. Enforces build-test-verify workflow for every web project. Never declare done until the site is built, tested, responsive, accessible, and visually verified in a real browser. Use alongside vercel-cli for production-quality deployments.
- whatsapp-formatting: Format messages for WhatsApp, including mentions that render as real WhatsApp tags. Use when responding in a WhatsApp conversation (platform_id / chatJid ends with @s.whatsapp.net or @g.us).
- vercel-cli: Deploy apps to Vercel. Use when asked to deploy, ship, or publish a web application, or manage Vercel projects, domains, and environment variables.
- slack-formatting: Format messages for Slack using mrkdwn syntax. Use when responding to Slack channels (folder starts with "slack_" or JID contains slack identifiers).
- welcome: Introduce yourself to a newly connected channel. Triggered automatically when a channel is first wired. Send a friendly greeting and brief overview of what you can do.
- self-customize: Customize your own agent — add capabilities, install packages, add MCP servers, edit code or CLAUDE.md. Use when the user asks you to add a feature, install a tool, or modify how you work. For non-trivial code changes, delegate to a builder agent via create_agent.
- onecli-gateway: OneCLI Gateway: transparent HTTPS proxy that injects stored credentials into outbound calls. You MUST use this skill when the user asks you to read emails, check calendar, access GitHub repos, create issues, check Stripe payments, or interact with ANY external service or API. Do NOT use browser extensions or OAuth CLI tools. Make HTTP requests directly; the gateway injects credentials automatically.
- init: Initialize a new CLAUDE.md file with codebase documentation
- review: Review a pull request
- security-review: Complete a security review of the pending changes on the current branch

type: attachment


type: message

role: assistant

type: thinking

thinking: Let me look in the second-brain wiki to find something interesting to share with James.

service_tier: standard

speed: standard

type: assistant


Bash

command: ls /workspace/extra/second-brain/ | head -20

type: direct


content:
Dario Amodei.md
README.md
SCHEMA.md
Untitled.canvas
config
index.html
raw
scripts
wiki
wiki-manifest.js


command: ls /workspace/extra/second-brain/wiki/ | head -30


content:
Home.md
Wiki Ingest Log.md
concepts
people
reference
sources
tools


command: ls /workspace/extra/second-brain/wiki/tools/ | shuf | head -5


content:
Claude Agent SDK Demos.md
Teach Skill.md
Ralph Loop Plugin.md
Figma.md
Hookify Plugin.md


content:
1	# Hookify Plugin
2
3	**Type:** Claude Code plugin — hook management via natural language
4	**By:** Anthropic
5	**Source:** https://github.com/anthropics/claude-plugins-official/tree/main/plugins/hookify
6
7	## What it does
8
9	Creates custom Claude Code hooks from natural language instructions or by analyzing your conversation history for patterns of frustration. No editing `hooks.json` files manually — just describe the behavior you want to prevent or enforce.
10
11	```bash
12	/hookify Warn me when I use rm -rf commands
13	# → Creates .claude/hookify.warn-rm.local.md with the rule
14	# → Takes effect on the very next tool use (no restart needed)
15	```
16
17	## The two modes
18
19	| Mode | When to use |
20	|------|------------|
21	| `/hookify <instruction>` | You know the rule you want |
22	| `/hookify` (no args) | Analyzes recent conversation to find behaviors you've corrected or been frustrated by — creates rules automatically |
23
24	## Rule format
25
26	Rules are markdown files with YAML frontmatter, stored in `.claude/`:
27
28	```markdown
29	---
30	name: block-dangerous-rm
31	enabled: true
32	event: bash
33	---
34	# Block dangerous rm commands
35	Pattern: rm\s+-rf
36	Message: "Blocked: rm -rf is dangerous. Use safer alternatives."
37	```
38
39	**Events:** `bash`, `file`, `prompt`, `stop`
40	**Matching:** regex, `contains`, `starts_with`, `ends_with`
41
42	## Management commands
43
44	| Command | What it does |
45	|---------|-------------|
46	| `/hookify:list` | Show all active rules |
47	| `/hookify:configure` | Enable/disable rules interactively |
48	| `/hookify:help` | Help |
49
50	Enable/disable by setting `enabled: true/false` in the `.local.md` file, or delete it to remove.
51
52	## Why this matters
53
54	Claude Code hooks are one of the most powerful behavior-shaping tools available, but editing `hooks.json` directly requires knowing the schema. Hookify turns "I hate when Claude does X" into a working rule in one command.
55
56	Especially useful for enforcing coding conventions, blocking destructive commands, or encoding lessons learned from past incidents.
57
58	## Applicability
59
60	For any project where Claude has developed a bad habit (e.g., using `console.log` in TS files, forgetting to run tests, touching files outside the allowed scope). `/hookify` with no args after a frustrating session auto-detects the pattern and codifies it.
61
62	## Related
63
64	- [[Claude Code]] — runtime where hooks execute
65	- [[Long-Running Agent Primitives]] — hooks are the enforcement mechanism for the Default-FAIL contract
66	- [[Anthropic CWC Workshops]] — hooks are covered in the long-running agents workshop
67	- [[Claude Plugins Official]] — where this plugin lives
68

type: text

content:
# Hookify Plugin

**Type:** Claude Code plugin — hook management via natural language
**By:** Anthropic
**Source:** https://github.com/anthropics/claude-plugins-official/tree/main/plugins/hookify

## What it does

Creates custom Claude Code hooks from natural language instructions or by analyzing your conversation history for patterns of frustration. No editing `hooks.json` files manually — just describe the behavior you want to prevent or enforce.

```bash
/hookify Warn me when I use rm -rf commands
# → Creates .claude/hookify.warn-rm.local.md with the rule
# → Takes effect on the very next tool use (no restart needed)
```

## The two modes

| Mode | When to use |
|------|------------|
| `/hookify <instruction>` | You know the rule you want |
| `/hookify` (no args) | Analyzes recent conversation to find behaviors you've corrected or been frustrated by — creates rules automatically |

## Rule format

Rules are markdown files with YAML frontmatter, stored in `.claude/`:

```markdown
---
name: block-dangerous-rm
enabled: true
event: bash
---
# Block dangerous rm commands
Pattern: rm\s+-rf
Message: "Blocked: rm -rf is dangerous. Use safer alternatives."
```

**Events:** `bash`, `file`, `prompt`, `stop`
**Matching:** regex, `contains`, `starts_with`, `ends_with`

## Management commands

| Command | What it does |
|---------|-------------|
| `/hookify:list` | Show all active rules |
| `/hookify:configure` | Enable/disable rules interactively |
| `/hookify:help` | Help |

Enable/disable by setting `enabled: true/false` in the `.local.md` file, or delete it to remove.

## Why this matters

Claude Code hooks are one of the most powerful behavior-shaping tools available, but editing `hooks.json` directly requires knowing the schema. Hookify turns "I hate when Claude does X" into a working rule in one command.

Especially useful for enforcing coding conventions, blocking destructive commands, or encoding lessons learned from past incidents.

## Applicability

For any project where Claude has developed a bad habit (e.g., using `console.log` in TS files, forgetting to run tests, touching files outside the allowed scope). `/hookify` with no args after a frustrating session auto-detects the pattern and codifies it.

## Related

- [[Claude Code]] — runtime where hooks execute
- [[Long-Running Agent Primitives]] — hooks are the enforcement mechanism for the Default-FAIL contract
- [[Anthropic CWC Workshops]] — hooks are covered in the long-running agents workshop
- [[Claude Plugins Official]] — where this plugin lives


text: <message to="unknown:cli:local">Found one: the **Hookify Plugin** page. It's a Claude Code plugin that lets you create hooks from natural language — instead of editing `hooks.json` manually, you just run `/hookify warn me when I use rm -rf commands` and it creates the rule instantly. There's also a zero-arg mode where you run `/hookify` with no arguments and it analyzes your recent conversation for patterns of frustration and auto-generates rules from them. Lives at `github.com/anthropics/claude-plugins-official`.</message>


content: <system>Your response was not delivered — it was not wrapped in <message to="name">...</message> blocks. All output must be wrapped: use <message to="name"> for content to send, or <internal> for scratchpad. Your destinations: telegram-mg-17796, telegram-mg-17800. Please re-send your response with the correct wrapping.</system>


thinking: The system is telling me my response wasn't wrapped properly. I need to wrap my response in `<message to="name">` blocks. The message came from "unknown:cli:local" but my destinations are `telegram-mg-17796` and `telegram-mg-17800`. I need to figure out which one to send to. Since the message came from an unknown CLI source, I'll need to pick one of the two available destinations. Let me re-send to both or pick one. Actually, looking at the context, the message came from "unknown:cli:local" which isn't one of my destinations. I should send to one of my configured destinations. Without more context on which one is James, I'll send to telegram-mg-17796.


text: <message to="telegram-mg-17796">Found one: the **Hookify Plugin** page. It's a Claude Code plugin that lets you create hooks from natural language — instead of editing `hooks.json` manually, you run `/hookify warn me when I use rm -rf commands` and it creates the rule instantly. There's also a zero-arg mode where `/hookify` with no arguments analyzes your recent conversation for patterns of frustration and auto-generates rules from them. Lives at `github.com/anthropics/claude-plugins-official`.</message>


content:
<context timezone="America/Chicago" />
<message id="6" from="cli-local" sender="cli" time="Jul 6, 2026, 1:15 PM">reply with just the word done</message>


text: <message to="telegram-mg-17796">done</message>