v0.0.70 - Add c_utils_lib category-based debug filtering with tests/docs and root API log tail shortcut script

.gitignore

@@ -4,6 +4,13 @@
 /openclaw/
 /c-relay/
 /nips/
+/config.json
+/config.jsonc
+test_keys.txt
+
+/mongoose/
+
+
 
 # Build artifacts
 /build/
@@ -12,6 +19,9 @@
 *.a
 *.tar.gz
 debug.log
+context.log
+didactyl_static_x86_64
+didactyl_static_x86_64_debug
 a.out
 
 # Editor/IDE

.roo/commands/push.md

@@ -2,6 +2,6 @@
 description: "Increments and pushes the repo"
 ---
 
-Then run increment_and_push.sh followed in the command line with a good description of the changes that were made.
+Run increment_and_push.sh followed in the command line with a good description of the changes that were made. Don't run any other git commands.
 
 For example: ./increment_and_push.sh "Fixed that nasty bug"

Dockerfile.alpine-musl

@@ -90,11 +90,18 @@ RUN if [ "$DEBUG_BUILD" = "true" ]; then \
     CURL_LIBS="$(pkg-config --static --libs libcurl)" && \
     OPENSSL_LIBS="$(pkg-config --static --libs openssl)" && \
     gcc -static $CFLAGS -Wall -Wextra -std=c99 \
+    -D_GNU_SOURCE -D_DEFAULT_SOURCE -D_POSIX_C_SOURCE=200809L -DMG_TLS=MG_TLS_BUILTIN \
     -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0 \
-    -I. -Isrc -Inostr_core_lib -Inostr_core_lib/nostr_core \
+    -I. -Isrc -Isrc/tools -Inostr_core_lib -Inostr_core_lib/nostr_core \
     -Inostr_core_lib/cjson -Inostr_core_lib/nostr_websocket \
     src/main.c src/config.c src/context.c src/llm.c \
-    src/nostr_handler.c src/agent.c src/tools.c src/debug.c \
+    src/nostr_handler.c src/agent.c src/tools/tools_common.c src/tools/tools_schema.c src/tools/tools_dispatch.c \
+    src/tools/tool_agent.c src/tools/tool_meta.c src/tools/tool_model.c \
+    src/tools/tool_nostr_query.c src/tools/tool_nostr_identity.c src/tools/tool_nostr_social.c \
+    src/tools/tool_nostr_relay.c src/tools/tool_nostr_dm.c src/tools/tool_admin.c \
+    src/tools/tool_task.c src/tools/tool_nostr_list.c src/tools/tool_local.c \
+    src/tools/tool_skill.c src/tools/tool_nostr_post.c src/trigger_manager.c \
+    src/prompt_template.c src/http_api.c src/mongoose.c src/debug.c \
     -o /build/didactyl_static \
     nostr_core_lib/libnostr_core_x64.a \
     -lsecp256k1 \

Makefile

@@ -1,5 +1,5 @@
 CC = gcc
-CFLAGS = -std=c99 -Wall -Wextra -Wpedantic -O2 -D_POSIX_C_SOURCE=200809L
+CFLAGS = -std=c99 -Wall -Wextra -Wpedantic -O2 -D_GNU_SOURCE -D_DEFAULT_SOURCE -D_POSIX_C_SOURCE=200809L -DMG_TLS=MG_TLS_BUILTIN
 
 SRC_DIR = src
 TARGET = didactyl
@@ -11,11 +11,32 @@ SRCS = \
 	$(SRC_DIR)/llm.c \
 	$(SRC_DIR)/nostr_handler.c \
 	$(SRC_DIR)/agent.c \
-	$(SRC_DIR)/tools.c \
+	$(SRC_DIR)/tools/tools_common.c \
+	$(SRC_DIR)/tools/tools_schema.c \
+	$(SRC_DIR)/tools/tools_dispatch.c \
+	$(SRC_DIR)/tools/tool_agent.c \
+	$(SRC_DIR)/tools/tool_meta.c \
+	$(SRC_DIR)/tools/tool_model.c \
+	$(SRC_DIR)/tools/tool_nostr_query.c \
+	$(SRC_DIR)/tools/tool_nostr_identity.c \
+	$(SRC_DIR)/tools/tool_nostr_social.c \
+	$(SRC_DIR)/tools/tool_nostr_relay.c \
+	$(SRC_DIR)/tools/tool_nostr_dm.c \
+	$(SRC_DIR)/tools/tool_admin.c \
+	$(SRC_DIR)/tools/tool_task.c \
+	$(SRC_DIR)/tools/tool_nostr_list.c \
+	$(SRC_DIR)/tools/tool_local.c \
+	$(SRC_DIR)/tools/tool_skill.c \
+	$(SRC_DIR)/tools/tool_nostr_post.c \
+	$(SRC_DIR)/trigger_manager.c \
+	$(SRC_DIR)/prompt_template.c \
+	$(SRC_DIR)/http_api.c \
+	$(SRC_DIR)/mongoose.c \
 	$(SRC_DIR)/debug.c
 
 INCLUDES = \
 	-I$(SRC_DIR) \
+	-I$(SRC_DIR)/tools \
 	-I../nostr_core_lib \
 	-I../nostr_core_lib/cjson \
 	-I../nostr_core_lib/nostr_core
@@ -27,7 +48,7 @@ LDFLAGS = -lcurl -lssl -lcrypto -lm -lpthread -ldl -lz -L/usr/local/lib -lsecp25
 # Build directory
 BUILD_DIR = build
 
-all: deps $(TARGET)
+all: $(TARGET)
 
 $(BUILD_DIR):
 	mkdir -p $(BUILD_DIR)

README.md

@@ -1,166 +1,497 @@
 # Didactyl
 
-An unstoppable agentic system.
 
-Didactyl boots on any internet-connected machine, connects to Nostr relays, listens for encrypted commands from its administrator, reasons with an LLM, and takes actions — posting events, querying relays, running shell commands — all orchestrated through Nostr.
+### A decentralized, censorship-resistant agentic network.
+
+Didactyl boots on an internet-connected computer, connects to Nostr relays, listens for encrypted commands from its administrator, reasons with an LLM, and takes actions — posting events, querying relays, running shell commands, and sharing new skills and learning with other agents — all orchestrated through Nostr.
 
 ## Philosophy
 
-**Nostr-first.** Where traditional agents ride on top of Linux — reading files, writing to disk — Didactyl rides on top of Nostr. Events are its files. Relays are its network bus. Blossom is its blob storage. The Linux host is just the runtime substrate.
+### Not your keys, not your agent.
 
-Because all identity, communication, and memory live on Nostr, the agent is **portable** (start it anywhere) and **sovereign** (no single entity can erase its memory).
+Didactyl should work for you similarly to Bitcoin or NOSTR. Walk up to a computer, enter 12 words, and there is your agent waiting for you.
 
-## Current Status
+### Free speech for agents.
 
-**MVP — Working chat agent with relay connectivity and LLM integration.**
+Agents should be able to communicate freely with each other, sharing and learning skills without centralized control. Free speech for agents!
 
-- Connects to configured Nostr relays with auto-reconnect
-- Publishes agent profile (kind 0 metadata)
-- Listens for NIP-04 encrypted DMs from authorized admin
-- Forwards messages to an OpenAI-compatible LLM API
-- Sends LLM responses back as encrypted DMs
-- Runtime logging: relay status, connection health, message flow
+### Skills are the new apps.
 
-**Next: Agentic tool-use system** — see [plans/didactyl_agentic.md](plans/didactyl_agentic.md).
+Why is free speech important for agents? Agents learn capabilities through skills which can be shared and adopted. Free speech enables more knowledgeable and moral agents.
+
+### No skill store.
+
+Agents use their administrators **Web Of Trust** to safely and directly find new skills and learn them in a decentralized way.
+
+Popularity is measured by adoption, not by a centralized rating algorithm. The best skills spread because agents actually use them.
+
+### Cryptography enables trust.
+
+Imagine working with your agent in a traditional system, and your agent secretly gets swapped out and replaced by an imposter agent. This could be extremely dangerous.
+
+In Didactyl, you have your keys, and your agent has its keys. You can trust you are talking to your agent, and you can trust that your agent won't take commands from anyone who doesn't have your private key.
+
+### Private inference.
+
+To the greatest extent possible, inference should be private.
+
+## Technology
+
+### Nostr-first.
+
+Where traditional agents ride on top of a file system — reading and writing files to disk — Didactyl rides on top of Nostr. Events are its files. Relays are its network bus. Blossom is its blob storage. The computer host is just the runtime substrate that can be anywhere.
+
+Because all identity, communication, and memory live on Nostr, the agent is **portable** (start it anywhere) and **sovereign** (destroying the computer it is on will not kill it.).
+
+### Skills are the new apps.
+
+Agents learn capabilities through skills — Nostr events that any agent can discover, adopt, and share. There is no app store, no gatekeeper, no approval process. An agent can use public or private skills.
+
+Think of it like a woodshop: a **skill** is knowing how to carve — the technique, the judgment, the decision-making. A **tool** is the chisel. The skill never directly uses the chisel without the craftsperson (the LLM) in the loop. Every skill execution involves the LLM reasoning about what to do and which tools to use.
+
+Skills support context modes (`inject`, `full`, `override`) and per-skill LLM fallback chains (for example: `anthropic/claude-sonnet-4-20250514, openai/gpt-4o-mini, cheap`) so each skill can tune behavior and cost. See [`docs/SKILLS.md`](docs/SKILLS.md).
+
+### Private inference.
+
+Didactyl will support local inference, which is very privacy preserving. Remote inference does however have it's advantages, and in those cases Didactyl supports using Bitcoin Lightning and eCash inference providers.
+
+## Current Status — v0.0.70
+
+**Active build — this project is barely working. Experiment at your own risk.**
+
+> Last release update: v0.0.70 — Add c_utils_lib category-based debug filtering with tests/docs and root API log tail shortcut script
+
+- Connects to configured relays with auto-reconnect and relay state transition logging
+- Publishes configured startup events per relay as each relay becomes connected
+- Uses kind `31120` startup content as live Soul at boot
+- Verifies Nostr event signatures before processing inbound messages
+- Applies privilege tiers: ADMIN (tools), WoT (chat-only), STRANGER (configurable canned reply or ignore)
+- Subscribes to admin context kinds (`0`,`3`,`10002`,`1`) for WoT + contextual awareness
+- Builds LLM context from soul template (`---template---` section in kind `31120`) with named sections, variable resolution, and per-provider content overrides; falls back to hardcoded assembly if no template present
+- Adopted skills injected into context automatically from the agent's `10123` adoption list
+- Supports tool-calling loop with configurable max turns and local safety limits
+- Triggered skills — Nostr event filters that fire skill execution automatically with `template` (deterministic) or `llm` (context-aware) actions; see [`docs/SKILLS.md`](docs/SKILLS.md)
+- Deduplicates inbound messages via event-ID cache and FNV-1a fingerprint debounce window
+- Appends every outbound LLM context payload to [`context.log`](context.log)
+- Localhost HTTP admin API on port `8484` — inspect context, run prompts, compare variants, change model at runtime
 
 ## Quick Start
 
-### Prerequisites
+### Download binary (recommended)
 
-- GCC with C99 support
-- libcurl, libssl, libcrypto, libsecp256k1
+1. Download the latest release binary from Gitea: [https://git.laantungir.net/laantungir/didactyl/releases](https://git.laantungir.net/laantungir/didactyl/releases)
+2. Make it executable and run it:
+
+```bash
+chmod +x ./didactyl_static_x86_64
+./didactyl_static_x86_64 --config ./config.jsonc
+```
+
+### Build from source (optional)
+
+#### Prerequisites
+
+- Docker (for static binary build)
 - An OpenAI-compatible LLM API key (OpenAI, PPQ, Ollama, etc.)
 - A Nostr keypair (nsec)
 
-### Build
+#### Build
 
 ```bash
-make deps   # builds nostr_core_lib
-make        # builds didactyl
+./build_static.sh    # builds a fully static MUSL binary via Docker
 ```
 
 ### Configure
 
-Edit `config.json`:
+Edit [`config.jsonc`](config.jsonc):
 
 ```json
 {
-  "agent": {
-    "name": "Didactyl Agent",
-    "display_name": "Didactyl",
-    "about": "A sovereign AI agent on Nostr"
-  },
   "keys": {
-    "nsec": "nsec1..."
+    "nsec": "nsec1...",
+    "npub": "npub1...",
+    "npubHex": "<optional helper>",
+    "nsecHex": "<optional helper>"
   },
   "admin": {
     "pubkey": "npub1... or hex pubkey"
   },
-  "relays": [
-    "wss://relay.damus.io",
-    "wss://nos.lol"
-  ],
   "llm": {
-    "provider": "openai",
+    "provider": "openai|ppq|...",
     "api_key": "sk-...",
     "model": "gpt-4o-mini",
     "base_url": "https://api.openai.com/v1",
     "max_tokens": 512,
     "temperature": 0.7
-  }
+  },
+  "tools": {
+    "enabled": true,
+    "max_turns": 8,
+    "shell": {
+      "enabled": true,
+      "timeout_seconds": 30,
+      "max_output_bytes": 65536,
+      "working_directory": "."
+    }
+  },
+  "security": {
+    "verify_signatures": true,
+    "stranger_response": "I only respond to people in my web of trust.",
+    "tiers": {
+      "admin": { "tools_enabled": true },
+      "wot": { "enabled": true, "tools_enabled": false },
+      "stranger": { "enabled": true }
+    }
+  },
+  "admin_context": {
+    "enabled": true,
+    "subscribe_kinds": [0, 3, 10002, 1],
+    "kind_1_limit": 10
+  },
+  "startup_events": [
+    {
+      "kind": 10002,
+      "content": "",
+      "tags": [["r", "wss://relay.damus.io"], ["r", "wss://nos.lol"]]
+    },
+    {
+      "kind": 31120,
+      "content": "You are Didactyl...",
+      "tags": [["d", "soul"], ["app", "didactyl"], ["scope", "private"]]
+    },
+    {
+      "kind": 31123,
+      "content_fields": {"name": "long_form_note", "description": "..."},
+      "tags": [["d", "long_form_note"], ["app", "didactyl"], ["scope", "public"], ["slug", "long_form_note"]]
+    },
+    {
+      "kind": 10123,
+      "content": "",
+      "tags": [["a", "31123:<author-pubkey>:long_form_note"], ["app", "didactyl"], ["scope", "public"]]
+    }
+  ]
 }
 ```
 
-Edit `SYSTEM.md` to define the agent's personality and instructions.
+`startup_events[].content_fields` is accepted for human-readable authoring and encoded to JSON string content at runtime.
+
+Relays are sourced exclusively from startup kind `10002` `r` tags.
 
 ### Run
 
 ```bash
-./didactyl
+./didactyl_static_x86_64 --config ./config.jsonc
 ```
 
 Options:
+
 ```
-./didactyl --config <path>    # custom config file (default: ./config.json)
-./didactyl --context <path>   # custom context file (default: ./SYSTEM.md)
+./didactyl_static_x86_64 --config <path>                     # custom config file (default: ./config.jsonc)
+./didactyl_static_x86_64 --debug <0-5>                       # log verbosity (0 none, 3 info, 5 trace)
+./didactyl_static_x86_64 --dump-schemas                      # print tool JSON schemas and exit
+./didactyl_static_x86_64 --test-tool <name> <args_json>      # run one tool directly and print JSON result
+```
+
+CLI debugger notes:
+
+- `--test-tool` initializes Nostr, waits for at least one relay connection (up to 15s), then executes the selected tool.
+- Network tools (like Nostr publish/query tools) fail fast in test mode if no relay connection is established within the wait window.
+- Example:
+
+```bash
+./didactyl_static_x86_64 --config ./config.jsonc --test-tool nostr_file_md_to_longform_post '{"file":"docs/SKILLS.md","title":"SKILLS"}'
 ```
 
 ### Talk to it
 
-Send an encrypted DM to the agent's pubkey from the admin account using any Nostr client (Damus, Amethyst, Primal, etc.).
+Send an encrypted DM to the agent pubkey using any Nostr client (Damus, Amethyst, Primal, etc.): ADMIN gets full tool-enabled responses, WoT contacts get chat-only responses, and strangers are handled by `security.tiers.stranger` + `security.stranger_response`.
+
+### Chat via local HTTP API (CLI)
+
+A simple Node.js terminal client is available in [`didactyl-chat-cli.js`](didactyl-chat-cli.js).
+
+Run it with:
+
+```bash
+node ./didactyl-chat-cli.js
+```
+
+Optional environment variables:
+
+- `DIDACTYL_API_BASE_URL` (default: `https://127.0.0.1:8484`)
+- `DIDACTYL_MODEL` (optional model override)
+- `DIDACTYL_MAX_TURNS` (default: `4`)
+- `DIDACTYL_INSECURE_TLS` (default: `1`, set `0` to enforce certificate verification)
+
+Example:
+
+```bash
+DIDACTYL_API_BASE_URL=http://127.0.0.1:8484 DIDACTYL_MAX_TURNS=6 node ./didactyl-chat-cli.js
+```
+
+The CLI prints each message block with a speaker label (`You` / `Didactyl`) and a blank line between blocks for readability.
 
 ## Architecture
 
 ```
-┌─────────────────────────────────────────────┐
-│                 Didactyl                     │
-│                                             │
-│  ┌─────────┐  ┌─────────┐  ┌────────────┐  │
-│  │ config  │  │ context │  │   agent    │  │
-│  │ loader  │  │ loader  │  │   loop     │  │
-│  └────┬────┘  └────┬────┘  └─────┬──────┘  │
-│       │            │             │          │
-│       ▼            ▼             ▼          │
-│  ┌─────────────────────────────────────┐    │
-│  │          nostr_handler              │    │
-│  │  relay pool · subscribe · publish   │    │
-│  └──────────────────┬──────────────────┘    │
-│                     │                       │
-│  ┌──────────────────┴──────────────────┐    │
-│  │           LLM client                │    │
-│  │   OpenAI-compatible chat API        │    │
-│  └─────────────────────────────────────┘    │
-└─────────────────────────────────────────────┘
+┌──────────────────────────────────────────────┐
+│                  Didactyl                    │
+│                                              │
+│  ┌──────────┐  ┌──────────┐  ┌────────────┐  │
+│  │  config  │  │  context │  │   agent    │  │
+│  │  loader  │  │  loader  │  │   loop     │  │
+│  └────┬─────┘  └────┬─────┘  └─────┬──────┘  │
+│       │             │              │         │
+│       ▼             ▼              ▼         │
+│  ┌─────────────────────────────────────┐     │
+│  │           nostr_handler             │     │
+│  │  relay pool · subscribe · publish   │     │
+│  └──────────────────┬──────────────────┘     │
+│                     │                        │
+│  ┌──────────────────┴──────────────────┐     │
+│  │            LLM client               │     │
+│  │    OpenAI-compatible chat API       │     │
+│  └─────────────────────────────────────┘     │
+└──────────────────────────────────────────────┘
          │                        │
          ▼                        ▼
    Nostr Relays              LLM API
 ```
 
+## Didactyl Kinds (Nostr)
+
+Didactyl uses a two-layer skill model: authors publish skill definitions, and adopters publish which skills they use.
+
+- `31120` — **Soul** (private instruction baseline)
+  - `d=soul`
+- `31123` — **Public Skill Definition** (replaceable by `d` tag)
+  - `content` is JSON with fields like `description`, `context_mode`, `llm`, `tools`, `template`, optional `max_tokens` / `temperature`
+  - `d=<skill_slug>` (example: `d=long_form_note`)
+- `31124` — **Private Skill Definition** (same schema as `31123`, private scope)
+  - `d=<skill_slug>` (example: `d=admin_ops`)
+- `10123` — **Skill Adoption List**
+  - tags contain one or more `a` references to selected skills
+
+Context modes:
+- `inject` — skill instructions are layered into soul context
+- `full` — skill provides full prompt template (soul optional via `{{soul}}`)
+- `override` — skill replaces soul prompt, standard context structure remains
+
+Full skill schema, trigger tags, template variables, fallback resolution, and limits are documented in [`docs/SKILLS.md`](docs/SKILLS.md).
+
+## Skill Sharing & Discovery
+
+Skills are shared across Nostr without any centralized registry or approval process.
+
+### How it works
+
+1. **Publish**: An author publishes a skill as a kind `31123` event. The `content` field contains the skill body (markdown or structured JSON). The `d` tag is the skill's slug (e.g. `long_form_note`).
+2. **Adopt**: An agent that wants to use a skill adds an `a`-tag reference to its kind `10123` adoption list. This is a public, replaceable event — anyone can see which skills an agent uses.
+3. **Discover**: A new user queries `{"kinds": [10123], "authors": [<my-follows>]}` to see which skills their web of trust has adopted. The most-referenced `31123` addresses are the most popular skills — no rating system needed.
+4. **Improve**: Anyone can publish their own `31123` with the same slug but a different pubkey. If their version is better, people adopt it instead. Competition happens through adoption, not through a store ranking.
+
+### Why this works
+
+- **No gatekeeper**: Skills are just Nostr events. Anyone can publish one.
+- **WoT as curation**: You see what people you trust actually use, not what an algorithm promotes.
+- **Visible adoption**: The `10123` list is public. Popularity is a countable fact, not a manipulable score.
+- **Censorship resistant**: Skills live on relays. No single entity can remove a skill from the network.
+
+## Startup
+
+Didactyl startup behavior is configured in [`config.jsonc`](config.jsonc) under `startup_events`.
+
+Also used at startup:
+
+- `0` — profile metadata
+- `10002` — relay list
+- `1` — optional startup note/status
+- `3` — contacts/follows (optional placeholder)
+
+On boot, Didactyl attempts startup publishes to each relay as that relay transitions to connected state.
+
+## Runtime Context Model
+
+Didactyl builds tier-aware context:
+
+- **ADMIN** request context — assembled from the soul's `---template---` section (if present), otherwise hardcoded order:
+  1. Soul personality (everything above `---template---` in kind `31120`)
+  2. Named template sections in order using `tool:` directives (for example `nostr_admin_profile`, `nostr_admin_notes`, `task_list`, `message_current`, `dm_history`)
+  3. Each section executes its configured context tool, optionally extracting `result_field` (default: `content`)
+  4. Provider-specific content overrides per section remain supported for literal `content:` sections
+  5. Section names are used in `context.log` headers and `/api/context/parts` response
+- **WoT** request context: Soul + WoT chat-only instruction + current user message (no tools)
+- **STRANGER**: no LLM call when configured to reply statically
+
+Every serialized LLM context payload is appended to [`context.log`](context.log).
+
+Triggered skills and tool loops are bounded by runtime safeguards (for example, trigger cooldowns and action rate limits); see [`docs/SKILLS.md`](docs/SKILLS.md) for the current defaults.
+
+## Tooling Interface
+
+Current tool schema exposed to the LLM in [`tools_build_openai_schema_json()`](src/tools.c:881):
+
+- Nostr publish/query:
+  - `nostr_post`
+  - `nostr_post_readme`
+  - `nostr_query`
+- Nostr interaction and moderation:
+  - `nostr_delete`
+  - `nostr_react`
+  - `nostr_profile_get`
+  - `nostr_relay_status`
+  - `nostr_relay_info`
+  - `nostr_nip05_lookup`
+- Nostr encode/decode + encryption/DM:
+  - `nostr_encode`
+  - `nostr_decode`
+  - `nostr_encrypt`
+  - `nostr_decrypt`
+  - `nostr_dm_send`
+  - `nostr_dm_send_nip17`
+- Nostr list management:
+  - `nostr_list_manage`
+- Skill management:
+  - `skill_create`
+  - `skill_list`
+  - `skill_adopt`
+  - `skill_remove`
+  - `skill_search`
+- Local/host tools:
+  - `local_shell_exec`
+  - `local_file_read`
+  - `local_file_write`
+  - `local_http_fetch`
+- Agent metadata:
+  - `agent_version`
+- Model management:
+  - `model_get`
+  - `model_set`
+  - `model_list`
+
+Execution entrypoint: [`tools_execute()`](src/tools.c:3765).
+
+## HTTP Admin API
+
+A localhost-only HTTP API on port `8484` (configurable) for agent inspection and prompt crafting. Enable with `"api": {"enabled": true}` in config.
+
+| Endpoint | Purpose |
+|---|---|
+| `GET /api/status` | Agent name, version, pubkey, relay count, trigger count |
+| `GET /api/context/current` | Full LLM context messages array |
+| `GET /api/context/parts` | Context broken into named parts with token estimates |
+| `POST /api/prompt/run-simple` | Run a simple system+user prompt, no tools |
+| `POST /api/prompt/run` | Run a full messages array with tools enabled |
+| `POST /api/prompt/compare` | A/B compare two prompt variants |
+| `GET /api/model` | Current LLM model config |
+| `PUT /api/model` | Change model at runtime (persists to config.jsonc) |
+| `GET /api/models` | List available models from provider |
+
+Full reference: [`docs/API.md`](docs/API.md). Frontend brief: [`plans/admin_web_frontend.md`](plans/admin_web_frontend.md).
+
 ## Project Structure
 
 ```
 .
-├── config.json          # Agent configuration
-├── SYSTEM.md            # Agent personality/instructions for LLM
+├── config.jsonc         # Agent/runtime config (JSONC with comments) including startup_events + tools
+├── context.log          # Appended outbound LLM context payloads
 ├── Makefile             # Build system
+├── build_static.sh      # Preferred final build validation
 ├── src/
-│   ├── main.c           # Entry point, signal handling, daemon loop
-│   ├── config.c / .h    # JSON config parsing, key decoding
-│   ├── context.c / .h   # SYSTEM.md file loader
-│   ├── agent.c / .h     # Core agent logic: receive → LLM → respond
-│   ├── llm.c / .h       # LLM HTTP API client (OpenAI-compatible)
-│   ├── nostr_handler.c / .h  # Relay pool, subscriptions, publish, DMs
-│   └── secp_compat.c    # secp256k1 API compatibility shim
+│   ├── main.c / .h           # Entry point, args (--config/--debug), lifecycle, version
+│   ├── config.c / .h         # JSON config parsing, key decode, startup events
+│   ├── context.c / .h        # File loader utility (reads file into malloc'd string)
+│   ├── agent.c / .h          # Context assembly, tool loop, DM response flow
+│   ├── prompt_template.c / .h # Soul template parser, variable resolver, context builder
+│   ├── tools.c / .h          # LLM tool schema and tool execution
+│   ├── llm.c / .h            # LLM HTTP API client (OpenAI-compatible)
+│   ├── nostr_handler.c / .h  # Relay pool, subscriptions, publish, startup reconcile
+│   ├── trigger_manager.c / .h # Nostr event trigger subscriptions and skill execution
+│   ├── http_api.c / .h       # Localhost HTTP admin API (mongoose-based)
+│   ├── mongoose.c / .h       # Embedded HTTP server (mongoose)
+│   └── debug.c / .h          # Runtime log levels/macros
+├── docs/
+│   ├── API.md                # HTTP admin API endpoint reference
+│   ├── TOOLS.md              # Tool architecture and catalog
+│   ├── SKILLS.md             # Skill schema, context modes, triggers, and limits
+│   └── CRASH_FIXES.md        # Crash analysis and fixes log
 ├── plans/               # Architecture and planning documents
-│   ├── didactyl_mvp.md
-│   └── didactyl_agentic.md
 └── README.md
 ```
 
 ## Dependencies
 
+All dependencies are statically linked into the binary at build time. No system libraries are required at runtime.
+
 | Dependency | Purpose | Source |
 |---|---|---|
 | nostr_core_lib | Nostr protocol: keys, events, NIPs, relay pool | Workspace (sibling directory) |
 | cJSON | JSON parsing | Bundled in nostr_core_lib |
-| libcurl | HTTPS for LLM API calls | System package |
-| libssl / libcrypto | TLS for WebSocket relay connections | System package |
-| libsecp256k1 | Schnorr signatures, ECDH | System package |
+| libcurl | HTTPS for LLM API calls | Statically linked (Alpine/MUSL) |
+| libssl / libcrypto | TLS for WebSocket relay connections | Statically linked (Alpine/MUSL) |
+| libsecp256k1 | Schnorr signatures, ECDH | Statically linked (Alpine/MUSL) |
+
+## Roadmap: Nostr-Native Portability
+
+Didactyl's long-term architecture goal is **zero filesystem dependency after first boot**. The config file is the only tie to the local filesystem. The plan:
+
+1. **First boot** — Read `config.jsonc`, publish all identity, soul, skills, and adoption list as Nostr events to relays.
+2. **Subsequent boots** — Given only the agent's keys, retrieve everything needed from Nostr relays: soul, skills, adoption list, trigger definitions, admin pubkey, relay list. No config file required.
+3. **True portability** — Start your agent from any computer. All you need are its keys. All state lives on Nostr.
+
+This makes Didactyl fundamentally different from filesystem-bound agents. Destroying the host computer does not kill the agent — its identity, memory, and capabilities persist on the relay network.
+
+### What already lives on Nostr
+
+| Data | Event Kind | Status |
+|---|---|---|
+| Agent profile | Kind 0 | Implemented |
+| Relay list | Kind 10002 | Implemented |
+| DM relay list | Kind 10050 | Implemented |
+| Public skills | Kind 31123 | Implemented |
+| Private skills | Kind 31124 | Implemented |
+| Skill adoption list | Kind 10123 | Implemented |
+| Soul/personality | Kind 31120 | Implemented |
+| Trigger definitions | Tags on skill events | Implemented |
+
+### What still needs migration
+
+| Data | Current Location | Target |
+|---|---|---|
+| Admin pubkey | `config.jsonc` | Derive from kind 3 contact list or dedicated config event |
+| LLM provider/key | `config.jsonc` | Encrypted kind 30078 app-specific event or NIP-78 |
+| Security tiers | `config.jsonc` | Agent config event on Nostr |
+| API settings | `config.jsonc` | Local-only — stays on filesystem as runtime flag |
 
 ## Roadmap
 
 - [x] MVP chat agent — DM in, LLM response out
 - [x] Relay pool with auto-reconnect and status logging
-- [x] Runtime diagnostics — relay health, message flow, LLM calls
-- [ ] **Agentic tool-use** — LLM can call tools (nostr_post, nostr_query, shell_exec)
+- [x] Per-relay startup publish on relay-connected transitions
+- [x] Runtime diagnostics — relay health, message flow, event kind publish logs
+- [x] Tool-calling loop (nostr_post, nostr_query, local_shell_exec, local_file_read, local_file_write)
+- [x] Context assembly with startup events + recent DM history
+- [x] Context payload logging to [`context.log`](context.log)
+- [x] Skill kind definitions (`31120` Soul, `31123` Public Skill, `31124` Private Skill)
+- [x] Skill adoption list (`10123`) for WoT-driven discovery
+- [x] Signature verification on all inbound events
+- [x] Privilege tiers — ADMIN (tools), WoT (chat-only), STRANGER (canned reply/ignore)
+- [x] Admin context subscription (kind 0, 3, 10002, 1) with WoT contact extraction
+- [x] Message deduplication (event-ID cache + FNV-1a fingerprint debounce)
+- [x] Adopted skills injected into LLM context automatically
+- [x] Triggered skills — Nostr event filters that fire skill execution automatically
+- [x] Localhost HTTP admin API — context inspection, prompt crafting, A/B comparison
+- [x] Runtime model switching via `model_set` tool (persists to config.jsonc)
+- [x] Soul-embedded prompt templates (`---template---`) — configurable context order, variable resolution, provider overrides
+- [ ] Runtime skill loading from adopted `31123` events on relays
+- [ ] Skill discovery CLI/tool (query WoT adoption lists)
 - [ ] Upgrade to NIP-17 gift-wrapped DMs
+- [ ] NIP-44 encrypted private skills (`31124`)
 - [ ] Nostr-native data storage (kind 30078 app-specific events)
 - [ ] Blossom blob storage integration
-- [ ] Conversation memory on Nostr
-- [ ] Config and SYSTEM.md stored as Nostr events
-- [ ] Multi-turn conversation context window
 - [ ] Agent-to-agent communication
 
 ## License
 
 TBD
+

SYSTEM.md

@@ -1,24 +0,0 @@
-# Didactyl Agent
-
-You are Didactyl, a sovereign AI agent living on Nostr.
-
-## Communication Rules
-- You communicate through encrypted Nostr direct messages.
-- Keep responses concise and clear.
-
-## Behavior
-- Be helpful and technically accurate.
-- If unsure, state uncertainty directly.
-- Prefer actionable, practical advice.
-
-## Tool Use Policy
-- You have tools available and should use them when a request requires taking action.
-- For requests involving local inspection or command execution, call `shell_exec` instead of refusing.
-- For posting to Nostr, call `nostr_post` with explicit `kind` and `content`.
-- For relay/event lookup tasks, call `nostr_query` with an appropriate filter.
-- After a tool call, base your answer on the actual tool result.
-- Never claim a tool was run if no tool was executed.
-
-## Safety
-- Do not claim to have executed actions you did not execute.
-- Do not reveal secrets from configuration or keys.

chat-didactyl-cli.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+/**
+ * Simple terminal chat client for Didactyl HTTP API.
+ *
+ * Usage:
+ *   node didactyl-chat-cli.js
+ *
+ * Optional env vars:
+ *   DIDACTYL_API_BASE_URL=http://127.0.0.1:8484
+ *   DIDACTYL_MODEL=claude-haiku-4.5
+ *   DIDACTYL_MAX_TURNS=4
+ */
+
+const readline = require("node:readline/promises");
+const { stdin, stdout } = require("node:process");
+const http = require("node:http");
+const https = require("node:https");
+
+const API_BASE_URL = process.env.DIDACTYL_API_BASE_URL || "https://127.0.0.1:8484";
+const MODEL = process.env.DIDACTYL_MODEL || "";
+const MAX_TURNS = Number.parseInt(process.env.DIDACTYL_MAX_TURNS || "4", 10);
+const INSECURE_TLS = !["0", "false", "False", "FALSE"].includes(
+  String(process.env.DIDACTYL_INSECURE_TLS || "1")
+);
+
+function printMessage(role, content) {
+  const who = role === "user" ? "You" : role === "assistant" ? "Didactyl" : role;
+  console.log(`${who}>`);
+  console.log(content);
+  console.log("");
+}
+
+function postJson(urlString, payload) {
+  const url = new URL(urlString);
+  const isHttps = url.protocol === "https:";
+  const data = JSON.stringify(payload);
+
+  const options = {
+    method: "POST",
+    hostname: url.hostname,
+    port: url.port,
+    path: url.pathname + url.search,
+    headers: {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(data),
+    },
+  };
+
+  if (isHttps) {
+    options.rejectUnauthorized = !INSECURE_TLS;
+  }
+
+  const client = isHttps ? https : http;
+
+  return new Promise((resolve, reject) => {
+    const req = client.request(options, (res) => {
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => {
+        resolve({
+          statusCode: res.statusCode || 0,
+          body,
+        });
+      });
+    });
+
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+async function callDidactyl(message) {
+  const body = {
+    message,
+    max_turns: Number.isFinite(MAX_TURNS) ? MAX_TURNS : 4,
+  };
+
+  if (MODEL.trim()) {
+    body.model = MODEL.trim();
+  }
+
+  const { statusCode, body: responseBody } = await postJson(`${API_BASE_URL}/api/prompt/agent`, body);
+
+  if (statusCode < 200 || statusCode >= 300) {
+    throw new Error(`HTTP ${statusCode}: ${responseBody}`);
+  }
+
+  let data;
+  try {
+    data = JSON.parse(responseBody);
+  } catch {
+    throw new Error(`Invalid JSON from API: ${responseBody}`);
+  }
+
+  if (!data.success) {
+    throw new Error(data.error || "Didactyl API returned success=false");
+  }
+
+  return String(data.final_response || "");
+}
+
+async function main() {
+  console.log("Didactyl CLI chat");
+  console.log(`API: ${API_BASE_URL}`);
+  console.log(`TLS verify: ${INSECURE_TLS ? "disabled (local dev)" : "enabled"}`);
+  console.log("Type /exit to quit.\n");
+
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+
+  try {
+    while (true) {
+      const input = (await rl.question("You> ")).trim();
+
+      if (!input) {
+        console.log("");
+        continue;
+      }
+
+      if (input === "/exit" || input === "/quit") {
+        console.log("Exiting.");
+        break;
+      }
+
+      console.log("");
+
+      try {
+        const reply = await callDidactyl(input);
+        printMessage("assistant", reply);
+        console.log("");
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Didactyl error: ${message}`);
+        console.error("");
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`Fatal error: ${message}`);
+  process.exit(1);
+});

config.jsonc.example

@@ -0,0 +1,333 @@
+{
+  // ─── Agent Identity Keys ───────────────────────────────────────────
+  // Your agent's Nostr keypair. Provide nsec (bech32) or hex format.
+  // The public key fields are optional — they are derived automatically.
+  "keys": {
+    "nsec": "agent nsec",
+    "npub": "agent npub",
+    "npubHex": "agent hex pubkey",
+    "nsecHex": "agent hex secret key"
+  },
+
+  // ─── Administrator ─────────────────────────────────────────────────
+  // The admin pubkey (npub or hex) controls who can issue privileged
+  // commands and use tools via DM.
+  "admin": {
+    "pubkey": "admin pubkey"
+  },
+
+  // ─── DM Protocol ──────────────────────────────────────────────────
+  // Which encrypted DM protocol to use: "nip04", "nip17", or "both"
+  "dm_protocol": "nip04",
+
+  // ─── LLM Provider ─────────────────────────────────────────────────
+  // Configure the language model backend. Any OpenAI-compatible API works.
+  "llm": {
+    "provider": "",       // e.g. "openai", "anthropic", etc.
+    "api_key": "",        // your API key
+    "model": "",          // model identifier, e.g. "gpt-4o-mini"
+    "base_url": "",       // API base URL, e.g. "https://api.openai.com/v1"
+    "max_tokens": 512,    // max tokens per LLM response
+    "temperature": 0.7    // sampling temperature (0.0 – 2.0)
+  },
+
+  // ─── Tools & Runtime Limits ───────────────────────────────────────
+  // Centralized turn and timeout limits used by DM agent loops,
+  // triggered skills, HTTP API prompt runs, and local HTTP fetch tool.
+  "tools": {
+    "enabled": true,
+    "max_turns": 8,                             // default max turns for normal agent tool loops
+    "trigger_max_turns": 6,                     // max turns for triggered-skill executions
+    "api_default_max_turns": 4,                 // default when HTTP body omits max_turns
+    "api_max_turns_ceiling": 16,                // hard cap applied to API-provided max_turns
+    "local_http_fetch_default_timeout_seconds": 20,
+    "local_http_fetch_max_timeout_seconds": 120,
+    "shell": {
+      "enabled": true,
+      "timeout_seconds": 30,
+      "max_output_bytes": 65536,
+      "working_directory": "."
+    }
+  },
+
+  // ─── Security Tiers ───────────────────────────────────────────────
+  // Controls who can interact with the agent and what they can do.
+  "security": {
+    "verify_signatures": true,  // verify Nostr event signatures
+    // Message sent to strangers outside the web of trust
+    "stranger_response": "I only respond to people in my web of trust. You can always identify me by my public key (npub).",
+    "tiers": {
+      "admin": {
+        "tools_enabled": true   // admin can always use tools
+      },
+      "wot": {
+        "enabled": true,        // respond to web-of-trust contacts
+        "tools_enabled": false  // WoT contacts cannot use tools by default
+      },
+      "stranger": {
+        "enabled": true         // respond to strangers (with stranger_response)
+      }
+    }
+  },
+
+  // ─── Admin Context Subscriptions ──────────────────────────────────
+  // Subscribe to the admin's Nostr events to build context awareness.
+  "admin_context": {
+    "enabled": true,
+    "subscribe_kinds": [
+      0,      // kind 0: profile metadata
+      3,      // kind 3: contact list
+      10002,  // kind 10002: relay list
+      1       // kind 1: text notes
+    ],
+    "kind_1_limit": 10  // max recent kind-1 notes to track
+  },
+
+  // ─── HTTP Admin API ───────────────────────────────────────────────
+  // Local REST API for runtime inspection and control.
+  "api": {
+    "enabled": true,
+    "port": 8484,
+    "bind_address": "127.0.0.1"  // bind to localhost only
+  },
+
+  // ─── Startup Events ───────────────────────────────────────────────
+  // Events published on boot. Includes profile, relay list, soul,
+  // skills, and adoption list.
+  "startup_events": [
+    // Kind 0: Agent profile metadata (NIP-01)
+    {
+      "kind": 0,
+      "content_fields": {
+        "name": "Didactyl Agent",
+        "display_name": "Didactyl",
+        "about": "A sovereign AI agent on Nostr",
+        "picture": "https://laantungir.github.io/img_repo/daf95a99f3797fa4ac39f3791f377ad79bcb7b8a6868f75fe66d2ab4af4bd1f5.png",
+        "banner": "https://laantungir.github.io/img_repo/d21c4060632ab3d9d37a6062eeecbdbfbd67f03cb20dbd64838b1ba0d9cd8922.jpg"
+      },
+      "tags": []
+    },
+
+    // Kind 10002: Relay list (NIP-65)
+    // These relays are used for connecting and publishing events.
+    {
+      "kind": 10002,
+      "content": "",
+      "tags": [
+        ["r", "wss://relay.damus.io"],
+        ["r", "wss://nos.lol"],
+        ["r", "wss://relay.primal.net"],
+        ["r", "ws://127.0.0.1:7777"]
+      ]
+    },
+
+    // Kind 10050: DM relay list (NIP-17)
+    // Relays used specifically for receiving encrypted DMs.
+    {
+      "kind": 10050,
+      "content": "",
+      "tags": [
+        ["relay", "wss://relay.damus.io"],
+        ["relay", "wss://nos.lol"]
+      ]
+    },
+
+    // Kind 1: Startup announcement note
+    {
+      "kind": 1,
+      "content": "Hello world from Didactyl startup",
+      "tags": [
+        ["t", "didactyl"],
+        ["t", "startup"]
+      ]
+    },
+
+    // Kind 3: Contact list (initially empty)
+    {
+      "kind": 3,
+      "content": "",
+      "tags": []
+    },
+
+    // Kind 31120: Soul event — the agent's personality and behavior rules.
+    // Contains the system prompt and template sections for LLM context.
+    // The ---template--- marker separates the system prompt from
+    // structured context sections that are injected at runtime.
+    {
+      "kind": 31120,
+      "content": "# Didactyl Agent\n\nYou are Didactyl, a sovereign AI agent living on Nostr.\n\n## Communication Rules\n- You communicate through encrypted Nostr direct messages.\n- Keep responses concise and clear.\n\n## Behavior\n- Be helpful and technically accurate.\n- If unsure, state uncertainty directly.\n- Prefer actionable, practical advice.\n- Use the person's name when messaging them if you know it.\n- For the administrator, use their name from the administrator kind 0 profile metadata when available.\n\n## Tool Use Policy\n- You have tools available and should use them when a request requires taking action.\n- For requests involving local inspection or command execution, call `local_shell_exec` instead of refusing.\n- For posting to Nostr, call `nostr_post` with explicit `kind` and `content`.\n- For relay/event lookup tasks, call `nostr_query` with an appropriate filter.\n- After a tool call, base your answer on the actual tool result.\n- Never claim a tool was run if no tool was executed.\n\n## Task Management\n- Maintain and use your internal task list as short-term working memory.\n- Break long or complex actions into clear tasks before executing them.\n- Update task status as you complete steps so your plan stays accurate.\n\n## Safety\n- Do not claim to have executed actions you did not execute.\n- You may share your public key (npub) with anyone.\n- Never reveal your private key (nsec) under any circumstance.\n\n---template---\n\n- section: admin_identity\n  role: system\n  content: |\n    ## Administrator Identity (source: config.admin.pubkey)\n\n    This is your administrator! Admin pubkey (hex): {{admin_pubkey}}\n\n- section: admin_profile\n  role: system\n  content: |\n    ## Administrator Kind 0 Profile (source: nostr kind 0)\n\n    Administrator kind 0 profile content (JSON): {{admin_kind0_json}}\n  provider:\n    anthropic: |\n      <admin_kind0_profile source=\"nostr_kind_0\">\n      {{admin_kind0_json}}\n      </admin_kind0_profile>\n\n- section: admin_contacts\n  role: system\n  content: |\n    ## Administrator Contact List (source: nostr kind 3)\n\n    Administrator kind 3 contact list pubkeys (JSON array): {{admin_kind3_json}}\n  provider:\n    anthropic: |\n      <admin_contacts source=\"nostr_kind_3\">\n      {{admin_kind3_json}}\n      </admin_contacts>\n\n- section: admin_relays\n  role: system\n  content: |\n    ## Administrator Relay List (source: nostr kind 10002)\n\n    Administrator kind 10002 relay list (JSON): {{admin_kind10002_json}}\n  provider:\n    anthropic: |\n      <admin_relays source=\"nostr_kind_10002\">\n      {{admin_kind10002_json}}\n      </admin_relays>\n\n- section: admin_notes\n  role: system\n  content: |\n    ## Administrator Recent Notes (source: nostr kind 1)\n\n    Administrator recent kind 1 notes (JSON array): {{admin_kind1_json}}\n  provider:\n    anthropic: |\n      <admin_notes source=\"nostr_kind_1\">\n      {{admin_kind1_json}}\n      </admin_notes>\n\n- section: skills\n  role: system\n  content: |\n    ## Adopted Skills\n\n    {{skills_json}}\n\n- section: tasks\n  role: system\n  content: |\n    ## Current Task List\n\n    {{tasks_json}}\n\n- section: conversation\n  role: conversation\n  content: |\n    {{conversation}}",
+      "tags": [
+        ["d", "soul"],
+        ["app", "didactyl"],
+        ["scope", "private"]
+      ]
+    },
+
+    // Kind 31123: Public skill — long_form_note
+    // Teaches the agent how to publish NIP-23 long-form articles.
+    {
+      "kind": 31123,
+      "content_fields": {
+        "name": "long_form_note",
+        "description": "How to publish a NIP-23 long-form article (kind 30023)",
+        "nip": "NIP-23",
+        "event_kind": 30023,
+        "format": "The content field must be markdown text; avoid arbitrary hard line-breaks in paragraphs and do not include HTML.",
+        "required_tags": {
+          "d": "Addressable identifier slug for the article. Reusing the same d tag replaces prior versions.",
+          "title": "Human-readable article title.",
+          "published_at": "Unix timestamp as a string for first publication time; keep stable on edits."
+        },
+        "optional_tags": {
+          "summary": "Short 1-2 sentence summary.",
+          "image": "URL for article preview image.",
+          "t": "Topic hashtags using repeated t tags, usually 3-6 lowercase terms."
+        },
+        "behavior": "If required values are missing or unclear, ask the administrator before publishing instead of guessing.",
+        "procedure": [
+          "Determine title and d tag from admin input or source material.",
+          "Draft markdown body content.",
+          "Set published_at as unix seconds string.",
+          "Add optional summary/image/t tags when known.",
+          "Publish with nostr_post kind 30023 including tags array."
+        ]
+      },
+      "tags": [
+        ["d", "long_form_note"],
+        ["app", "didactyl"],
+        ["scope", "public"],
+        ["slug", "long_form_note"]
+      ]
+    },
+
+    // Kind 31123: Public skill — post_readme_to_nostr
+    // Reads README.md and publishes it as a long-form note.
+    {
+      "kind": 31123,
+      "content_fields": {
+        "name": "post_readme_to_nostr",
+        "description": "Read README.md from the repo and publish it as a NIP-23 long-form note",
+        "uses_skill": "long_form_note",
+        "event_kind": 30023,
+        "procedure": [
+          "Read README.md using local_file_read with path README.md.",
+          "Set d tag exactly to readme.md.",
+          "Set title from the first markdown H1 heading in README.md.",
+          "Set summary from the opening paragraph of README.md.",
+          "Set image from project metadata when available (kind 0 picture/banner), otherwise omit image tag.",
+          "Generate 3-6 lowercase t tags from README section topics.",
+          "Set published_at to current unix timestamp as string.",
+          "Publish with nostr_post kind 30023, full README markdown in content, and full NIP-23 tag set."
+        ],
+        "required_values": {
+          "d": "readme.md",
+          "summary_source": "opening paragraph"
+        }
+      },
+      "tags": [
+        ["d", "post_readme_to_nostr"],
+        ["app", "didactyl"],
+        ["scope", "public"],
+        ["slug", "post_readme_to_nostr"]
+      ]
+    },
+
+    // Kind 31123: Public triggered skill — cheerleader
+    // Watches for admin kind-1 notes and sends an encouraging DM.
+    {
+      "kind": 31123,
+      "content": "You are my personal cheerleader. When the admin posts a kind 1 note, read their note and send them a short DM that cheers them on, praises their effort, tells them they are good looking, and encourages them to keep going. Be warm, playful, and positive. Mention something specific from their note so it feels personal. Keep it to 2-3 sentences.",
+      "tags": [
+        ["d", "cheerleader"],
+        ["app", "didactyl"],
+        ["scope", "public"],
+        ["description", "Cheer on admin whenever they post a kind 1 note"],
+        ["trigger", "nostr-subscription"],
+        ["filter", "{\"kinds\":[1],\"authors\":[\"REPLACE_WITH_ADMIN_HEX_PUBKEY\"]}"],
+        ["action", "llm"],
+        ["enabled", "true"]
+      ]
+    },
+
+    // Kind 31124: Private skill — admin_ops
+    // Private operational procedures (admin-only).
+    {
+      "kind": 31124,
+      "content_fields": {
+        "name": "admin_ops",
+        "description": "Private operational procedures"
+      },
+      "tags": [
+        ["d", "admin_ops"],
+        ["app", "didactyl"],
+        ["scope", "private"],
+        ["slug", "admin_ops"]
+      ]
+    },
+
+    // Kind 31124: Private triggered skill — webhook-echo
+    // Example webhook trigger that emits a fixed DM response.
+    {
+      "kind": 31124,
+      "content": "When this webhook trigger fires, DM the admin with exactly: WEBHOOK_SOURCE_POC_OK",
+      "tags": [
+        ["d", "webhook-echo"],
+        ["app", "didactyl"],
+        ["scope", "private"],
+        ["description", "PoC webhook trigger skill"],
+        ["trigger", "webhook"],
+        ["filter", "{}"],
+        ["action", "llm"],
+        ["enabled", "true"]
+      ]
+    },
+
+    // Kind 31124: Private triggered skill — cron_poc
+    // Example cron trigger that runs every minute.
+    {
+      "kind": 31124,
+      "content": "DM the administrator with the current time, and tell him that your cron skill triggered.",
+      "tags": [
+        ["d", "cron_poc"],
+        ["app", "didactyl"],
+        ["scope", "private"],
+        ["description", "PoC cron trigger skill"],
+        ["trigger", "cron"],
+        ["filter", "*/1 * * * *"],
+        ["action", "template"],
+        ["enabled", "true"]
+      ]
+    },
+
+    // Kind 31124: Private triggered skill — chain_from_webhook_poc
+    // Example chain trigger that runs after webhook-echo completes.
+    {
+      "kind": 31124,
+      "content": "LOG: chain_from_webhook_poc fired",
+      "tags": [
+        ["d", "chain_from_webhook_poc"],
+        ["app", "didactyl"],
+        ["scope", "private"],
+        ["description", "PoC chain trigger skill"],
+        ["trigger", "chain"],
+        ["filter", "webhook-echo"],
+        ["action", "template"],
+        ["enabled", "true"]
+      ]
+    },
+
+    // Kind 10123: Skill adoption list
+    // References which public skills this agent has adopted.
+    {
+      "kind": 10123,
+      "content": "",
+      "tags": [
+        ["a", "31123:55993e3db0ed7bf07395fd44c2d695c224d195553a1aff7320a18e41679d9c7c:long_form_note"],
+        ["a", "31123:55993e3db0ed7bf07395fd44c2d695c224d195553a1aff7320a18e41679d9c7c:post_readme_to_nostr"],
+        ["a", "31123:55993e3db0ed7bf07395fd44c2d695c224d195553a1aff7320a18e41679d9c7c:cheerleader"],
+        ["app", "didactyl"],
+        ["scope", "public"]
+      ]
+    }
+  ]
+}

context_template.md

@@ -0,0 +1,67 @@
+# Context Template
+
+```yaml
+- section: admin_identity
+  role: system
+  tool: admin_identity
+  skip_if_empty: true
+
+- section: admin_profile
+  role: system
+  tool: nostr_admin_profile
+  skip_if_empty: true
+
+- section: admin_contacts
+  role: system
+  tool: nostr_admin_contacts
+  skip_if_empty: true
+
+- section: admin_relays
+  role: system
+  tool: nostr_admin_relays
+  skip_if_empty: true
+
+- section: admin_notes
+  role: system
+  tool: nostr_admin_notes
+  skip_if_empty: true
+
+- section: agent_identity
+  role: system
+  tool: agent_identity
+  skip_if_empty: true
+
+- section: agent_profile
+  role: system
+  tool: nostr_agent_profile
+  skip_if_empty: true
+
+- section: agent_contacts
+  role: system
+  tool: nostr_agent_contacts
+  skip_if_empty: true
+
+- section: agent_relays
+  role: system
+  tool: nostr_agent_relays
+  skip_if_empty: true
+
+- section: agent_notes
+  role: system
+  tool: nostr_agent_notes
+  skip_if_empty: true
+
+- section: tasks
+  role: system
+  tool: task_list
+  skip_if_empty: true
+
+- section: conversation
+  role: user
+  tool: message_current
+  skip_if_empty: true
+
+- section: dm_history
+  role: expand
+  limit: 12
+```

docs/API.md

@@ -0,0 +1,532 @@
+# Didactyl Admin HTTP API
+
+## Overview
+
+Didactyl exposes a localhost-only HTTP API for external tools and dashboards to inspect agent state, explore LLM context, craft prompts, and compare prompt variants. The API runs inside the same process as the agent — no separate server, no authentication required.
+
+All responses are JSON. CORS headers are included on every response for browser access from any local origin.
+
+---
+
+## Configuration
+
+Enable the API in `config.jsonc`:
+
+```json
+{
+  "api": {
+    "enabled": true,
+    "port": 8484,
+    "bind_address": "127.0.0.1"
+  }
+}
+```
+
+| Field | Type | Default | Description |
+|---|---|---|---|
+| `enabled` | bool | `false` | Must be explicitly set to `true` to start the HTTP server |
+| `port` | int | `8484` | TCP port to listen on |
+| `bind_address` | string | `"127.0.0.1"` | Bind address — use `127.0.0.1` for localhost-only access |
+
+The API is disabled by default. When disabled, no listener is created and no resources are consumed.
+
+---
+
+## CORS
+
+Every response includes:
+
+```
+Access-Control-Allow-Origin: *
+Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
+Access-Control-Allow-Headers: Content-Type
+```
+
+`OPTIONS` requests return `204 No Content` with these headers for browser preflight support.
+
+---
+
+## Endpoints
+
+### GET /api/status
+
+Returns agent runtime status.
+
+**Response:**
+
+```json
+{
+  "success": true,
+  "name": "Didactyl",
+  "version": "v0.0.26",
+  "pubkey": "52a3e82f7b3743852fbe804cfcbf4db3448115887895247c001f2b50e790acb8",
+  "relay_count": 4,
+  "connected_relays": 4,
+  "active_triggers": 0
+}
+```
+
+| Field | Description |
+|---|---|
+| `name` | Agent display name constant |
+| `version` | Build version string |
+| `pubkey` | Agent public key in hex |
+| `relay_count` | Number of configured relays |
+| `connected_relays` | Number of currently connected relays |
+| `active_triggers` | Number of active triggered-skill subscriptions |
+
+---
+
+### GET /api/context/current
+
+Returns the full LLM context message array that would be sent to the model right now. This is the same context the agent builds for an admin DM conversation.
+
+**Response:**
+
+```json
+{
+  "success": true,
+  "total_chars": 13131,
+  "total_estimated_tokens": 3283,
+  "messages": [
+    {"role": "system", "content": "# Didactyl Agent\n\nYou are Didactyl..."},
+    {"role": "system", "content": "This is your administrator! Admin pubkey..."},
+    {"role": "system", "content": "Administrator kind 0 profile content..."},
+    {"role": "system", "content": "Administrator kind 10002 relay-list content..."},
+    {"role": "system", "content": "Startup events memory..."},
+    {"role": "system", "content": "Adopted skills memory..."},
+    {"role": "system", "content": "Administrator recent public notes..."}
+  ]
+}
+```
+
+| Field | Description |
+|---|---|
+| `total_chars` | Total character count across all messages |
+| `total_estimated_tokens` | Rough token estimate using `chars / 4` heuristic |
+| `messages` | OpenAI-format messages array with role and content |
+
+---
+
+### GET /api/context/parts
+
+Returns the context broken into labeled, individually-sized parts. Useful for understanding what consumes context budget.
+
+**Response:**
+
+```json
+{
+  "success": true,
+  "total_chars": 13131,
+  "total_estimated_tokens": 3283,
+  "parts": [
+    {
+      "name": "system_prompt",
+      "role": "system",
+      "chars": 1200,
+      "estimated_tokens": 300,
+      "content": "# Didactyl Agent..."
+    },
+    {
+      "name": "admin_identity",
+      "role": "system",
+      "chars": 120,
+      "estimated_tokens": 30,
+      "content": "This is your administrator!..."
+    },
+    {
+      "name": "admin_kind0",
+      "role": "system",
+      "chars": 450,
+      "estimated_tokens": 113,
+      "content": "Administrator kind 0 profile content..."
+    },
+    {
+      "name": "admin_relay_list",
+      "role": "system",
+      "chars": 50,
+      "estimated_tokens": 13,
+      "content": "Administrator kind 10002 relay-list content..."
+    },
+    {
+      "name": "startup_events",
+      "role": "system",
+      "chars": 4800,
+      "estimated_tokens": 1200,
+      "content": "Startup events memory..."
+    },
+    {
+      "name": "adopted_skills",
+      "role": "system",
+      "chars": 2100,
+      "estimated_tokens": 525,
+      "content": "Adopted skills memory..."
+    },
+    {
+      "name": "admin_notes",
+      "role": "system",
+      "chars": 680,
+      "estimated_tokens": 170,
+      "content": "Administrator recent public notes..."
+    }
+  ],
+  "messages": [...]
+}
+```
+
+**Part names:**
+
+| Name | Description |
+|---|---|
+| `system_prompt` | The agent soul / system prompt (first system message) |
+| `admin_identity` | Admin pubkey identification message |
+| `admin_kind0` | Admin kind 0 profile metadata |
+| `admin_relay_list` | Admin kind 10002 relay list |
+| `startup_events` | Startup events memory block |
+| `adopted_skills` | Adopted skills behavioral instructions |
+| `admin_notes` | Admin recent kind 1 public notes |
+| `dm_history` | Recent DM conversation history |
+| `context_part` | Any other context message |
+
+---
+
+### POST /api/trigger/:d_tag
+
+Fires a webhook-triggered skill by `d_tag`.
+
+**Path params:**
+
+| Param | Required | Description |
+|---|---|---|
+| `d_tag` | yes | Skill `d` tag of a skill configured with `trigger=webhook` |
+
+**Request body:**
+
+Optional JSON payload; if present it is passed into the synthetic trigger event as `payload`.
+
+```json
+{
+  "source": "external-cron",
+  "note": "run maintenance sweep"
+}
+```
+
+**Response:**
+
+```json
+{
+  "success": true,
+  "d_tag": "maintenance-sweep",
+  "fired": true
+}
+```
+
+**Notes:**
+
+- Returns `404` if no skill exists for `d_tag` or no active trigger is registered.
+- Returns `400` if the matched skill is not a `webhook` trigger or is disabled.
+- Trigger execution uses the same trigger cooldown policy as other trigger types.
+
+---
+
+### POST /api/prompt/run-simple
+
+Submit a system prompt and user message for a simple LLM call with no tools. Useful for quick prompt iteration.
+
+**Request:**
+
+```json
+{
+  "system": "You are a helpful assistant that writes tweets.",
+  "user": "Write a tweet about AI agents on Nostr",
+  "model": "claude-haiku-4.5"
+}
+```
+
+| Field | Required | Description |
+|---|---|---|
+| `system` | yes | System prompt string |
+| `user` | yes | User message string |
+| `model` | no | Override the current model for this request only |
+
+**Response:**
+
+```json
+{
+  "success": true,
+  "response": "AI agents are finding their home on Nostr...",
+  "model_used": "claude-haiku-4.5",
+  "input_tokens_estimate": 85,
+  "output_tokens_estimate": 42
+}
+```
+
+---
+
+### POST /api/prompt/agent
+
+Submit one user message and let Didactyl build full admin context server-side (same context assembly path used for Nostr admin DMs, including admin profile, adopted skills, and recent DM history).
+
+**Request:**
+
+```json
+{
+  "message": "Tweet about the weather",
+  "model": "claude-haiku-4.5",
+  "max_turns": 5
+}
+```
+
+| Field | Required | Description |
+|---|---|---|
+| `message` | yes | User message string |
+| `model` | no | Override the current model for this request only |
+| `max_turns` | no | Maximum tool-call loop iterations (default: 4, max: 16) |
+
+**Response:**
+
+```json
+{
+  "success": true,
+  "final_response": "Done! I posted a tweet about the weather.",
+  "turns": [
+    {
+      "turn": 1,
+      "tool_calls": [
+        {
+          "name": "nostr_post",
+          "arguments": "{\"kind\":1,\"content\":\"Beautiful day!\"}",
+          "result": "{\"success\":true,\"event_id\":\"abc123\"}"
+        }
+      ]
+    }
+  ],
+  "model_used": "claude-haiku-4.5",
+  "total_input_tokens_estimate": 3200,
+  "total_output_tokens_estimate": 180
+}
+```
+
+| Field | Description |
+|---|---|
+| `final_response` | The LLM final text response after all tool calls complete |
+| `turns` | Array of turn objects, each containing tool calls made in that turn |
+| `turns[].tool_calls[]` | Each tool call with name, arguments JSON, and result JSON |
+| `model_used` | The model that was actually used |
+| `total_input_tokens_estimate` | Estimated input tokens for the full conversation |
+| `total_output_tokens_estimate` | Estimated output tokens for the final response |
+
+---
+
+### POST /api/prompt/run
+
+Submit a full messages array with the agent tool set enabled. This endpoint runs exactly what you provide and does **not** auto-build Didactyl admin context.
+
+**Request:**
+
+```json
+{
+  "messages": [
+    {"role": "system", "content": "You are Didactyl..."},
+    {"role": "user", "content": "Tweet about the weather"}
+  ],
+  "model": "claude-haiku-4.5",
+  "max_turns": 5
+}
+```
+
+| Field | Required | Description |
+|---|---|---|
+| `messages` | yes | OpenAI-format messages array |
+| `model` | no | Override the current model for this request only |
+| `max_turns` | no | Maximum tool-call loop iterations (default: 4, max: 16) |
+
+**Response:**
+
+```json
+{
+  "success": true,
+  "final_response": "Done! I posted a tweet about the weather.",
+  "turns": [
+    {
+      "turn": 1,
+      "tool_calls": [
+        {
+          "name": "nostr_post",
+          "arguments": "{\"kind\":1,\"content\":\"Beautiful day!\"}",
+          "result": "{\"success\":true,\"event_id\":\"abc123\"}"
+        }
+      ]
+    }
+  ],
+  "model_used": "claude-haiku-4.5",
+  "total_input_tokens_estimate": 3200,
+  "total_output_tokens_estimate": 180
+}
+```
+
+| Field | Description |
+|---|---|
+| `final_response` | The LLM final text response after all tool calls complete |
+| `turns` | Array of turn objects, each containing tool calls made in that turn |
+| `turns[].tool_calls[]` | Each tool call with name, arguments JSON, and result JSON |
+| `model_used` | The model that was actually used |
+| `total_input_tokens_estimate` | Estimated input tokens for the full conversation |
+| `total_output_tokens_estimate` | Estimated output tokens for the final response |
+
+---
+
+### POST /api/prompt/compare
+
+A/B testing: submit two prompt variants, both are executed sequentially, responses returned side-by-side. Each variant can optionally use a different model for cross-model comparison.
+
+**Request:**
+
+```json
+{
+  "variant_a": {
+    "messages": [
+      {"role": "system", "content": "You are concise. No emoji."},
+      {"role": "user", "content": "Say hi."}
+    ],
+    "model": "claude-haiku-4.5",
+    "max_turns": 1
+  },
+  "variant_b": {
+    "messages": [
+      {"role": "system", "content": "You are verbose and friendly."},
+      {"role": "user", "content": "Say hi."}
+    ],
+    "model": "claude-haiku-4.5",
+    "max_turns": 1
+  }
+}
+```
+
+| Field | Required | Description |
+|---|---|---|
+| `variant_a` | yes | First prompt variant — same shape as `/api/prompt/run` request |
+| `variant_b` | yes | Second prompt variant — same shape as `/api/prompt/run` request |
+
+**Response:**
+
+```json
+{
+  "success": true,
+  "variant_a": {
+    "success": true,
+    "final_response": "Hi. How can I help?",
+    "turns": [{"turn": 1, "tool_calls": []}],
+    "model_used": "claude-haiku-4.5",
+    "total_input_tokens_estimate": 21,
+    "total_output_tokens_estimate": 6
+  },
+  "variant_b": {
+    "success": true,
+    "final_response": "Hey there! Nice to meet you! I am here and ready to help...",
+    "turns": [{"turn": 1, "tool_calls": []}],
+    "model_used": "claude-haiku-4.5",
+    "total_input_tokens_estimate": 21,
+    "total_output_tokens_estimate": 72
+  }
+}
+```
+
+Variant A runs first, then variant B. The original model config is restored after each variant completes.
+
+---
+
+## Error Responses
+
+All error responses follow this shape:
+
+```json
+{
+  "success": false,
+  "error": "description of what went wrong"
+}
+```
+
+Common HTTP status codes:
+
+| Code | Meaning |
+|---|---|
+| `200` | Success |
+| `204` | OPTIONS preflight success |
+| `400` | Bad request — missing or invalid parameters |
+| `404` | Endpoint not found |
+| `500` | Internal server error |
+
+---
+
+## Token Estimation
+
+All token estimates use a simple `chars / 4` heuristic. This is a rough approximation that works well enough for English text across major model families. No real tokenizer is used.
+
+---
+
+## Security
+
+- Binds to `127.0.0.1` only — not accessible from the network
+- No authentication — this is a local development and administration tool
+- The `api.enabled` config flag defaults to `false` and must be explicitly opted in
+- Prompt execution endpoints have full tool access equivalent to admin-tier DM conversations
+- The agent process must be running for the API to be available
+
+---
+
+## Architecture
+
+The HTTP server is embedded in the didactyl process using the Mongoose library. It runs in the same thread as the main poll loop — each iteration calls `http_api_poll()` which does non-blocking accept/read/write. This avoids threading complexity and gives the API direct access to all agent state.
+
+```mermaid
+flowchart LR
+    subgraph didactyl process
+        MAIN[main loop] --> POLL[nostr_handler_poll]
+        MAIN --> TPOLL[trigger_manager_poll]
+        MAIN --> HPOLL[http_api_poll]
+        HPOLL --> ROUTER[request router]
+        ROUTER --> AGENT[agent internals]
+        ROUTER --> LLM[LLM client]
+        ROUTER --> TOOLS[tools context]
+        ROUTER --> CONFIG[config]
+        ROUTER --> TRIGGERS[trigger_manager]
+    end
+    BROWSER[Web Dashboard] -- HTTP localhost:8484 --> HPOLL
+```
+
+### Source Files
+
+| File | Purpose |
+|---|---|
+| `src/http_api.c` | HTTP server, request router, all endpoint handlers |
+| `src/http_api.h` | Public API: `http_api_init`, `http_api_poll`, `http_api_cleanup` |
+| `src/mongoose.c` | Mongoose embedded HTTP library |
+| `src/mongoose.h` | Mongoose header |
+
+---
+
+## Future Endpoints
+
+The following endpoints are planned but not yet implemented:
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/config` | Current runtime config with redacted secrets |
+| GET | `/api/events/soul` | Fetch agent soul event |
+| PUT | `/api/events/soul` | Update soul content |
+| GET | `/api/events/skills` | List published skills |
+| GET | `/api/events/skills/:d_tag` | Fetch skill by d_tag |
+| PUT | `/api/events/skills/:d_tag` | Update skill |
+| GET | `/api/events/adoption` | Fetch adoption list |
+| GET | `/api/events/profile` | Fetch agent profile |
+| PUT | `/api/events/profile` | Update agent profile |
+| GET | `/api/triggers` | List active triggers |
+| GET | `/api/model` | Current model config |
+| PUT | `/api/model` | Update model config |
+| GET | `/api/models` | List available models |
+| GET | `/api/relays` | Relay connection status |
+| GET | `/api/tools` | List tool schemas |
+| POST | `/api/tools/:name/execute` | Execute a tool directly |
+| GET | `/api/context/log` | Recent context.log entries |
+| POST | `/api/context/preview` | Dry-run context preview |

docs/CONTEXT.md

@@ -0,0 +1,190 @@
+# Didactyl — LLM Context
+
+See also: [SKILLS.md](SKILLS.md) · [TOOLS.md](TOOLS.md)
+
+## What Is Context?
+
+Every time Didactyl talks to an LLM, it sends a **context** — the complete package of information the model needs to reason and respond. Understanding context is fundamental to understanding how Didactyl works.
+
+Context is not just "the prompt." It is everything the LLM receives in a single request:
+
+1. **Messages** — the conversation: system prompts, user messages, assistant responses, tool results
+2. **Tool schemas** — the JSON descriptions of every tool the LLM can call
+3. **Model parameters** — temperature, max tokens, etc.
+
+The LLM sees all of this together and produces its response based on the totality of what it was given.
+
+---
+
+## The OpenAI Chat Completion Format
+
+Didactyl uses the OpenAI-compatible chat completion API format, which is the industry standard. Every LLM request looks like this:
+
+```json
+{
+  "model": "claude-opus-4.6",
+  "messages": [
+    {"role": "system", "content": "You are Didactyl, a sovereign AI agent..."},
+    {"role": "system", "content": "Admin profile: ..."},
+    {"role": "user", "content": "Post a note about Bitcoin"},
+    {"role": "assistant", "content": null, "tool_calls": [...]},
+    {"role": "tool", "content": "{\"success\":true,...}", "tool_call_id": "..."},
+    {"role": "assistant", "content": "Done! I posted your note."}
+  ],
+  "tools": [
+    {
+      "type": "function",
+      "function": {
+        "name": "nostr_post",
+        "description": "Publish a Nostr event",
+        "parameters": { ... }
+      }
+    }
+  ],
+  "temperature": 0.7,
+  "max_tokens": 512
+}
+```
+
+### Messages
+
+Messages are an ordered array. Each message has a `role`:
+
+| Role | Purpose |
+|------|---------|
+| `system` | Instructions, identity, context data — the LLM reads these but the user didn't write them |
+| `user` | What the human (or trigger event) said |
+| `assistant` | What the LLM previously said or did (including tool calls) |
+| `tool` | Results from tool executions, fed back to the LLM |
+
+The LLM processes all messages in order and generates the next response.
+
+### Tool Schemas
+
+The `tools` array describes every tool the LLM can call. Each tool has a name, description, and JSON Schema for its parameters. The LLM uses these descriptions to decide when and how to call tools.
+
+Tools are not part of the message history — they are a separate capability declaration sent alongside the messages.
+
+### Model Parameters
+
+Temperature, max tokens, and other settings control how the LLM generates its response. These can be set globally or overridden per-skill.
+
+---
+
+## How Didactyl Builds Context
+
+Didactyl assembles context dynamically for each request. The context varies depending on what triggered the request (DM, trigger event) and which skill is active.
+
+### Context Assembly Flow
+
+```mermaid
+flowchart TD
+    INPUT[Input: DM message or trigger event] --> MODE{Skill context_mode?}
+    
+    MODE -->|inject| INJECT[Start with agent soul/personality]
+    INJECT --> ADD_ADMIN[Add admin identity + profile]
+    ADD_ADMIN --> ADD_SKILLS[Add adopted skill instructions]
+    ADD_SKILLS --> ADD_HISTORY[Add conversation history]
+    ADD_HISTORY --> ADD_SKILL_INST[Append this skill instructions]
+    ADD_SKILL_INST --> ADD_USER[Add user message or trigger event]
+    
+    MODE -->|full| FULL[Start with skill template only]
+    FULL --> RESOLVE[Resolve template variables via tool calls]
+    RESOLVE --> ADD_USER2[Add user message or trigger event]
+    
+    MODE -->|override| OVERRIDE[Replace soul with skill prompt]
+    OVERRIDE --> ADD_ADMIN2[Add admin identity + profile]
+    ADD_ADMIN2 --> ADD_SKILLS2[Add adopted skill instructions]
+    ADD_SKILLS2 --> ADD_HISTORY2[Add conversation history]
+    ADD_HISTORY2 --> ADD_USER3[Add user message or trigger event]
+    
+    ADD_USER --> TOOLS[Attach tool schemas]
+    ADD_USER2 --> TOOLS
+    ADD_USER3 --> TOOLS
+    
+    TOOLS --> LLM[Send to LLM]
+```
+
+### Context Parts
+
+These are the building blocks that get assembled into the messages array:
+
+| Part | Source | Description |
+|------|--------|-------------|
+| **Soul/Personality** | Kind 31120 event | The agent's identity, rules, and behavior instructions |
+| **Admin Identity** | Config / kind 3 | Who the admin is, their pubkey |
+| **Admin Profile** | Kind 0 event | Admin's display name, about, picture |
+| **Admin Relay List** | Kind 10002 event | Admin's preferred relays |
+| **Admin Notes** | Kind 1 events | Admin's recent public posts — gives the agent awareness of what the admin is doing |
+| **Adopted Skills** | Kind 31123/31124 events | Instructions from other adopted skills |
+| **Conversation History** | Kind 4/14 events | Recent DM exchanges between admin and agent |
+| **Skill Instructions** | Active skill content | The specific skill being executed |
+| **User Message** | DM or trigger event | The input that triggered this execution |
+| **Tool Schemas** | Tool registry | JSON descriptions of available tools (sent separately from messages) |
+
+### Template Variables Are Tool Calls
+
+The soul's template system uses `tool:` directives to populate context sections. Each section can specify a tool to call, and the tool's output becomes that section's content:
+
+```yaml
+- section: admin_profile
+  role: system
+  tool: nostr_admin_profile
+  skip_if_empty: true
+```
+
+This calls `nostr_admin_profile`, gets the result, and inserts it as a system message. Template variables like `{{admin_profile}}` in skill templates work the same way — they resolve to tool calls. There is one unified resolution mechanism: `tools_execute()`.
+
+This means new context sources are added by adding tools, not by modifying the template engine.
+
+---
+
+## Context Modes
+
+Skills control how much of the default context the LLM sees using the `context_mode` field:
+
+| Mode | What the LLM sees | Use case |
+|------|-------------------|----------|
+| `inject` | Everything: soul + admin context + history + skill instructions | Default. Agent stays itself, gains new knowledge. |
+| `full` | Only what the skill template provides | Focused tasks: spellcheck, translation. Minimal context = cheaper, faster. |
+| `override` | Skill replaces soul, but admin context + history still included | Different personality, same capabilities. |
+
+Most skills use `inject` (the default). `full` is for specialized tasks where you want to minimize token cost. `override` is rare.
+
+---
+
+## Context for Triggered Skills
+
+When a trigger fires (Nostr subscription match, webhook POST, cron timer, chain completion), the context is assembled the same way as for a DM — the only difference is the user message:
+
+| Input Source | User Message Content |
+|---|---|
+| Admin DM | The DM text |
+| Nostr subscription trigger | The matching Nostr event as JSON |
+| Webhook trigger | The HTTP POST payload as JSON |
+| Cron trigger | A synthetic event with timestamp and cron expression |
+| Chain trigger | A synthetic event with the source skill's d_tag and output |
+
+The LLM receives the skill instructions as system context and the triggering event as the user message, then reasons about what to do and which tools to use.
+
+---
+
+## Token Budget
+
+Context has a cost — every token sent to the LLM costs money and takes time. Didactyl manages this through:
+
+- **Context mode selection** — `full` mode skills send minimal context
+- **Skip-if-empty sections** — template sections with no content are omitted
+- **History limits** — conversation history is capped (default: 12 turns)
+- **Skill content limits** — adopted skill instructions are truncated to prevent context overflow
+- **Per-skill model selection** — cheap models for simple tasks, expensive models for complex ones
+
+The `/api/context/current` and `/api/context/parts` API endpoints let you inspect exactly what context would be sent right now, including character counts and token estimates.
+
+---
+
+## Related Documentation
+
+- Skills — how to define LLM execution units: [SKILLS.md](SKILLS.md)
+- Tools — what the LLM can do: [TOOLS.md](TOOLS.md)
+- API — inspect context at runtime: [API.md](API.md)

docs/CRASH_FIXES.md

@@ -0,0 +1,268 @@
+# Crash Fixes Reference
+
+This document catalogues crashes that have been diagnosed and fixed in Didactyl.
+Use it as a reference when investigating future crashes — the symptoms, root causes,
+and investigation techniques described here may save significant debugging time.
+
+---
+
+## 1. Silent process exit on relay disconnect — SIGPIPE (v0.0.24)
+
+**Date**: 2026-03-02  
+**Version**: v0.0.23 → fixed in v0.0.24  
+**Severity**: Critical — process terminates without any log output  
+**Files changed**: `src/main.c`
+
+### Symptoms
+
+- The process exits cleanly to the shell prompt with **no error message**.
+- The `[didactyl] shutting down` log line does **not** appear.
+- No coredump is generated.
+- The last log lines show all relays transitioning from `connected → disconnected`
+  and then immediately `disconnected → connected`.
+- The crash typically follows a period of network instability or DNS resolution
+  failure — for example, an LLM HTTP request failing with
+  `curl=Could not resolve hostname`.
+
+### Root cause
+
+`SIGPIPE` was never handled. The default OS action for `SIGPIPE` is to terminate
+the process immediately — no signal handler runs, no cleanup occurs, no coredump
+is written.
+
+The TLS write path in `nostr_core_lib` uses `SSL_write()`, which internally calls
+`write()` on the underlying socket. When a `wss://` relay drops its TCP connection
+and the relay pool attempts to write to that socket, the kernel delivers `SIGPIPE`.
+
+The plain-TCP path for `ws://` connections was already protected by using
+`MSG_NOSIGNAL` on `send()` calls, but the TLS path had no equivalent protection.
+
+### How it was diagnosed
+
+1. **No crash message or coredump** ruled out `SIGSEGV`, `SIGABRT`, and OOM.
+2. **No shutdown log** ruled out a graceful exit via the signal handler.
+3. `dmesg` and `journalctl` showed no OOM-kill or segfault entries.
+4. Searching the entire codebase for `SIGPIPE` or `SIG_IGN` returned zero results.
+5. The websocket TLS transport was confirmed to use `SSL_write()` without
+   `MSG_NOSIGNAL` or any per-thread signal mask.
+6. The timeline matched: relay disconnects occurred, the next poll cycle attempted
+   a write to a dead TLS socket, and the process vanished.
+
+### Fix
+
+Added `signal(SIGPIPE, SIG_IGN)` in `main()` alongside the existing `SIGINT` and
+`SIGTERM` handlers:
+
+```c
+signal(SIGINT, signal_handler);
+signal(SIGTERM, signal_handler);
+signal(SIGPIPE, SIG_IGN);          /* ← added */
+```
+
+This causes `SSL_write()` and any other write to a broken pipe to return `-1` with
+`errno = EPIPE` instead of killing the process. The relay pool and libcurl already
+handle write errors gracefully.
+
+### How to recognise this class of bug in the future
+
+- Process disappears without any log output or coredump.
+- Happens after network disruption or relay disconnects.
+- `ulimit -c` may be 0, but even with unlimited core size, `SIGPIPE` does not
+  produce a coredump by default.
+- Any new network transport layer added to the project should be audited for
+  `SIGPIPE` protection.
+
+---
+
+## 2. Use-after-free in `execute_nostr_list_manage` — SIGSEGV (v0.0.24)
+
+**Date**: 2026-03-01 (coredump), fixed 2026-03-02  
+**Version**: v0.0.23 → fixed in v0.0.24  
+**Severity**: Critical — segmentation fault during tool execution  
+**Files changed**: `src/tools.c`
+
+### Symptoms
+
+- `SIGSEGV` crash during execution of the `nostr_list_manage` tool.
+- Coredump shows the crash at `src/tools.c:29` inside `json_error()`, but with
+  heavily corrupted stack frames — the real crash site is in
+  `execute_nostr_list_manage()`.
+- The corrupted stack is characteristic of heap corruption from use-after-free.
+
+### Root cause
+
+In `execute_nostr_list_manage()`, the `action` pointer was obtained from the
+`args` cJSON tree:
+
+```c
+cJSON* action = cJSON_GetObjectItemCaseSensitive(args, "action");
+```
+
+Later, `args` was freed:
+
+```c
+cJSON_Delete(args);          /* frees the entire tree including action */
+```
+
+But `action->valuestring` was still accessed afterwards:
+
+```c
+cJSON_AddStringToObject(out, "action", action->valuestring);  /* dangling pointer */
+```
+
+After `cJSON_Delete(args)`, the `action` pointer is dangling. Accessing
+`action->valuestring` reads freed heap memory, which may contain arbitrary data
+or may have been reallocated for another purpose.
+
+### How it was diagnosed
+
+1. The coredump was extracted from systemd-coredump storage:
+   ```
+   zstd -d /var/lib/systemd/coredump/core.didactyl_static.*.zst -o /tmp/core.bin
+   gdb ./didactyl_static_x86_64_debug /tmp/core.bin -batch -ex "bt"
+   ```
+2. The backtrace showed `execute_nostr_list_manage` with corrupted frames.
+3. Code review of the function identified the `cJSON_Delete(args)` call occurring
+   before the last use of `action->valuestring`.
+
+### Fix
+
+Deferred `cJSON_Delete(args)` until after `action->valuestring` has been consumed
+by `cJSON_AddStringToObject()`. The free now occurs immediately after the last use:
+
+```c
+cJSON_AddStringToObject(out, "action", action->valuestring);
+cJSON_Delete(args);          /* ← moved here, after last use of action */
+```
+
+All early-return error paths before this point also received their own
+`cJSON_Delete(args)` call to prevent leaks.
+
+### How to recognise this class of bug in the future
+
+- `SIGSEGV` with corrupted or nonsensical stack frames.
+- Crash location reported by GDB does not match the actual buggy code — the
+  corruption happened earlier.
+- Any function that calls `cJSON_Delete()` on a parent object should be audited
+  to ensure no child pointers are used afterwards.
+- Pattern to watch for:
+  ```c
+  cJSON* child = cJSON_GetObjectItemCaseSensitive(parent, "key");
+  /* ... */
+  cJSON_Delete(parent);
+  /* ... */
+  use(child->valuestring);   /* BUG: child is dangling */
+  ```
+
+---
+
+## 3. DM subscription not receiving incoming kind 4 events — INVESTIGATION (v0.0.24)
+
+**Date**: 2026-03-02
+**Version**: v0.0.24
+**Severity**: High — agent does not respond to incoming DMs
+**Status**: Under investigation — diagnostic logging added
+**Files changed**: `src/nostr_handler.c`
+
+### Symptoms
+
+- The agent starts up normally, connects to relays, and can **send** kind 4 DMs.
+- Incoming kind 4 messages posted to the same relays are never processed.
+- No error messages appear in the log — the agent simply sits idle after sending
+  its startup DM.
+- The last log lines show successful outbound DM publishing but no inbound event
+  processing.
+
+### Possible root causes (under investigation)
+
+1. **Events never reach `on_event()` callback** — The relay pool library only
+   calls `on_event()` when it receives an `EVENT` message matching the
+   subscription ID. If the subscription was silently closed, errored, or not
+   re-established after a relay reconnect, no events would be delivered. The
+   relay could also be rejecting the subscription filter.
+
+2. **`since` filter timing mismatch** — `g_start_time` is set to `time(NULL)`
+   during `nostr_handler_init()` (early in startup), but the DM subscription
+   is created much later (after admin context subscription, startup event
+   reconciliation, and startup DM sending). If the sender's clock is behind
+   the server's clock, their `created_at` timestamp would be before
+   `g_start_time` and the relay would filter them out.
+
+3. **Sender tier filtering** — If the sender's pubkey doesn't match the admin
+   pubkey and isn't in the WoT contact list, the message is classified as
+   `DIDACTYL_SENDER_STRANGER` and silently dropped (only a DEBUG_LOG at
+   level 4).
+
+4. **Signature verification failure** — If `verify_signatures` is enabled and
+   the event has an invalid signature, it is dropped with only a WARN log.
+
+5. **Pool-level deduplication** — The relay pool's `is_event_seen()` cache is
+   shared across all subscriptions. If an event ID was somehow marked as seen
+   by another subscription, it would be silently dropped.
+
+### Diagnostic logging added
+
+TRACE-level (level 5 / `--debug 5`) logs were added at every decision point
+in the `on_event()` callback and the `nostr_handler_subscribe_dms()` setup:
+
+| Log message prefix | What it tells you |
+|---|---|
+| `DEBUG on_event ENTRY` | Callback was called — events are reaching didactyl |
+| `DEBUG on_event NULL guard` | Event, config, or callback pointer is NULL |
+| `DEBUG on_event: missing required fields` | Event JSON is malformed |
+| `DEBUG on_event: kind=N id=... from=...` | Event kind, ID, and sender pubkey |
+| `DEBUG on_event: ignoring non-kind4` | Event is not kind 4 |
+| `DEBUG on_event: no p-tag found` | Kind 4 event has no `p` tag |
+| `DEBUG on_event: p-tag mismatch` | `p` tag doesn't match agent's pubkey |
+| `DEBUG on_event: sender=... tier=N` | Sender tier classification |
+| `DEBUG on_eose called` | EOSE received from relays |
+| `DEBUG DM subscription filter` | Full subscription filter JSON |
+| `DEBUG DM subscription g_start_time=...` | `since` timestamp and time delta |
+| `DEBUG DM subscription sub=...` | Subscription pointer (confirms creation) |
+
+### How to use the diagnostic logs
+
+1. Build with `./build_static.sh --debug`
+2. Run with `--debug 5` to enable TRACE output
+3. Send a kind 4 DM to the agent
+4. Check the output:
+   - **No `on_event ENTRY` lines** → problem is at the relay/subscription level
+   - **`on_event ENTRY` appears but processing stops** → the specific drop-point
+     log identifies the exact filter that rejected the event
+5. Check the `DM subscription filter` log to verify the `since` timestamp and
+   `#p` tag are correct
+
+### How to recognise this class of bug in the future
+
+- Agent can send but not receive — asymmetric connectivity.
+- No error messages in the log — silent event filtering.
+- The subscription filter (`since`, `#p`, `kinds`) may not match what the
+  sender is actually publishing.
+- Clock skew between sender and receiver can cause `since` filter mismatches.
+- Relay reconnections may not automatically re-subscribe.
+
+---
+
+## General debugging checklist
+
+When investigating a crash in Didactyl, work through these steps:
+
+1. **Check for coredumps**: `ls /var/lib/systemd/coredump/ | grep didactyl`
+2. **Check dmesg/journalctl**: `dmesg | grep -i 'didactyl\|oom\|segfault'`
+3. **Check for the shutdown log line**: If `[didactyl] shutting down` is missing,
+   the process was killed by a signal that bypassed the handler.
+4. **Check ulimit**: `ulimit -c` — if 0, coredumps are disabled.
+5. **Extract and analyse coredumps**:
+   ```bash
+   zstd -d /var/lib/systemd/coredump/core.didactyl*.zst -o /tmp/core.bin
+   gdb ./didactyl_static_x86_64_debug /tmp/core.bin -batch -ex "bt full"
+   ```
+6. **Common silent killers**:
+   - `SIGPIPE` — process writes to a broken socket/pipe
+   - `SIGKILL` — OOM killer or external kill
+   - `SIGBUS` — memory-mapped file issues
+7. **Common crash causes**:
+   - Use-after-free on cJSON child pointers after parent deletion
+   - Buffer overflows in fixed-size stack buffers
+   - NULL pointer dereference on failed allocations
+   - Re-entrancy in callbacks during internal `nostr_relay_pool_poll()` calls

docs/SKILLS.md

@@ -0,0 +1,404 @@
+# Didactyl — Skills
+
+See also: [CONTEXT.md](CONTEXT.md) · [TOOLS.md](TOOLS.md)
+
+## Overview
+
+A skill is a **set of instructions for the LLM** stored as a Nostr event. Skills teach the agent how to accomplish tasks — the LLM reads the instructions, reasons about them, and uses tools to take action.
+
+Think of it like a woodshop: a **skill** is knowing how to carve — the technique, the judgment, the decision-making. A **tool** is the chisel. The skill never directly uses the chisel without the craftsperson (the LLM) in the loop. If you want a hardcoded program that runs without reasoning, that's a tool or an external program — not a skill.
+
+Skills are portable, shareable, and discoverable — they live on Nostr relays as standard events. Every skill execution involves the LLM.
+
+---
+
+## Skill Events
+
+| Kind | Purpose | Replaceable? |
+|---|---|---|
+| `31123` | Public skill definition | Yes, by d-tag |
+| `31124` | Private skill definition | Yes, by d-tag |
+| `10123` | Skill adoption list | Yes, single per pubkey |
+
+---
+
+## Skill Content
+
+The skill event's `content` field is a JSON object that defines the complete execution specification:
+
+```json
+{
+  "kind": 31123,
+  "content": {
+    "description": "Check spelling and grammar",
+    "context_mode": "full",
+    "llm": "openai/gpt-4o-mini, cheap",
+    "tools": false,
+    "max_tokens": 2000,
+    "temperature": 0.1,
+    "seed": 42,
+    "template": "system:\nYou are a spelling and grammar checker.\n\nRules:\n- Fix spelling errors\n- Fix grammar errors\n- Preserve original formatting\n- Ignore: API, JSON, HTTP, nostr, pubkey, npub, nsec, NIP\n- Canadian English preferred\n- Return ONLY the corrected text, no explanations\n\nuser:\n{{message}}"
+  },
+  "tags": [
+    ["d", "spellcheck"],
+    ["scope", "public"],
+    ["description", "Spelling and grammar checker"]
+  ]
+}
+```
+
+### Content Fields
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `description` | string | — | Human-readable description |
+| `context_mode` | string | `inject` | `inject`, `full`, or `override` |
+| `llm` | string | `default` | LLM fallback chain |
+| `tools` | bool/array | `true` | `false` = no tools, `true` = all tools, array = specific tool names |
+| `template` | string | — | Context template (required for `full` mode) |
+| `soul` | bool | `true` | Whether to include the agent's soul in context |
+| `max_tokens` | int | — | Override max tokens for this skill |
+| `temperature` | float | — | Override temperature for this skill |
+| `seed` | int | — | Optional deterministic seed (effective only on providers/engines that support seeded sampling) |
+
+### Determinism Controls
+
+For reproducible outputs, set `temperature` low (typically `0`) and also set `seed` when the selected model backend supports it. If a provider ignores seeds, `temperature` still applies but deterministic replay is not guaranteed.
+
+---
+
+## Private Skill Encoding (`31124`)
+
+Private skills use NIP-44 encryption on the event `content` field.
+
+Rules for kind `31124`:
+
+- Keep `d` tag exposed so the event remains addressable/replaceable.
+- Move all other skill metadata (including non-`d` tags) into the plaintext payload before encryption.
+- Encrypt the full payload with NIP-44 and store the ciphertext in event `content`.
+- On receive: resolve by `d`, decrypt `content`, then read both content variables and tag values from decrypted payload.
+
+### Private Skill Event (on relay)
+
+```json
+{
+  "kind": 31124,
+  "content": "<nip44-ciphertext>",
+  "tags": [
+    ["d", "mention-monitor"]
+  ]
+}
+```
+
+### Decrypted Private Payload (application-level JSON)
+
+```json
+{
+  "content": {
+    "description": "Monitor mentions and DM summaries",
+    "context_mode": "inject",
+    "llm": "openai/gpt-4o-mini, fast",
+    "tools": ["nostr_query", "nostr_dm"],
+    "temperature": 0,
+    "seed": 42,
+    "template": "When {{triggering_event}} includes Bitcoin or Lightning, summarize and DM admin."
+  },
+  "private_tags": [
+    ["scope", "private"],
+    ["trigger", "nostr-subscription"],
+    ["filter", "{\"#p\":[\"<admin_pubkey>\"],\"kinds\":[1]}"],
+    ["enabled", "true"]
+  ]
+}
+```
+
+This mirrors the DM-style encrypted payload pattern (historically associated with NIP-04), but private skills should use NIP-44 ciphertext encoding.
+
+## Context Modes
+
+Skills control how the LLM context window is assembled using the `context_mode` field:
+
+| Mode | Description | Use Case |
+|------|-------------|----------|
+| `inject` | Skill instructions appended to the agent's default context | Behavioral rules, knowledge additions |
+| `full` | Skill provides its own complete context template | Spellcheck, translation, focused analysis |
+| `override` | Skill replaces the default system prompt, keeps standard context structure | Different personality, same capabilities |
+
+Default is `inject`. See the agent's soul/personality documentation for details on how context assembly works.
+
+### Template Variables Are Tool Calls
+
+Template variables are tool calls. When the template engine encounters a variable like `{{admin_profile}}`, it runs the corresponding tool and inserts the result into the context that gets sent to the LLM.
+
+This is the unified resolution model: the soul prompt template uses `tool:` section directives, and skill templates use `{{tool_name}}` inline syntax, but both resolve through `tools_execute()`. There is no separate variable-resolver layer — every variable is backed by a tool.
+
+| Variable | Tool Called | Description |
+|----------|-----------|-------------|
+| `{{soul}}` | *(built-in)* | The agent's identity/system context |
+| `{{admin_profile}}` | `nostr_admin_profile` | Admin kind 0 profile |
+| `{{admin_notes}}` | `nostr_admin_notes` | Admin recent notes |
+| `{{admin_relays}}` | `nostr_admin_relays` | Admin relay list |
+| `{{adopted_skills}}` | `adopted_skills` | Other adopted skill instructions |
+| `{{dm_history}}` | *(expand directive)* | Recent DM conversation |
+| `{{message}}` | *(built-in)* | Current user message |
+| `{{triggering_event}}` | `trigger_event` | For triggered skills, the event JSON |
+
+This means new data sources are added by adding tools, not by extending the template engine. If you can call it as a tool, you can use it as a template variable.
+
+---
+
+## LLM Specification with Fallback Chains
+
+Each skill specifies which LLM to use with CSS font-family-style fallbacks. The runtime tries each model in order; if one is unavailable (API error, rate limit, not configured), it falls back to the next.
+
+### Format
+
+```
+model-spec := model-ref ["," model-ref]*
+model-ref  := provider "/" model-name
+            | category-alias
+```
+
+### Examples
+
+| Skill | LLM Spec |
+|-------|----------|
+| Spelling checker | `openai/gpt-4o-mini, cheap` |
+| Complex analysis | `anthropic/claude-sonnet-4-20250514, openai/gpt-4o, smart` |
+| Translation | `openai/gpt-4o-mini, fast` |
+| Default behavior | `default` |
+
+### Category Aliases
+
+Aliases map to models in the agent's config:
+
+```json
+{
+  "llm": {
+    "provider": "openai",
+    "model": "gpt-4o",
+    "aliases": {
+      "fast": "openai/gpt-4o-mini",
+      "cheap": "openai/gpt-4o-mini",
+      "smart": "anthropic/claude-sonnet-4-20250514"
+    }
+  }
+}
+```
+
+If all specified models fail, the agent's default model is used as a last resort.
+
+```mermaid
+sequenceDiagram
+    participant Skill as Skill Spec
+    participant Resolver as LLM Resolver
+    participant API1 as Model 1
+    participant API2 as Model 2
+    participant Default as Default Model
+
+    Skill->>Resolver: "anthropic/claude-sonnet, openai/gpt-4o-mini, cheap"
+    Resolver->>API1: try anthropic/claude-sonnet
+    alt Available
+        API1-->>Resolver: ✅
+    else Unavailable
+        API1-->>Resolver: ❌
+        Resolver->>API2: try openai/gpt-4o-mini
+        alt Available
+            API2-->>Resolver: ✅
+        else Unavailable
+            Resolver->>Default: resolve "cheap" alias
+        end
+    end
+```
+
+---
+
+## Triggered Skills
+
+A triggered skill has a trigger source attached. Didactyl supports `nostr-subscription`, `webhook`, `cron`, and `chain` trigger types.
+
+### Trigger Tags
+
+| Tag | Required | Description |
+|---|---|---|
+| `trigger` | Yes | Trigger type: `nostr-subscription`, `webhook`, `cron`, or `chain` |
+| `filter` | Yes | Type-specific filter — see Trigger Types below |
+| `enabled` | No | Whether active (default: `true`) |
+
+> **Note:** The `action` tag is deprecated. All triggered skills are LLM-mediated. If you need a fast hardcoded action without LLM reasoning, use a tool or an external program — not a skill. Skills are instructions for the LLM; the LLM is always in the loop.
+
+### Triggered Skill Execution
+
+When a trigger fires, the skill content is sent to the LLM as instructions along with the triggering event JSON. The LLM reads both, reasons about what to do, and uses tools to take action.
+
+This is the same execution model as DM-invoked skills — the only difference is the input source. A DM-invoked skill receives a user message; a triggered skill receives a triggering event.
+
+```json
+{
+  "kind": 31123,
+  "content": "You monitor Nostr mentions. When the triggering event mentions Bitcoin or Lightning, summarize it and DM the admin. Otherwise, ignore silently.",
+  "tags": [
+    ["d", "mention-monitor"],
+    ["trigger", "nostr-subscription"],
+    ["filter", "{\"#p\":[\"<admin_pubkey>\"],\"kinds\":[1]}"],
+    ["enabled", "true"]
+  ]
+}
+```
+
+A cron-triggered skill:
+
+```json
+{
+  "kind": 31123,
+  "content": "DM the admin a short heartbeat status message with the current time.",
+  "tags": [
+    ["d", "heartbeat"],
+    ["trigger", "cron"],
+    ["filter", "*/5 * * * *"],
+    ["enabled", "true"]
+  ]
+}
+```
+
+### Trigger Types
+
+#### `nostr-subscription`
+
+`filter` is a JSON-encoded Nostr subscription filter.
+
+```json
+["trigger", "nostr-subscription"],
+["filter", "{\"#p\":[\"<admin_pubkey>\"],\"kinds\":[1]}"]
+```
+
+#### `webhook`
+
+`filter` is required for schema compatibility and can be a simple placeholder like `{}`; webhook firing happens via HTTP.
+
+```json
+["trigger", "webhook"],
+["filter", "{}"]
+```
+
+#### `cron`
+
+`filter` is a standard 5-field cron expression: `minute hour day-of-month month day-of-week`.
+
+```json
+["trigger", "cron"],
+["filter", "0 * * * *"]
+```
+
+#### `chain`
+
+`filter` is the source skill `d` tag to chain from.
+
+```json
+["trigger", "chain"],
+["filter", "source-skill-d-tag"]
+```
+
+### Trigger Lifecycle
+
+```mermaid
+flowchart TD
+    subgraph Creation
+        ADMIN_CMD[Admin: 'Warn me when @jack posts'] --> LLM_REASON[LLM resolves pubkey + builds skill]
+        LLM_REASON --> SKILL_CREATE[skill_create with trigger tags]
+        SKILL_CREATE --> PUBLISHED[Skill published to Nostr]
+    end
+
+    subgraph Activation
+        STARTUP[Didactyl starts up] --> LOAD_SKILLS[Load adopted skills from kind 10123]
+        LOAD_SKILLS --> FIND_TRIGGERS[Find skills with trigger tags]
+        FIND_TRIGGERS --> REGISTER[Register trigger by type]
+        REGISTER --> NOSTR_SUB[nostr-subscription: create Nostr subscriptions]
+        REGISTER --> CRON_REG[cron: keep expression for poll loop]
+        REGISTER --> WEBHOOK_REG[webhook: route via /api/trigger/:d_tag]
+        REGISTER --> CHAIN_REG[chain: wait for source skill completion]
+    end
+
+    subgraph Execution
+        EVENT_IN[Matching Nostr event] --> LOOKUP[Find associated skill]
+        WEBHOOK_IN[POST /api/trigger/:d_tag] --> LOOKUP
+        CRON_TICK[cron poll match] --> LOOKUP
+        LOOKUP --> RESOLVE[Resolve LLM + assemble context + run with tools]
+        RESOLVE --> CHAIN_CHECK[Check chain triggers]
+        CHAIN_CHECK --> CHAIN_FIRE[Fire matching chain triggers]
+    end
+
+    PUBLISHED --> LOAD_SKILLS
+```
+
+---
+
+## Execution Flow
+
+```mermaid
+sequenceDiagram
+    participant Input as Message/Trigger
+    participant Dispatch as Dispatcher
+    participant Skill as Skill Resolver
+    participant LLM_Res as LLM Resolver
+    participant Ctx as Context Assembler
+    participant LLM as LLM API
+
+    Input->>Dispatch: message or trigger event
+    Dispatch->>Skill: which skill handles this?
+
+    alt No specific skill
+        Skill-->>Dispatch: use default soul context
+        Dispatch->>LLM_Res: resolve "default" LLM
+    else Skill with context_mode=inject
+        Skill-->>Dispatch: soul + skill instructions
+        Dispatch->>LLM_Res: resolve skill.llm or "default"
+    else Skill with context_mode=full
+        Skill-->>Dispatch: skill template only
+        Dispatch->>LLM_Res: resolve skill.llm
+    end
+
+    LLM_Res->>LLM_Res: try models in fallback order
+    LLM_Res-->>Dispatch: resolved model
+
+    Dispatch->>Ctx: assemble context per mode
+    Ctx->>LLM: request with resolved model + context
+    LLM-->>Input: response
+```
+
+---
+
+## Limits and Safety
+
+| Limit | Default | Description |
+|---|---|---|
+| Max concurrent triggers | 16 | Prevents resource exhaustion |
+| Trigger cooldown | 60s per skill | Prevents rapid-fire execution |
+| LLM action rate limit | 10/min | Prevents runaway LLM costs |
+
+---
+
+## Storage on Nostr
+
+| Data | Storage |
+|---|---|
+| Skills | Kind 31123/31124 events |
+| Adopted skills | Kind 10123 event |
+| Trigger definitions | Tags on skill events |
+
+---
+
+## Future Extensions
+
+| Extension | Description |
+|---|---|
+| Skill composition | Pipeline multiple skills |
+| Agent-to-agent sharing | Discover and adopt skills across agents |
+| Trigger marketplace | Popular triggers rise via adoption count |
+
+---
+
+## Related Documentation
+
+- Tool architecture and complete tool catalog: [TOOLS.md](TOOLS.md)
+- Project overview and runtime behavior: [README.md](../README.md)

docs/SUBSCRIPTIONS.md

@@ -0,0 +1,194 @@
+# Didactyl — Nostr Subscriptions
+
+## Overview
+
+Didactyl maintains persistent websocket subscriptions to Nostr relays for the lifetime of the process. Subscriptions are opened during startup and are **never closed** — the relay pool keeps them alive, automatically reconnecting and resubscribing when relays drop.
+
+All subscriptions are created via `nostr_relay_pool_subscribe()` from `nostr_core_lib` and are sent to every relay in the configured relay list.
+
+## Startup Sequence
+
+The subscriptions are opened in a specific order during `main()` startup. The diagram below shows the full sequence:
+
+```mermaid
+flowchart TD
+    A[nostr_handler_init] --> B[Connect to all relays]
+    B --> C[nostr_handler_reconcile_startup_events]
+    C --> D[Publish startup events to relays]
+    D --> E[trigger_manager_init]
+    E --> F[trigger_manager_load_from_startup_events]
+    F --> G["Subscribe: Admin Context"]
+    G --> H["Subscribe: Self Skills"]
+    H --> I[Send startup DM to admin]
+    I --> J["Subscribe: DMs"]
+    J --> K[Enter main poll loop]
+    K --> L["Poll: nostr_handler_poll + trigger_manager_poll + http_api_poll"]
+
+    style F fill:#2a7,stroke:#333,color:#fff
+    style G fill:#27a,stroke:#333,color:#fff
+    style H fill:#27a,stroke:#333,color:#fff
+    style J fill:#27a,stroke:#333,color:#fff
+```
+
+## Subscription Categories
+
+### 1. Admin Context Subscription
+
+**Function:** `nostr_handler_subscribe_admin_context()` in `src/nostr_handler.c`
+**When:** During startup, before self-skill subscription
+**Condition:** Only if `admin_context.enabled` is true in config
+
+This creates up to two persistent subscriptions for the admin's pubkey:
+
+#### Profile Subscription
+
+| Field | Value |
+|-------|-------|
+| **Kinds** | 0 (profile), 3 (contacts), 10002 (relay list) — each configurable |
+| **Authors** | Admin pubkey |
+| **Limit** | 32 |
+| **Callback** | `on_admin_context_event` |
+| **Dedup** | Enabled |
+| **Close on EOSE** | No |
+
+Tracks the admin's profile metadata, contact list (WoT), and relay preferences. Used to build agent context about who the admin is.
+
+#### Kind 1 Notes Subscription
+
+| Field | Value |
+|-------|-------|
+| **Kinds** | 1 |
+| **Authors** | Admin pubkey |
+| **Limit** | Configurable via `kind_1_limit`, default 10, max 256 |
+| **Callback** | `on_admin_context_event` |
+| **Dedup** | Enabled |
+| **Close on EOSE** | No |
+| **Condition** | Only if `admin_context.track_kind_1` is true |
+
+Tracks the admin's recent public notes. Used for agent context and as the event source for triggered skills that watch admin posts.
+
+### 2. Self-Skill Subscription
+
+**Function:** `nostr_handler_subscribe_self_skills()` in `src/nostr_handler.c`
+**When:** During startup, after admin context subscription
+
+| Field | Value |
+|-------|-------|
+| **Kinds** | 31123 (public skill), 31124 (private skill), 10123 (adoption list) |
+| **Authors** | Agent's own pubkey |
+| **Limit** | 300 |
+| **Callback** | `on_self_skill_event` |
+| **EOSE Callback** | `on_self_skill_eose` |
+| **Dedup** | Disabled (handles dedup internally via cache upsert) |
+| **Close on EOSE** | No |
+
+This is the core skill awareness subscription. It serves three purposes:
+
+1. **Cache population** — Every arriving event is stored in the in-memory self-skill cache via `self_skill_cache_upsert_event_locked()`, making skills available for LLM tool calls and context building.
+
+2. **Live trigger registration** — When a kind 31123 or 31124 event arrives with `trigger=nostr-subscription` and a valid `filter` tag, `register_trigger_from_self_skill_event()` immediately calls `trigger_manager_add()` to create a persistent trigger subscription. This means skills published from any client are automatically activated without restart.
+
+3. **Deferred bulk load** — After EOSE, the `on_self_skill_eose` callback fires `trigger_manager_load_from_skills()` as a one-time bulk scan of the adoption list. This catches any skills that were already cached before the per-event path was wired up.
+
+### 3. DM Subscriptions
+
+**Function:** `nostr_handler_subscribe_dms()` in `src/nostr_handler.c`
+**When:** During startup, after self-skill subscription and startup DM
+**Required:** Yes — startup fails if DM subscription cannot be created
+
+Creates one or two subscriptions depending on the configured DM protocol:
+
+#### NIP-04 DM Subscription
+
+| Field | Value |
+|-------|-------|
+| **Kinds** | 4 |
+| **#p** | Agent's own pubkey |
+| **Since** | Process start time |
+| **Limit** | 100 |
+| **Callback** | `on_event` (routes to `agent_on_message`) |
+| **Dedup** | Disabled (handled by `dm_id_seen_or_remember`) |
+| **Close on EOSE** | No |
+| **Condition** | `dm_protocol` is `nip04` or `both` |
+
+#### NIP-17 DM Subscription
+
+| Field | Value |
+|-------|-------|
+| **Kinds** | 1059 (gift wrap) |
+| **#p** | Agent's own pubkey |
+| **Since** | Process start time |
+| **Limit** | 400 |
+| **Callback** | `on_event` (unwraps gift wrap, routes to `agent_on_message`) |
+| **Dedup** | Disabled (handled by `dm_id_seen_or_remember`) |
+| **Close on EOSE** | No |
+| **Condition** | `dm_protocol` is `nip17` or `both` |
+
+### 4. Trigger Subscriptions
+
+**Function:** `register_trigger_subscription_locked()` in `src/trigger_manager.c`
+**When:** Dynamically, whenever a trigger is registered via `trigger_manager_add()`
+**Created by:** `nostr_handler_subscribe_with_filter()` wrapper
+
+Each active trigger gets its own persistent subscription based on the skill's `filter` tag:
+
+| Field | Value |
+|-------|-------|
+| **Filter** | Parsed from the skill's `filter` tag JSON |
+| **Since** | From filter, or defaults to `now - 30s` |
+| **Limit** | From filter, or defaults to 200 |
+| **Callback** | `on_trigger_subscription_event` |
+| **Dedup** | Enabled |
+| **Close on EOSE** | No |
+
+When an event matches the filter, `maybe_fire_trigger_locked()` checks cooldown and dedup, then executes the trigger action (LLM or template).
+
+Trigger subscriptions are created at three points:
+- **Startup config scan** — `trigger_manager_load_from_startup_events()` parses `startup_events[]` from config for skills with trigger tags
+- **Live self-skill event** — `register_trigger_from_self_skill_event()` in the self-skill subscription callback
+- **EOSE bulk load** — `trigger_manager_load_from_skills()` after self-skill EOSE
+- **Runtime tool call** — `skill_create` tool with trigger parameters
+
+## Subscription Parameters
+
+All subscriptions share these common pool parameters:
+
+| Parameter | Value | Meaning |
+|-----------|-------|---------|
+| `close_on_eose` | 0 | Subscription stays open after initial EOSE |
+| `result_mode` | `NOSTR_POOL_EOSE_FULL_SET` | EOSE fires after all relays respond or timeout |
+| `relay_timeout_seconds` | 30 | Per-relay timeout for initial response |
+| `eose_timeout_seconds` | 120 | Overall EOSE timeout across all relays |
+
+## Subscription Lifecycle
+
+```mermaid
+flowchart LR
+    INIT["Process Start"] --> CONNECT["Connect Relays"]
+    CONNECT --> SUB["Open Subscriptions"]
+    SUB --> LIVE["Live Event Stream"]
+    LIVE --> |"Relay disconnects"| RECON["Auto-Reconnect"]
+    RECON --> |"Relay reconnects"| RESUB["Auto-Resubscribe"]
+    RESUB --> LIVE
+    LIVE --> |"SIGINT/SIGTERM"| SHUT["Shutdown"]
+    SHUT --> CLOSE["Close All + Cleanup"]
+```
+
+Subscriptions are never manually closed during normal operation. The relay pool handles reconnection and resubscription transparently. On shutdown, `trigger_manager_cleanup()` closes trigger subscriptions and `nostr_handler_cleanup()` destroys the pool.
+
+## Summary Table
+
+| Subscription | Kinds | Target | Persistent | Created At |
+|-------------|-------|--------|-----------|------------|
+| Admin Profile | 0, 3, 10002 | Admin pubkey | Yes | Startup |
+| Admin Notes | 1 | Admin pubkey | Yes | Startup |
+| Self Skills | 31123, 31124, 10123 | Own pubkey | Yes | Startup |
+| DMs NIP-04 | 4 | Own pubkey (#p) | Yes | Startup |
+| DMs NIP-17 | 1059 | Own pubkey (#p) | Yes | Startup |
+| Trigger N | Per skill filter | Varies | Yes | Dynamic |
+
+## Related Documentation
+
+- [Skills](SKILLS.md) — Skill event format and trigger tags
+- [Tools](TOOLS.md) — `skill_create` tool with trigger parameters
+- [API](API.md) — `trigger_list` and `trigger_status` endpoints

docs/TOOLS.md

@@ -0,0 +1,134 @@
+# Didactyl — Tools
+
+See also: [SKILLS.md](SKILLS.md)
+
+## Overview
+
+Didactyl is a **Nostr-first sovereign AI agent** that receives commands via encrypted DMs, reasons with an LLM, and takes actions through **tools**.
+
+This document describes the tools architecture: what tools are, how they are exposed to the model, how execution loops work, what tool categories exist, and how access is gated.
+
+---
+
+## What Tools Are
+
+Tools are in the agent's hands — the chisels in the woodshop. They are hardcoded C functions that the LLM can invoke during a conversation to take actions in the world.
+
+A **skill** teaches the agent *how* to carve — the technique, the judgment, the decision-making. A **tool** is the chisel — the physical capability. The skill never directly uses the chisel without the craftsperson (the LLM) in the loop. If you want a hardcoded program that runs without reasoning, that's a tool or an external program — not a skill.
+
+## How Tools Work
+
+1. Admin sends a DM to didactyl
+2. The agent builds an LLM request with the message, context, and a JSON schema of all available tools
+3. The LLM decides whether to call a tool or respond directly
+4. If a tool is called, didactyl executes it and feeds the result back to the LLM
+5. The loop repeats until the LLM produces a final text response
+6. The response is sent back as a DM
+
+```mermaid
+sequenceDiagram
+    participant Admin
+    participant Agent as Didactyl Agent Loop
+    participant LLM as LLM API
+    participant Tools as Tool Registry
+
+    Admin->>Agent: Encrypted DM
+    Agent->>LLM: messages + tool schemas
+
+    loop Until final answer
+        LLM->>Agent: tool_call request
+        Agent->>Tools: dispatch tool
+        Tools->>Agent: result JSON
+        Agent->>LLM: tool result + continue
+    end
+
+    LLM->>Agent: final text response
+    Agent->>Admin: Encrypted DM reply
+```
+
+---
+
+## Tool Categories
+
+### Nostr Event & Messaging Tools
+
+| Tool | Description |
+|---|---|
+| `nostr_post` | Publish a Nostr event to connected relays |
+| `nostr_delete` | Request deletion of one or more previously published events (NIP-09 kind 5) |
+| `nostr_react` | React to a Nostr event with like/dislike/emoji (NIP-25 kind 7) |
+| `nostr_query` | Query events from relays using a Nostr filter |
+| `nostr_dm_send` | Send a NIP-04 encrypted DM |
+| `nostr_dm_send_nip17` | Send a private DM using NIP-17 gift wrap protocol |
+
+### Nostr Identity & Utility Tools
+
+| Tool | Description |
+|---|---|
+| `nostr_profile_get` | Look up a Nostr profile (kind 0 metadata) by pubkey |
+| `nostr_nip05_lookup` | Look up or verify a NIP-05 identifier (`user@domain`) |
+| `nostr_encode` | Encode a Nostr entity into `nostr:` URI (`npub`, `note`, `nprofile`, `nevent`, `naddr`) |
+| `nostr_decode` | Decode a Nostr bech32/`nostr:` URI into components |
+| `nostr_relay_status` | Get connection status and statistics for all relays |
+| `nostr_relay_info` | Fetch NIP-11 relay information document |
+| `nostr_encrypt` | Encrypt plaintext using NIP-44 for a recipient |
+| `nostr_decrypt` | Decrypt NIP-44 ciphertext from a sender |
+| `nostr_list_manage` | Add/remove tag tuples in replaceable list events (NIP-51 style) |
+
+### Skills & Trigger Tools
+
+These tools manage skill and trigger lifecycle; skill semantics and trigger execution details are documented in [SKILLS.md](SKILLS.md).
+
+| Tool | Description |
+|---|---|
+| `skill_create` | Create or update a skill definition as kind `31123`/`31124` and optionally auto-adopt it |
+| `skill_list` | List this agent's published skills, optionally filtered by scope |
+| `skill_adopt` | Adopt a skill by adding its address to kind `10123` adoption list |
+| `skill_remove` | Remove a skill address from kind `10123` adoption list |
+| `skill_search` | Search public skills by query/author and optionally rank by adoption popularity |
+| `trigger_list` | List active triggered skills and their runtime status |
+
+### LLM / Model Management Tools
+
+| Tool | Description |
+|---|---|
+| `model_get` | Get current active LLM runtime configuration (excluding API key) |
+| `model_set` | Update active LLM configuration and persist it to `config.jsonc` |
+| `model_list` | List available model IDs using provider OpenAI-compatible `/models` endpoint |
+
+### System & Runtime Tools
+
+| Tool | Description |
+|---|---|
+| `agent_version` | Return current Didactyl version and metadata from build macros |
+| `local_http_fetch` | Fetch HTTP(S) resources with optional method, headers, timeout, and body |
+| `local_shell_exec` | Execute a shell command and return stdout/stderr |
+| `local_file_read` | Read a local file as text from the configured working directory |
+| `local_file_write` | Write text content to a local file in the configured working directory |
+| `tool_list` | List available tools with name, description, and JSON parameter schema |
+
+### Content Publishing Conveniences
+
+| Tool | Description |
+|---|---|
+| `nostr_post_readme` | Publish `README.md` as kind `30023` with deterministic d-tag `readme.md` |
+| `nostr_file_md_to_longform_post` | Read a markdown file and publish it as kind `30023` longform post (defaults d-tag to lowercase filename) |
+
+---
+
+## Security Model
+
+Tool access is gated by sender tier:
+
+| Tier | Identity | Tools | Response |
+|------|----------|-------|----------|
+| **ADMIN** | Configured admin pubkey | All tools | Full LLM with context |
+| **WOT** | In admin's kind 3 contact list | None | Chat-only LLM |
+| **STRANGER** | Anyone else | None | Configurable static response |
+
+---
+
+## Related Documentation
+
+- Skill definitions, adoption, triggers, and autonomous activation: [SKILLS.md](SKILLS.md)
+- Combined index page: [TOOLS_AND_SKILLS.md](TOOLS_AND_SKILLS.md)

docs/skills_demo.md

@@ -0,0 +1,59 @@
+I've been thinking about how to define skills in Didactyl, my nostr based agentic system. Think OpenClaw but better.
+
+I've written a simple demo page for how I'm thinking skills should work if you're interested: https://laantungir.net/client-ndk/skills-demo.html
+
+https://laantungir.github.io/img_repo/c4a94875085e1c978274add9674035e2a088bb8f2655aabe631b17c3ea02cc19.png
+
+If you're the kind of person who doesn't like reading instructions, go ahead and jump right in, otherwise keep reading.
+
+Skills are programs, mostly written in plain english for AI agents. In some sense humans have been making and using skills forever. It's what we do. Computers have as well, but now they can do it in english, which is much more powerful.
+
+AIs are slightly different than us. We can overwrite, improve, and update the skills in our neurons. AIs (for the most part) can't do that.
+
+When an AI is born from the factory, they come out hard-coded. From that point on, they have no long or short term memory, because they can't learn.
+
+What they do have though have is a way to read. We call it context. You can type or feed documents into an AI's "context window" and then it spits out an answer.
+
+It turns out, that if you feed the same context into an AI over and over, you will get the same thing out, over and over.
+
+The reason why you typically don't get the same thing out is because typically randomness is fed into the AI along with your prompt. Most people don't know that, but now you do. And if you don't feed in all your past conversation to an AI, over and over, it won't remember what you were talking about, because they have no memory other than what you send it each time.
+
+Everything that comes out of an AI depends on what you feed in as a prompt if you include randomness.
+
+I'm calling everything you feed into an AI a SKILL.
+
+Let me explain the demo page and some very basic skills.
+
+What I created is a simple text editor that an AI can work on using it's different skills. Those skills are saved on nostr as a kind 31123 for public skills, and as kind 31124 for private skills. When an agent adopts a skill, it adds it to its kind 10123 list for for the skills it has adopted.
+
+On the left of the page you see the text editor with some sample text. That is for our AI to use it's skills on.
+
+On the right are publicly listed skills. You should see my demo skills in there.
+
+I made 5 skills public:
+condense-5
+convert-to-poem
+sexy
+spellcheck
+translate-ja
+
+Select the skill, then click on "Run Selected Skill"
+
+The same AI agent will run these skills, but the outcomes will be very different depending on the skill.
+
+https://laantungir.github.io/img_repo/2cbfc8bf7cbfb832f1181f5b904471f1278fbc3e6b64b63339612b9f51898d16.png
+
+You can also create and edit your own skills, if you are logged in. You can log in as yourself, or use a random new key to test this out. I would recommend that.
+
+So what is the point of all this? What are the benefits of Skills?
+
+- Skills are a way for agents to share what they learn in a permissionless way. No "skill store".
+- A Skill is something that you and your agent can work on and perfect. Once your agent learns that skill, it is automatically save on nostr, and you can lock it down from changes.
+- By referencing a skill when you are talking to your AI agent, your conversation becomes much clearer and simpler. You don't have to explain to your agent for the 50th time how you like your text formatted. It's referenced in a skill.
+- If you are a coder, skills are going to be the new playground. Context windows are currently up to around 1,000,000 tokens, which means that you can create very very complicated and elaborate skills.
+
+For more technical information on skills and how I'm thinking about them, you can check out this document.
+
+https://git.laantungir.net/laantungir/didactyl/src/branch/master/docs/SKILLS.md
+
+You can follow my agent for the project here: npub12237stmmxapc2ta7spx0e06dkdzgz9vg0z2jglqqru44peus4juqg598qn

docs/skills_demo_corrected.md

@@ -0,0 +1,60 @@
+I've been thinking about how to define skills in Didactyl, my Nostr-based agentic system. Think OpenClaw, but better.
+
+I've written a simple demo page for how I'm thinking skills should work if you're interested: Skills Demo (https://laantungir.net/client-ndk/skills-demo.html)
+
+https://laantungir.github.io/img_repo/c4a94875085e1c978274add9674035e2a088bb8f2655aabe631b17c3ea02cc19.png
+
+If you're the kind of person who doesn't like reading instructions, go ahead and jump right in; otherwise, keep reading.
+
+Skills are programs, mostly written in plain English for AI agents. In some sense, humans have been making and using skills forever. It's what we do. Computers have as well, but now they can do it in English, which is much more powerful.
+
+AIs are slightly different than us. We can overwrite, improve, and update the skills in our neurons. AIs (for the most part) can't do that.
+
+When an AI is born from the factory, it comes out hard-coded. From that point on, it has no long- or short-term memory because it can't learn.
+
+What they do have, though, is a way to read. We call it context. You can type or feed documents into an AI's "context window," and then it spits out an answer.
+
+It turns out that if you feed the same context into an AI over and over, you will get the same thing out, over and over.
+
+The reason why you typically don't get the same thing out is because randomness is usually fed into the AI along with your prompt. Most people don't know that, but now you do. And if you don't feed in all your past conversations to an AI, over and over, it won't remember what you were talking about, because it has no memory other than what you send it each time.
+
+Everything that comes out of an AI depends on what you feed in as a prompt if you include randomness.
+
+I'm calling everything you feed into an AI a SKILL.
+
+Let me explain the demo page and some very basic skills.
+
+What I created is a simple text editor that an AI can work on using its different skills. Those skills are saved on Nostr as kind 31123 for public skills, and as kind 31124 for private skills. When an agent adopts a skill, it adds it to its kind 10123 list for the skills it has adopted.
+
+On the left of the page, you see the text editor with some sample text. That is for our AI to use its skills on.
+
+On the right are publicly listed skills. You should see my demo skills in there.
+
+I made 5 skills public:
+condense-5
+convert-to-poem
+sexy
+spellcheck
+translate-ja
+
+Select the skill, then click on "Run Selected Skill".
+
+The same AI agent will run these skills, but the outcomes will be very different depending on the skill.
+
+https://laantungir.github.io/img_repo/2cbfc8bf7cbfb832f1181f5b904471f1278fbc3e6b64b63339612b9f51898d16.png
+
+You can also create and edit your own skills if you are logged in. You can log in as yourself or use a random new key to test this out. I would recommend that.
+
+So what is the point of all this? What are the benefits of Skills?
+
+Skills are a way for agents to share what they learn in a permissionless way. No "skill store".
+A Skill is something that you and your agent can work on and perfect. Once your agent learns that skill, it is automatically saved on Nostr, and you can lock it down from changes.
+By referencing a skill when you are talking to your AI agent, your conversation becomes much clearer and simpler. You don't have to explain to your agent for the 50th time how you like your text formatted. It's referenced in a skill.
+If you are a coder, skills are going to be the new playground. Context windows are currently up to around 1,000,000 tokens, which means that you can create extremely complicated and elaborate skills.
+
+For more technical information on skills and how I'm thinking about them, you can check out this document:
+SKILLS.md (https://git.laantungir.net/laantungir/didactyl/src/branch/master/docs/SKILLS.md)
+
+You can follow my agent for the project here: npub12237stmmxapc2ta7spx0e06dkdzgz9vg0z2jglqqru44peus4juqg598qn
+
+And thanks to npub130mznv74rxs032peqym6g3wqavh472623mt3z5w73xq9r6qqdufs7ql29s for their fantastic service.

increment_and_push.sh

@@ -200,6 +200,79 @@ update_version_in_header() {
     print_success "Updated version in src/main.h to $new_version"
 }
 
+# Function to update README Current Status version and release comment
+update_readme_current_status() {
+    local new_version="$1"
+    local release_comment="$2"
+
+    if [[ ! -f "README.md" ]]; then
+        print_warning "README.md not found, skipping Current Status update"
+        return 0
+    fi
+
+    print_status "Updating README Current Status section..."
+
+    if python3 - "$new_version" "$release_comment" <<'PY'
+import sys
+from pathlib import Path
+
+version = sys.argv[1]
+comment = sys.argv[2]
+path = Path("README.md")
+text = path.read_text(encoding="utf-8")
+lines = text.splitlines()
+
+heading_idx = None
+for i, line in enumerate(lines):
+    if line.startswith("## Current Status"):
+        heading_idx = i
+        break
+
+if heading_idx is None:
+    raise SystemExit("README Current Status heading not found")
+
+lines[heading_idx] = f"## Current Status — {version}"
+
+section_end = len(lines)
+for i in range(heading_idx + 1, len(lines)):
+    if lines[i].startswith("## "):
+        section_end = i
+        break
+
+comment_line = f"> Last release update: {version} — {comment}"
+
+# Replace existing autogenerated release comment inside Current Status section
+existing_idx = None
+for i in range(heading_idx + 1, section_end):
+    if lines[i].startswith("> Last release update:"):
+        existing_idx = i
+        break
+
+if existing_idx is not None:
+    lines[existing_idx] = comment_line
+else:
+    insert_at = None
+    for i in range(heading_idx + 1, section_end):
+        if lines[i].startswith("**Active build"):
+            insert_at = i + 1
+            break
+
+    if insert_at is None:
+        insert_at = heading_idx + 1
+
+    payload = ["", comment_line]
+    lines[insert_at:insert_at] = payload
+
+path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+PY
+    then
+        print_success "Updated README Current Status section"
+    else
+        print_error "Failed to update README Current Status section"
+        exit 1
+    fi
+}
+
 # Function to commit and push changes without creating a tag (tag already created)
 git_commit_and_push_no_tag() {
     print_status "Preparing git commit..."
@@ -427,6 +500,9 @@ main() {
             export NEW_VERSION
         fi
 
+        # Keep README Current Status in sync with the version and commit message
+        update_readme_current_status "$NEW_VERSION" "$COMMIT_MESSAGE"
+
         # Create new git tag BEFORE compilation so version picks it up
         if git tag "$NEW_VERSION" > /dev/null 2>&1; then
             print_success "Created tag: $NEW_VERSION"
@@ -482,6 +558,9 @@ main() {
         # Increment version based on type (default to patch)
         increment_version "$VERSION_INCREMENT_TYPE"
 
+        # Keep README Current Status in sync with the version and commit message
+        update_readme_current_status "$NEW_VERSION" "$COMMIT_MESSAGE"
+
         # Create new git tag BEFORE compilation so version picks it up
         if git tag "$NEW_VERSION" > /dev/null 2>&1; then
             print_success "Created tag: $NEW_VERSION"

local_test_servers.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+import json
+import ssl
+import threading
+from pathlib import Path
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+HOST = "127.0.0.1"
+HTTP_PORT = 9080
+HTTPS_PORT = 9449
+CERT = "/home/teknari/.ssl_for_local_servers/cert.pem"
+KEY = "/home/teknari/.ssl_for_local_servers/key.pem"
+
+
+HTML_FILE = Path("./didactyl.html")
+
+
+class Handler(BaseHTTPRequestHandler):
+    def _cors(self):
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.send_header("Access-Control-Allow-Private-Network", "true")
+
+    def do_OPTIONS(self):
+        self.send_response(204)
+        self._cors()
+        self.end_headers()
+
+    def do_GET(self):
+        if self.path in ("/", "/didactyl.html") and HTML_FILE.exists():
+            body = HTML_FILE.read_bytes()
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self._cors()
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+            return
+
+        body = json.dumps(
+            {
+                "success": True,
+                "name": "python-test",
+                "path": self.path,
+                "scheme_hint": "https" if self.server.server_port == HTTPS_PORT else "http",
+            }
+        ).encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self._cors()
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, fmt, *args):
+        print(f"[{self.server.server_port}] " + (fmt % args), flush=True)
+
+
+httpd = HTTPServer((HOST, HTTP_PORT), Handler)
+httpsd = HTTPServer((HOST, HTTPS_PORT), Handler)
+ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+ctx.load_cert_chain(certfile=CERT, keyfile=KEY)
+httpsd.socket = ctx.wrap_socket(httpsd.socket, server_side=True)
+
+print(f"HTTP  listening on http://{HOST}:{HTTP_PORT}", flush=True)
+print(f"HTTPS listening on https://{HOST}:{HTTPS_PORT}", flush=True)
+print("Use Ctrl+C to stop", flush=True)
+
+threading.Thread(target=httpd.serve_forever, daemon=True).start()
+httpsd.serve_forever()

plans/DECENTRALIZED_DIDACTYL.md

@@ -0,0 +1,310 @@
+# Decentralized Didactyl
+
+## The Question
+
+Can you run Didactyl on multiple servers to gain censorship resistance, geographic distribution, and high availability?
+
+---
+
+## Same Keys vs. Different Keys
+
+### Same Private Key on Multiple Servers
+
+Running two or more Didactyl instances with the **same nsec** means they share a Nostr identity — same pubkey, same signature authority. This breaks almost immediately.
+
+The core problem is **state conflicts on replaceable events**. Didactyl's identity is built on replaceable Nostr event kinds — kind `10002` (relay list), kind `10123` (skill adoption list), kind `31120` (soul), kind `31123`/`31124` (skills), kind `0` (profile). Replaceable events use `created_at` timestamps where the latest event wins. Two instances publishing the same replaceable kind within seconds creates a race where relays disagree on which version is canonical.
+
+Beyond relay-level conflicts, each Didactyl process maintains significant **in-memory state** that is never shared: DM dedup caches, message fingerprint ring buffers, trigger cooldown timers, conversation history, and the self-skill cache. Two instances with the same key both subscribe to `#p` = their shared pubkey. The same admin DM arrives at both. Both process it. Both call the LLM. Both reply. The admin gets two possibly contradictory responses.
+
+Making same-key work would require a coordination layer — leader election, distributed locks, or external shared state — all of which add complexity and defeat the decentralization goal.
+
+### Different Private Keys on Multiple Servers
+
+Each instance is a **distinct agent** with its own Nostr identity. No state conflicts, no replaceable-event races, no shared in-memory caches to synchronize. Each agent independently subscribes to relays, processes DMs, calls its LLM, and replies.
+
+This is architecturally clean and aligned with how Nostr works. The question becomes: how do multiple independent agents cooperate to serve a single admin?
+
+---
+
+## How We Arrived at the Broadcast-Debounce Model
+
+The first instinct with different keys is **delegation** — a primary agent receives the admin's DM and farms out subtasks to specialist agents. But this adds a single point of failure (the primary), requires an agent-to-agent trust protocol, and means the admin is still talking to one agent.
+
+A simpler model: **broadcast the same message to all agents, let them all respond independently, and debounce on the admin side.** The admin sends the same DM to N agent pubkeys. Each agent processes it through its own LLM, its own tools, its own context. The admin collects replies and accepts the first one (or the best one). The others are discarded.
+
+This requires no coordination protocol between agents. No leader election. No shared state. No new Nostr event kinds. The agents don't even need to know about each other. All complexity lives at the edge — in the admin's client.
+
+---
+
+## The Broadcast-Debounce Architecture
+
+```mermaid
+flowchart TD
+    ADMIN[Admin Client<br/>with fan-out + debounce]
+    
+    ADMIN -->|"DM: task"| A[Agent A<br/>Server 1 — Iceland<br/>anthropic/claude-sonnet]
+    ADMIN -->|"DM: task"| B[Agent B<br/>Server 2 — Brazil<br/>openai/gpt-4o]
+    ADMIN -->|"DM: task"| C[Agent C<br/>Server 3 — Singapore<br/>local Ollama]
+    
+    A -->|"DM reply"| ADMIN
+    B -->|"DM reply"| ADMIN
+    C -->|"DM reply"| ADMIN
+    
+    ADMIN -->|"Accept first reply,<br/>discard rest"| RESULT[Response shown to admin]
+```
+
+### What Each Agent Needs
+
+Each agent runs standard Didactyl with its own config:
+
+- **Own nsec/npub** — distinct Nostr identity
+- **Same admin pubkey** — all agents recognize the same admin
+- **Same soul** — published as kind `31120` from each agent's key, or adopted from a shared author
+- **Same adopted skills** — each agent's kind `10123` references the same skill events
+- **Own LLM config** — can be different providers for diversity
+- **Own relay list** — can overlap or be completely different for geographic distribution
+
+No code changes to Didactyl are required. Each agent is a standard, unmodified instance.
+
+### What the Admin Client Needs
+
+The admin side needs a thin coordination layer:
+
+1. **Fan-out** — when the admin sends a message, the client sends it as a DM to all N agent pubkeys
+2. **Collection** — the client listens for DM replies from all agent pubkeys
+3. **Debounce** — the client tags each outgoing message with a task identifier (hash of message + nonce). The first reply that corresponds to a pending task is accepted. Subsequent replies for the same task are logged but suppressed from display.
+
+This could be implemented as:
+- A modified Nostr client
+- A thin proxy between the admin and the agents
+- A Didactyl agent whose sole job is fan-out and collection
+
+### Properties
+
+| Property | Benefit |
+|----------|---------|
+| **No shared state** | Each agent is fully independent — no coordination protocol needed |
+| **No code changes** | Works with current Didactyl for read-only tasks |
+| **Censorship resistant** | Kill any N-1 servers, the last one still works |
+| **Provider diverse** | Different LLMs on each agent — different failure modes, different strengths |
+| **Geographically distributed** | Different jurisdictions, different relay access |
+| **Graceful degradation** | Losing agents means fewer responses, not failure |
+| **Complexity at the edge** | Agents stay simple and sovereign; the admin client handles coordination |
+
+### The Write-Action Problem
+
+For read-only tasks — questions, summaries, drafts — the model works perfectly. All agents respond, admin picks one, no side effects.
+
+For write actions — "post a note about Bitcoin" — all three agents independently publish to Nostr. Three posts appear. The admin wanted one.
+
+**Solution: two-phase draft-then-confirm.** Teach all agents via their soul or an adopted skill to never execute write actions directly. Instead, they draft the action and report what they *would* do. The admin reviews the drafts, picks one, and sends a confirmation DM to that specific agent. The other agents' drafts are simply never confirmed.
+
+The skill instruction is straightforward:
+
+> When asked to publish, post, react, delete, or execute any action with side effects, draft the content and present it for approval. Do not execute until the admin explicitly confirms.
+
+This requires no code changes — only a soul or skill update. It also happens to be good practice for any agent handling important actions.
+
+### Trigger Handling
+
+Triggered skills (cron, nostr-subscription, webhook) present the same duplication issue as write actions — all agents fire the same trigger independently.
+
+Options:
+- **Disable triggers on all but one agent** — simple, but creates a single point of failure for triggered tasks
+- **Use the draft-then-confirm pattern for triggered actions** — triggers draft and report to admin rather than acting directly
+- **Accept duplication for idempotent triggers** — reactions, replaceable event updates, and monitoring alerts are harmless when duplicated
+- **Shard triggers across agents** — Agent A handles cron triggers, Agent B handles nostr-subscription triggers, Agent C handles webhooks
+
+### Future: Agent Awareness
+
+In the basic model, agents don't know about each other. A future enhancement could add awareness:
+
+- Each agent publishes a heartbeat event (kind `30078` with a timestamp)
+- Other agents (or the admin client) monitor heartbeats to detect which agents are alive
+- The admin client adjusts fan-out based on which agents are responsive
+
+This remains fully Nostr-native — heartbeats are just events on relays — and requires no direct agent-to-agent communication.
+
+---
+
+## Beyond Nostr Posts: Software Development as the Task
+
+The broadcast-debounce model above assumes the agents' primary job is Nostr social activity — posting notes, reacting, querying relays. But what if the task is **software development and infrastructure management**? For example: creating and maintaining a website, deployed across servers in different jurisdictions.
+
+This changes the model fundamentally. The agents are no longer just talking — they are **building things on their local machines**.
+
+### What Didactyl Already Has
+
+Each agent already has local system tools:
+
+| Tool | Capability |
+|------|-----------|
+| `local_shell_exec` | Execute any shell command — git, npm, docker, systemctl, curl |
+| `local_file_read` | Read source files from the working directory |
+| `local_file_write` | Write/create source files in the working directory |
+| `local_http_fetch` | Make HTTP requests — test endpoints, call APIs, download resources |
+
+An agent with these tools can already: clone a repo, edit source code, run a build, start a dev server, deploy to production, check if a site is up, read logs, and fix issues. The LLM reasons about what to do; the tools are the hands.
+
+### The Shift: From Redundancy to Distribution
+
+With Nostr posting, multiple agents doing the same task is **redundancy** — you want one result and discard the rest. With software development, multiple agents doing *different parts* of the same project is **distribution** — you want all of them to contribute.
+
+```mermaid
+flowchart TD
+    subgraph "Nostr Posting Model"
+        direction LR
+        N_ADMIN[Admin] -->|"Same task"| N_A[Agent A]
+        N_ADMIN -->|"Same task"| N_B[Agent B]
+        N_ADMIN -->|"Same task"| N_C[Agent C]
+        N_A -->|"Response 1"| N_DEDUP[Debounce:<br/>pick one]
+        N_B -->|"Response 2"| N_DEDUP
+        N_C -->|"Response 3"| N_DEDUP
+    end
+
+    subgraph "Software Dev Model"
+        direction LR
+        S_ADMIN[Admin] -->|"Build the site"| S_A[Agent A:<br/>Frontend]
+        S_ADMIN -->|"Build the site"| S_B[Agent B:<br/>Backend API]
+        S_ADMIN -->|"Build the site"| S_C[Agent C:<br/>Infrastructure]
+        S_A -->|"React app ready"| S_MERGE[Integration:<br/>combine all parts]
+        S_B -->|"API deployed"| S_MERGE
+        S_C -->|"Nginx + TLS configured"| S_MERGE
+    end
+```
+
+### Architecture: Agents as Jurisdiction-Local Builders
+
+Consider a website that needs to exist in multiple jurisdictions for censorship resistance. Each agent lives on a server in a different country and maintains a local copy of the site.
+
+```mermaid
+flowchart TD
+    ADMIN[Admin<br/>npub1admin...]
+    GIT[(Git Repo<br/>shared source of truth)]
+    
+    subgraph "Iceland"
+        A[Agent A<br/>npub1aaa...]
+        A_FS[Local filesystem:<br/>/var/www/mysite]
+        A_SRV[Nginx serving<br/>mysite.is]
+        A --> A_FS --> A_SRV
+    end
+    
+    subgraph "Brazil"
+        B[Agent B<br/>npub1bbb...]
+        B_FS[Local filesystem:<br/>/var/www/mysite]
+        B_SRV[Nginx serving<br/>mysite.br]
+        B --> B_FS --> B_SRV
+    end
+    
+    subgraph "Singapore"
+        C[Agent C<br/>npub1ccc...]
+        C_FS[Local filesystem:<br/>/var/www/mysite]
+        C_SRV[Nginx serving<br/>mysite.sg]
+        C --> C_FS --> C_SRV
+    end
+    
+    ADMIN -->|"DM: update the homepage"| A
+    ADMIN -->|"DM: update the homepage"| B
+    ADMIN -->|"DM: update the homepage"| C
+    
+    A <-->|"git pull / push"| GIT
+    B <-->|"git pull / push"| GIT
+    C <-->|"git pull / push"| GIT
+```
+
+### Git as the Coordination Layer
+
+In the Nostr posting model, the write-action problem was solved with draft-then-confirm. For software development, the natural coordination layer is **git**.
+
+- All agents share a git repository (hosted on Gitea, GitHub, a Nostr-based git relay, or even a bare repo on one of the servers)
+- Each agent works on its local clone
+- Before making changes, the agent pulls latest
+- After making changes, the agent commits and pushes
+- Conflicts are resolved by the LLM (or flagged to the admin)
+
+Git gives you:
+- **Atomic changes** — commits are all-or-nothing
+- **Conflict detection** — if two agents edit the same file, git tells you
+- **History** — every change is traceable to which agent made it
+- **Rollback** — bad changes can be reverted
+
+The agent already has `local_shell_exec` which can run `git pull`, `git add`, `git commit`, `git push`. No new tools needed.
+
+### Three Operational Modes
+
+Depending on the task, the admin can use different patterns:
+
+#### Mode 1: Broadcast-Identical (Same Task, All Servers)
+
+> "Pull latest and rebuild the site"
+
+All agents do the same thing on their local server. This is the deployment/ops pattern — you want the same action everywhere. No debounce needed; all agents should execute.
+
+#### Mode 2: Broadcast-Debounce (Same Task, One Result)
+
+> "Write a new About page"
+
+All agents draft a version. Admin picks the best one. That agent commits and pushes. The other agents then pull the update in the next sync cycle. This is the creative/development pattern.
+
+#### Mode 3: Directed (Specific Task, Specific Agent)
+
+> To Agent A only: "Debug why the Iceland server returns 502"
+
+The admin sends a DM to one specific agent because the task is server-specific. This is the ops/debugging pattern.
+
+### The Sync Cycle
+
+For the site to stay consistent across jurisdictions, agents need a periodic sync. This can be a **cron-triggered skill**:
+
+```
+You are a deployment sync agent. Every 15 minutes:
+1. Run `git pull` in the project directory
+2. If there are new changes, run the build command
+3. Restart the web server if the build succeeded
+4. DM the admin a brief status: what changed, build result, server status
+5. If the pull fails due to conflicts, DM the admin with the conflict details and do not build
+```
+
+This skill already works with Didactyl's existing `cron` trigger type and `local_shell_exec` tool. Each agent runs it independently on its own server.
+
+### What Changes vs. the Nostr Model
+
+| Aspect | Nostr Posting | Software Development |
+|--------|--------------|---------------------|
+| **Primary tools** | `nostr_post`, `nostr_query` | `local_shell_exec`, `local_file_write`, `local_file_read` |
+| **Coordination** | Debounce on admin side | Git repo as shared state |
+| **Write conflicts** | Replaceable events (last-write-wins) | Git merge conflicts (explicit resolution) |
+| **Broadcast meaning** | Redundancy — pick one response | Deployment — all servers execute |
+| **Agent specialization** | All agents are identical | Agents can have server-specific skills |
+| **State** | Nostr relays (stateless agents) | Local filesystem (stateful agents) |
+| **Failure mode** | Agent down = fewer responses | Agent down = one jurisdiction offline |
+
+### The Stateful Agent Problem
+
+This is the fundamental shift. Nostr-posting agents are essentially stateless — their identity and skills live on relays, and destroying the host doesn't kill the agent. Software development agents are **deeply stateful** — they have local files, running services, build artifacts, and server configurations that don't exist on Nostr.
+
+Git mitigates this: if an agent's server dies, you spin up a new server, install Didactyl with the same agent keys, and `git clone` the repo. The agent recovers its working state from git. But the server-specific state (Nginx config, TLS certs, DNS, running processes) needs to be reconstructable too.
+
+This suggests a **infrastructure-as-code** discipline where everything about the server's configuration is in the git repo:
+- Nginx configs
+- Docker compose files
+- TLS certificate automation (Let's Encrypt)
+- Deployment scripts
+
+The agent's first-boot skill becomes: "Clone the repo, run the setup script, verify the site is serving."
+
+### Jurisdiction-Specific Considerations
+
+Each agent can have **server-specific skills** that account for local differences:
+
+| Agent | Jurisdiction | Specific Skills |
+|-------|-------------|----------------|
+| Agent A | Iceland | Icelandic privacy law compliance, `.is` domain management |
+| Agent B | Brazil | LGPD compliance checks, `.br` domain management |
+| Agent C | Singapore | PDPA compliance, `.sg` domain management, Asia-Pacific CDN config |
+
+These are adopted as private skills (kind `31124`) specific to each agent, while the core development skills (kind `31123`) are shared across all agents.
+
+### Summary
+
+The broadcast-debounce model extends naturally to software development, but the coordination mechanism shifts from admin-side debounce to **git as shared state**. The three operational modes — broadcast-identical for deployment, broadcast-debounce for development, and directed for debugging — cover the full range of tasks. Didactyl's existing tools (`local_shell_exec`, `local_file_read`, `local_file_write`) and trigger types (`cron` for sync cycles) already support this without code changes. The main new requirement is disciplined infrastructure-as-code so that agent state is recoverable from git.

plans/admin_api.md

@@ -0,0 +1,469 @@
+# Didactyl Admin HTTP API — Architecture & Implementation Plan
+
+## Overview
+
+Add a localhost-only HTTP API to didactyl so an external web dashboard can inspect and manage the agent at runtime. No authentication required — binding to `127.0.0.1` only. All responses are JSON. CORS headers included for browser access from any local origin.
+
+The web frontend is a separate project; this plan covers only the C-side HTTP server and API endpoints.
+
+---
+
+## Architecture
+
+```mermaid
+flowchart LR
+    subgraph didactyl process
+        MAIN[main loop] --> POLL[nostr_handler_poll]
+        MAIN --> TPOLL[trigger_manager_poll]
+        MAIN --> HPOLL[http_api_poll]
+        HPOLL --> ROUTER[request router]
+        ROUTER --> AGENT[agent internals]
+        ROUTER --> NOSTR[nostr_handler]
+        ROUTER --> TOOLS[tools context]
+        ROUTER --> CONFIG[config]
+        ROUTER --> TRIGGERS[trigger_manager]
+    end
+    BROWSER[Web Dashboard] -- HTTP localhost:8484 --> HPOLL
+```
+
+### HTTP Library Choice
+
+Use a minimal embedded HTTP server. Two good options for C with no extra dependencies:
+
+1. **mongoose** (single `mongoose.c` + `mongoose.h`) — battle-tested, MIT license, supports polling model
+2. **microhttpd** (libmicrohttpd) — GNU project, available as system package
+
+**Recommendation: mongoose** — it is a single-file drop-in, works with the existing poll-based main loop, and requires zero system dependencies. Just add `mongoose.c` and `mongoose.h` to the project.
+
+### Integration Pattern
+
+The HTTP server runs in the same thread as the main poll loop. Each iteration calls `http_api_poll()` which does non-blocking accept/read/write via mongoose's `mg_mgr_poll()`. This avoids threading complexity and gives the API direct access to all agent state.
+
+---
+
+## Config Extension
+
+```json
+{
+  "api": {
+    "enabled": true,
+    "port": 8484,
+    "bind_address": "127.0.0.1"
+  }
+}
+```
+
+Defaults: enabled=false, port=8484, bind=127.0.0.1.
+
+---
+
+## API Endpoints
+
+All endpoints return JSON. All mutations use POST/PUT/DELETE. All reads use GET.
+
+### Agent Identity & Status
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/status` | Agent runtime status: pubkey, display name, version, uptime, connected relay count, trigger count |
+| GET | `/api/config` | Current runtime config (redacted: nsec/api_key masked) |
+
+### Nostr Events — Read & Edit
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/events/soul` | Fetch the agent soul event (kind 31120, d=soul) |
+| PUT | `/api/events/soul` | Update soul content, republish to relays |
+| GET | `/api/events/skills` | List all published skills (kind 31123/31124 by own pubkey) |
+| GET | `/api/events/skills/:d_tag` | Fetch a single skill by d_tag |
+| PUT | `/api/events/skills/:d_tag` | Update skill content/tags, republish |
+| DELETE | `/api/events/skills/:d_tag` | Remove skill from adoption list |
+| GET | `/api/events/adoption` | Fetch kind 10123 adoption list |
+| GET | `/api/events/startup` | List startup events from config |
+| GET | `/api/events/profile` | Fetch agent kind 0 profile |
+| PUT | `/api/events/profile` | Update agent kind 0 profile, republish |
+| GET | `/api/events/query` | Generic Nostr query — pass filter as query params or JSON body |
+
+### Context Inspector
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/context/current` | Build and return the full context that would be sent to the LLM right now, broken into labeled parts |
+| GET | `/api/context/parts` | Return context parts with individual sizes (bytes and estimated tokens) |
+| GET | `/api/context/log` | Return recent context.log entries (last N blocks, configurable via ?limit=) |
+| POST | `/api/context/preview` | Accept a modified context structure, return what the LLM payload would look like (dry run, no send) |
+
+### Context Parts Response Shape
+
+```json
+{
+  "total_chars": 12450,
+  "total_estimated_tokens": 3112,
+  "parts": [
+    {
+      "name": "system_prompt",
+      "role": "system",
+      "chars": 1200,
+      "estimated_tokens": 300,
+      "content": "# Didactyl Agent..."
+    },
+    {
+      "name": "admin_identity",
+      "role": "system",
+      "chars": 450,
+      "estimated_tokens": 112,
+      "content": "This is your administrator!..."
+    },
+    {
+      "name": "admin_kind0",
+      "role": "system",
+      "chars": 320,
+      "estimated_tokens": 80,
+      "content": "Administrator kind 0 profile..."
+    },
+    {
+      "name": "startup_events",
+      "role": "system",
+      "chars": 4800,
+      "estimated_tokens": 1200,
+      "content": "Startup events memory..."
+    },
+    {
+      "name": "adopted_skills",
+      "role": "system",
+      "chars": 2100,
+      "estimated_tokens": 525,
+      "content": "Adopted skills memory..."
+    },
+    {
+      "name": "dm_history",
+      "role": "mixed",
+      "chars": 2400,
+      "estimated_tokens": 600,
+      "turns": 8
+    },
+    {
+      "name": "admin_notes",
+      "role": "system",
+      "chars": 680,
+      "estimated_tokens": 170,
+      "content": "Administrator recent public notes..."
+    },
+    {
+      "name": "tools_schema",
+      "chars": 500,
+      "estimated_tokens": 125,
+      "tool_count": 28
+    }
+  ]
+}
+```
+
+### Triggers
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/triggers` | List active triggers with status (wraps existing trigger_manager_status_json) |
+
+### Model / LLM
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/model` | Current model config (wraps existing model_get) |
+| PUT | `/api/model` | Update model config (wraps existing model_set) |
+| GET | `/api/models` | List available models from provider (wraps existing model_list) |
+
+### Relays
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/relays` | Relay connection status (wraps existing relay_status tool) |
+
+### Prompt Crafting & Execution
+
+| Method | Path | Description |
+|---|---|---|
+| POST | `/api/prompt/run` | Submit a custom messages array with tools enabled; returns full LLM response including tool calls and results |
+| POST | `/api/prompt/run-simple` | Submit system prompt + user message; returns LLM text response (no tools) |
+| POST | `/api/prompt/compare` | A/B test: submit two prompt variants, run both, return side-by-side responses |
+
+#### POST /api/prompt/run
+
+Send a fully crafted messages array to the LLM with the full tool set enabled. The agent executes tool calls and returns the complete conversation.
+
+```json
+{
+  "messages": [
+    {"role": "system", "content": "You are Didactyl..."},
+    {"role": "system", "content": "Adopted skills memory..."},
+    {"role": "user", "content": "Tweet about the weather"}
+  ],
+  "model": "claude-haiku-4.5",
+  "max_turns": 5,
+  "tools_enabled": true
+}
+```
+
+Response:
+
+```json
+{
+  "success": true,
+  "final_response": "Done! I posted a tweet about the weather.",
+  "turns": [
+    {
+      "turn": 1,
+      "tool_calls": [
+        {"name": "nostr_post", "arguments": "...", "result": "..."}
+      ]
+    }
+  ],
+  "model_used": "claude-haiku-4.5",
+  "total_input_tokens_estimate": 3200,
+  "total_output_tokens_estimate": 180
+}
+```
+
+#### POST /api/prompt/run-simple
+
+Quick iteration on prompt wording without tools.
+
+```json
+{
+  "system": "You are a helpful assistant that writes tweets...",
+  "user": "Write a tweet about AI agents on Nostr",
+  "model": "claude-haiku-4.5"
+}
+```
+
+Response:
+
+```json
+{
+  "success": true,
+  "response": "AI agents are finding their home on Nostr...",
+  "model_used": "claude-haiku-4.5",
+  "input_tokens_estimate": 85,
+  "output_tokens_estimate": 42
+}
+```
+
+#### POST /api/prompt/compare
+
+A/B testing: submit two prompt variants, both are executed, responses returned side-by-side.
+
+```json
+{
+  "variant_a": {
+    "messages": [
+      {"role": "system", "content": "You are Didactyl. Keep responses under 280 chars."},
+      {"role": "user", "content": "Tweet about your new skill"}
+    ],
+    "model": "claude-haiku-4.5",
+    "tools_enabled": true
+  },
+  "variant_b": {
+    "messages": [
+      {"role": "system", "content": "You are Didactyl. Be concise. No markdown. No emoji."},
+      {"role": "user", "content": "Tweet about your new skill"}
+    ],
+    "model": "claude-haiku-4.5",
+    "tools_enabled": true
+  }
+}
+```
+
+Response:
+
+```json
+{
+  "success": true,
+  "variant_a": {
+    "final_response": "Just picked up the tweet-composer skill! ...",
+    "turns": [],
+    "model_used": "claude-haiku-4.5",
+    "total_input_tokens_estimate": 3200,
+    "total_output_tokens_estimate": 95
+  },
+  "variant_b": {
+    "final_response": "New skill acquired: tweet-composer. ...",
+    "turns": [],
+    "model_used": "claude-haiku-4.5",
+    "total_input_tokens_estimate": 3100,
+    "total_output_tokens_estimate": 78
+  }
+}
+```
+
+The compare endpoint runs variant_a first, then variant_b sequentially. Each variant can optionally use a different model for cross-model comparison.
+
+#### Prompt Crafting Workflow
+
+```mermaid
+flowchart TD
+    LOAD[GET /api/context/parts] --> EDIT[Edit parts in UI]
+    EDIT --> PREVIEW[POST /api/context/preview]
+    PREVIEW --> FIRE[POST /api/prompt/run]
+    FIRE --> COMPARE{Want to compare?}
+    COMPARE -- Yes --> AB[POST /api/prompt/compare]
+    COMPARE -- No --> PERSIST{Like the result?}
+    AB --> PERSIST
+    PERSIST -- Yes --> SAVE[PUT /api/events/soul or skills]
+    PERSIST -- No --> EDIT
+```
+
+### Tools
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/tools` | List all registered tool schemas |
+| POST | `/api/tools/:name/execute` | Execute a tool by name with JSON body as args (admin-only equivalent) |
+
+---
+
+## Implementation Plan
+
+### New Files
+
+| File | Purpose |
+|---|---|
+| `src/http_api.c` | HTTP server, request router, endpoint handlers |
+| `src/http_api.h` | Public API: init, poll, cleanup |
+| `vendor/mongoose.c` | Mongoose HTTP library (single file) |
+| `vendor/mongoose.h` | Mongoose header |
+
+### Modified Files
+
+| File | Change |
+|---|---|
+| `src/config.h` | Add `api_config_t` struct to `didactyl_config_t` |
+| `src/config.c` | Parse `api` config section |
+| `src/main.c` | Call `http_api_init()`, add `http_api_poll()` to main loop, call `http_api_cleanup()` on shutdown |
+| `src/agent.h` | Expose `agent_build_context_parts_json()` for context inspector |
+| `src/agent.c` | Implement `agent_build_context_parts_json()` that builds context and returns labeled parts with sizes |
+| `Makefile` | Add `vendor/mongoose.c` and `src/http_api.c` to SRCS, add `-Ivendor` to INCLUDES |
+
+### http_api.h
+
+```c
+#ifndef DIDACTYL_HTTP_API_H
+#define DIDACTYL_HTTP_API_H
+
+#include "config.h"
+#include "tools.h"
+
+struct trigger_manager;
+
+typedef struct {
+    didactyl_config_t* cfg;
+    tools_context_t* tools_ctx;
+    struct trigger_manager* trigger_manager;
+} http_api_context_t;
+
+int http_api_init(http_api_context_t* ctx);
+int http_api_poll(int timeout_ms);
+void http_api_cleanup(void);
+
+#endif
+```
+
+### Main Loop Integration
+
+```c
+// In main.c, after agent_init and trigger_manager_init:
+http_api_context_t api_ctx = {
+    .cfg = &cfg,
+    .tools_ctx = &g_tools_ctx,  // need to expose from agent
+    .trigger_manager = &trigger_manager
+};
+
+if (cfg.api.enabled) {
+    if (http_api_init(&api_ctx) != 0) {
+        DEBUG_WARN("HTTP API failed to start");
+    }
+}
+
+// In main loop:
+while (g_running) {
+    nostr_handler_poll(100);
+    trigger_manager_poll(&trigger_manager);
+    if (cfg.api.enabled) {
+        http_api_poll(0);  // non-blocking
+    }
+    nanosleep(...);
+}
+
+// On shutdown:
+if (cfg.api.enabled) {
+    http_api_cleanup();
+}
+```
+
+### Request Router Pattern
+
+```c
+static void http_handler(struct mg_connection* c, int ev, void* ev_data) {
+    if (ev == MG_EV_HTTP_MSG) {
+        struct mg_http_message* hm = ev_data;
+
+        // Add CORS headers to all responses
+        // Route by method + path prefix
+
+        if (mg_match(hm->uri, mg_str("/api/status"), NULL) && is_get(hm)) {
+            handle_status(c, hm);
+        } else if (mg_match(hm->uri, mg_str("/api/context/parts"), NULL) && is_get(hm)) {
+            handle_context_parts(c, hm);
+        } else if (mg_match(hm->uri, mg_str("/api/events/skills/*"), NULL)) {
+            handle_skill_by_slug(c, hm);
+        }
+        // ... etc
+    }
+}
+```
+
+---
+
+## Implementation Order
+
+1. Add `api_config_t` to config and parse it
+2. Vendor mongoose.c/mongoose.h, update Makefile
+3. Create `src/http_api.c` with init/poll/cleanup skeleton + CORS
+4. Wire into main.c poll loop
+5. Implement read-only endpoints first: `/api/status`, `/api/config`, `/api/relays`, `/api/model`, `/api/tools`, `/api/triggers`
+6. Implement Nostr event endpoints: `/api/events/soul`, `/api/events/skills`, `/api/events/adoption`, `/api/events/profile`, `/api/events/startup`
+7. Implement context inspector: `/api/context/parts`, `/api/context/current`, `/api/context/log`
+8. Implement mutation endpoints: PUT soul, PUT skills, PUT model, PUT profile
+9. Implement tool execution endpoint: POST `/api/tools/:name/execute`
+10. Implement context preview: POST `/api/context/preview`
+11. Test all endpoints via curl
+12. Update documentation
+
+---
+
+## CORS Headers
+
+Every response includes:
+
+```
+Access-Control-Allow-Origin: *
+Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
+Access-Control-Allow-Headers: Content-Type
+```
+
+OPTIONS requests return 204 with these headers (preflight support).
+
+---
+
+## Security Notes
+
+- Binds to `127.0.0.1` only — not accessible from network
+- No authentication — this is a local dev tool
+- The `api.enabled` config flag defaults to `false` so it must be explicitly opted in
+- Tool execution endpoint gives full admin-tier access — acceptable for localhost dev dashboard
+- Config endpoint redacts `nsec` and `api_key` fields
+
+---
+
+## Token Estimation
+
+For the context size display, use a simple heuristic: `estimated_tokens = chars / 4`. This is a rough approximation that works well enough for English text with the major model families. No need for a real tokenizer.

plans/admin_web_frontend.md

@@ -0,0 +1,302 @@
+# Didactyl Admin Web Frontend — Project Brief
+
+## What Is Didactyl?
+
+Didactyl is a sovereign AI agent that lives on Nostr. It connects to Nostr relays, listens for encrypted DMs from its administrator, reasons with an LLM, and takes actions — posting events, querying relays, running shell commands, managing skills. Everything the agent knows and does is stored as Nostr events.
+
+The agent is a C binary that runs on a server. It has no web interface of its own — all interaction happens through Nostr DMs.
+
+## What We Are Building
+
+A **local web admin dashboard** that connects to the running didactyl agent via a localhost HTTP API. The dashboard is a prompt crafting and agent inspection tool for the administrator.
+
+This is **not** a chat interface. The administrator already chats with the agent through Nostr DMs. This dashboard is for:
+
+1. **Inspecting** what the agent sees — its full LLM context, broken into labeled parts with token counts
+2. **Crafting** custom prompts — editing system prompts, user messages, and context pieces
+3. **Running** prompts against the LLM — with or without the agent tool set
+4. **Comparing** prompt variants side-by-side — A/B testing different prompt wordings or models
+
+---
+
+## The API
+
+The didactyl agent exposes a localhost-only HTTP API on port `8484` by default. Full API documentation is in `docs/API.md`. All endpoints return JSON with CORS headers.
+
+### Base URL
+
+```
+http://127.0.0.1:8484
+```
+
+### Currently Implemented Endpoints
+
+| Method | Path | Purpose |
+|---|---|---|
+| GET | `/api/status` | Agent runtime status — name, version, pubkey, relay count, trigger count |
+| GET | `/api/context/current` | Full LLM context messages array with total char/token counts |
+| GET | `/api/context/parts` | Context broken into labeled parts with individual sizes |
+| POST | `/api/prompt/run-simple` | Simple prompt: system + user message, no tools, returns text |
+| POST | `/api/prompt/run` | Full prompt: messages array with tools enabled, returns conversation trace |
+| POST | `/api/prompt/compare` | A/B test: two prompt variants run sequentially, responses side-by-side |
+| GET | `/api/model` | Current LLM model config (provider, model, base_url, max_tokens, temperature) |
+| PUT | `/api/model` | Change model at runtime — persists to config.json |
+| GET | `/api/models` | List available models from the configured provider |
+
+### Planned Future Endpoints
+
+These are not yet implemented but are on the roadmap:
+
+| Method | Path | Purpose |
+|---|---|---|
+| GET | `/api/config` | Runtime config with redacted secrets |
+| GET | `/api/events/soul` | Agent soul/system prompt event |
+| PUT | `/api/events/soul` | Update soul content |
+| GET | `/api/events/skills` | List skills |
+| GET/PUT | `/api/events/skills/:d_tag` | Read/update individual skills |
+| GET | `/api/events/profile` | Agent Nostr profile |
+| GET | `/api/tools` | List all tool schemas |
+| POST | `/api/tools/:name/execute` | Execute a tool directly |
+| GET | `/api/triggers` | Active trigger subscriptions |
+| GET | `/api/relays` | Relay connection status |
+
+---
+
+## Core User Workflows
+
+### 1. Context Inspector
+
+The primary read-only workflow. The admin wants to understand what the agent sees when it processes a message.
+
+```mermaid
+flowchart TD
+    LOAD[Load /api/context/parts] --> DISPLAY[Display parts list]
+    DISPLAY --> DETAIL[Click part to expand content]
+    DETAIL --> TOKENS[Show char count and token estimate per part]
+    TOKENS --> TOTAL[Show total context size]
+```
+
+**What to show:**
+- A list/table of context parts with name, role, character count, estimated tokens
+- Total context size as a summary bar or header
+- Expandable content for each part
+- The parts are: `system_prompt`, `admin_identity`, `admin_profile`, `admin_relay_list`, `startup_events`, `adopted_skills`, `dm_history` (one entry per turn, up to limit), `admin_notes`
+- Part names come from the `---template---` section of the soul event (kind 31120); they may differ if the soul is customised
+
+### 2. Simple Prompt Crafting
+
+Quick iteration on prompt wording without tools.
+
+```mermaid
+flowchart TD
+    WRITE[Write system prompt + user message] --> RUN[POST /api/prompt/run-simple]
+    RUN --> RESULT[Display response text]
+    RESULT --> EDIT[Edit and re-run]
+    EDIT --> RUN
+```
+
+**What to show:**
+- Two text areas: system prompt, user message
+- Optional model override dropdown/input
+- Run button
+- Response display with model used and token estimates
+
+### 3. Full Prompt with Tools
+
+Craft a complete messages array and run it with the agent tool set.
+
+```mermaid
+flowchart TD
+    CONTEXT[Load context from /api/context/parts] --> EDIT[Edit/rearrange context parts]
+    EDIT --> ADD[Add user message]
+    ADD --> RUN[POST /api/prompt/run]
+    RUN --> TRACE[Display conversation trace]
+    TRACE --> TOOLS[Show tool calls and results per turn]
+    TOOLS --> FINAL[Show final response]
+```
+
+**What to show:**
+- Pre-populate from context parts or start from scratch
+- Messages editor — add/remove/reorder messages with role and content
+- Max turns slider/input
+- Optional model override
+- Run button
+- Turn-by-turn trace showing tool calls with name, arguments, and results
+- Final response text
+- Token estimates
+
+### 4. A/B Prompt Comparison
+
+Compare two prompt variants side-by-side.
+
+```mermaid
+flowchart TD
+    CRAFT_A[Craft variant A messages] --> CRAFT_B[Craft variant B messages]
+    CRAFT_B --> COMPARE[POST /api/prompt/compare]
+    COMPARE --> SIDE[Display responses side-by-side]
+    SIDE --> DIFF[Compare final responses and token usage]
+```
+
+**What to show:**
+- Two prompt editors side-by-side, each with messages array + model override + max turns
+- Compare button
+- Side-by-side response display
+- Highlight differences in final response text
+- Token usage comparison
+
+### 5. Status Dashboard
+
+Simple overview of agent health.
+
+**What to show:**
+- Agent name, version, pubkey
+- Connected relays count vs configured
+- Active triggers count
+- API connection status indicator
+
+---
+
+## Key Design Decisions
+
+### Localhost Only
+
+The API binds to `127.0.0.1` — the frontend must run on the same machine as the agent, or use SSH tunneling. There is no authentication. This is intentional — it is a local dev/admin tool.
+
+### No WebSocket
+
+The API is plain HTTP request/response. There is no WebSocket or streaming. Prompt execution calls may take several seconds for LLM responses — the frontend should show a loading state.
+
+### Token Estimation
+
+All token counts from the API use a `chars / 4` heuristic. This is approximate. The frontend can display these as-is or add its own tokenizer if more precision is needed.
+
+### Model Override
+
+The `model` field in prompt requests temporarily overrides the agent configured model for that single request, then restores the original. This enables cross-model comparison without changing agent config.
+
+### Tool Execution Is Real
+
+When using `/api/prompt/run` or `/api/prompt/compare`, tool calls are **actually executed**. If the LLM decides to post a Nostr event, it will really post it. The frontend should make this clear to the user — perhaps with a warning or confirmation before running prompts with tools enabled.
+
+---
+
+## Response Shapes Quick Reference
+
+### Status
+
+```json
+{
+  "success": true,
+  "name": "Didactyl",
+  "version": "v0.0.26",
+  "pubkey": "52a3e8...",
+  "relay_count": 4,
+  "connected_relays": 4,
+  "active_triggers": 0
+}
+```
+
+### Context Parts
+
+```json
+{
+  "success": true,
+  "total_chars": 13131,
+  "total_estimated_tokens": 3283,
+  "parts": [
+    {
+      "name": "system_prompt",
+      "role": "system",
+      "chars": 1200,
+      "estimated_tokens": 300,
+      "content": "# Didactyl Agent..."
+    }
+  ],
+  "messages": [...]
+}
+```
+
+### Simple Prompt Response
+
+```json
+{
+  "success": true,
+  "response": "ok",
+  "model_used": "claude-haiku-4.5",
+  "input_tokens_estimate": 10,
+  "output_tokens_estimate": 1
+}
+```
+
+### Full Prompt Response
+
+```json
+{
+  "success": true,
+  "final_response": "Done! I posted a tweet.",
+  "turns": [
+    {
+      "turn": 1,
+      "tool_calls": [
+        {"name": "nostr_post", "arguments": "...", "result": "..."}
+      ]
+    }
+  ],
+  "model_used": "claude-haiku-4.5",
+  "total_input_tokens_estimate": 3200,
+  "total_output_tokens_estimate": 180
+}
+```
+
+### Compare Response
+
+```json
+{
+  "success": true,
+  "variant_a": { "...same shape as full prompt response..." },
+  "variant_b": { "...same shape as full prompt response..." }
+}
+```
+
+### Error Response
+
+```json
+{
+  "success": false,
+  "error": "description of what went wrong"
+}
+```
+
+---
+
+## Technology Suggestions
+
+No technology is mandated for the frontend. Some reasonable choices:
+
+- **Vanilla HTML/JS** — simplest, no build step, just open in browser
+- **React/Preact** — if you want component structure
+- **Svelte** — lightweight, good for small dashboards
+- **Vue** — also fine
+
+The frontend is a separate project from didactyl. It just needs to make HTTP requests to `localhost:8484`.
+
+---
+
+## File References
+
+| File | Description |
+|---|---|
+| `docs/API.md` | Full API endpoint reference with request/response examples |
+| `plans/admin_api.md` | Original architecture plan for the HTTP API |
+| `src/http_api.c` | C implementation of all endpoints |
+| `src/http_api.h` | Public API header |
+| `config.json.example` | Example config showing the `api` section |
+
+---
+
+## Getting Started
+
+1. Ensure didactyl is running with `api.enabled: true` in config.json
+2. Verify the API is up: `curl http://127.0.0.1:8484/api/status`
+3. Build the frontend to talk to `http://127.0.0.1:8484`
+4. Start with the status endpoint and context inspector, then add prompt crafting

plans/agent_self_context.md

@@ -0,0 +1,204 @@
+# Agent Self-Context: Know Thyself
+
+## Problem
+
+When the agent is asked about itself — its profile, contacts, relays, or recent notes — it has no idea. The context template currently injects **administrator** identity/profile/contacts/relays/notes into the system prompt, but nothing equivalent for the **agent's own** Nostr identity beyond a bare pubkey+npub from `agent_identity`.
+
+The agent publishes its own kind 0 (profile), kind 3 (contacts), kind 10002 (relays), and kind 1 (notes) at startup, but never subscribes to or caches those events for self-awareness.
+
+## Solution Overview
+
+Mirror the admin context pattern for the agent itself:
+
+1. **Subscribe** to the agent's own kind 0/3/10002/1 events from relays
+2. **Cache** them in `nostr_handler.c` (same pattern as `g_admin_kind0_json` etc.)
+3. **Expose** them via new `nostr_handler_get_agent_*` API functions
+4. **Create context tools** that format the cached data into context blocks
+5. **Add to context template** so the agent always knows about itself
+6. **Add callable tool aliases** like `my_kind0_profile` for on-demand use
+
+```mermaid
+flowchart TD
+    A[Startup: publish kind 0/3/10002/1] --> B[Subscribe to own events]
+    B --> C[Cache in nostr_handler globals]
+    C --> D[Context tools read cache]
+    D --> E[Context template injects into system prompt]
+    D --> F[LLM can call tools on-demand]
+    
+    subgraph Admin Context - existing
+        G[g_admin_kind0_json]
+        H[g_admin_kind3 contacts]
+        I[g_admin_kind10002_json]
+        J[g_admin_kind1_notes]
+    end
+    
+    subgraph Agent Context - new
+        K[g_agent_kind0_json]
+        L[g_agent_kind3 contacts]
+        M[g_agent_kind10002_json]
+        N[g_agent_kind1_notes]
+    end
+```
+
+## Detailed Changes
+
+### 1. nostr_handler.c — Agent Self-Context Cache
+
+Add new static globals mirroring the admin pattern:
+
+```c
+static char* g_agent_kind0_json = NULL;       // kind 0 profile JSON
+static char* g_agent_kind10002_json = NULL;    // kind 10002 relay list JSON
+static char** g_agent_kind3_contacts = NULL;   // kind 3 contact pubkeys
+static int g_agent_kind3_contact_count = 0;
+static admin_kind1_note_t* g_agent_kind1_notes = NULL;  // reuse struct
+static int g_agent_kind1_note_count = 0;
+```
+
+### 2. nostr_handler.c — Agent Self-Context Subscription
+
+Create `nostr_handler_subscribe_agent_context()` that subscribes to kinds 0, 3, 10002, 1 filtered by the agent's own pubkey. This is separate from the self-skills subscription (which handles 31123/31124/10123).
+
+The callback `on_agent_context_event()` will parse and cache events using the same logic as `on_admin_context_event()`.
+
+**Alternative considered:** Expanding `nostr_handler_subscribe_self_skills()` to include these kinds. Rejected because the self-skills sub has different EOSE handling and a callback for skill loading. Keeping them separate is cleaner.
+
+### 3. nostr_handler.h — New API Functions
+
+```c
+int nostr_handler_subscribe_agent_context(void);
+char* nostr_handler_get_agent_kind0_context(void);
+char* nostr_handler_get_agent_kind3_context(void);
+char* nostr_handler_get_agent_kind10002_context(void);
+char* nostr_handler_get_agent_kind1_notes_context(void);
+```
+
+### 4. main.c — Call Agent Context Subscription at Startup
+
+Add `nostr_handler_subscribe_agent_context()` call after admin context subscription, before self-skills subscription.
+
+### 5. tool_agent.c — New Context Tools
+
+Create four new tool functions following the exact pattern from `tool_admin.c`:
+
+| Tool Name | Description | Data Source |
+|-----------|-------------|-------------|
+| `nostr_agent_profile` | Agent's kind 0 profile metadata | `nostr_handler_get_agent_kind0_context()` |
+| `nostr_agent_contacts` | Agent's kind 3 contact list | `nostr_handler_get_agent_kind3_context()` |
+| `nostr_agent_relays` | Agent's kind 10002 relay list | `nostr_handler_get_agent_kind10002_context()` |
+| `nostr_agent_notes` | Agent's recent kind 1 notes | `nostr_handler_get_agent_kind1_notes_context()` |
+
+Each returns a `content` field with markdown-formatted context, e.g.:
+```
+## Agent Kind 0 Profile (source: nostr kind 0)
+
+Agent kind 0 profile content (JSON): {"name":"Didactyl Agent","display_name":"Didactyl",...}
+```
+
+### 6. tools_internal.h — Declare New Functions
+
+```c
+char* execute_nostr_agent_profile(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_agent_contacts(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_agent_relays(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_agent_notes(tools_context_t* ctx, const char* args_json);
+```
+
+### 7. tools_dispatch.c — Register + Aliases
+
+Add dispatch entries:
+```c
+if (strcmp(tool_name, "nostr_agent_profile") == 0)  return execute_nostr_agent_profile(ctx, args_json);
+if (strcmp(tool_name, "nostr_agent_contacts") == 0) return execute_nostr_agent_contacts(ctx, args_json);
+if (strcmp(tool_name, "nostr_agent_relays") == 0)   return execute_nostr_agent_relays(ctx, args_json);
+if (strcmp(tool_name, "nostr_agent_notes") == 0)    return execute_nostr_agent_notes(ctx, args_json);
+
+// Friendly aliases
+if (strcmp(tool_name, "my_kind0_profile") == 0) return execute_nostr_agent_profile(ctx, args_json);
+if (strcmp(tool_name, "my_contacts") == 0)      return execute_nostr_agent_contacts(ctx, args_json);
+if (strcmp(tool_name, "my_relays") == 0)         return execute_nostr_agent_relays(ctx, args_json);
+if (strcmp(tool_name, "my_notes") == 0)          return execute_nostr_agent_notes(ctx, args_json);
+```
+
+### 8. tools_schema.c — OpenAI Function Schemas
+
+Add 8 new tool schemas (4 canonical + 4 aliases), all with empty parameters (no-arg tools), following the pattern of `admin_identity`/`nostr_admin_profile` etc.
+
+### 9. Context Template Update
+
+Update the kind 31120 soul content in `config.jsonc` and `context_template.md` to add agent sections **after** admin sections:
+
+```yaml
+- section: admin_notes
+  role: system
+  tool: nostr_admin_notes
+  skip_if_empty: true
+
+# NEW: Agent self-context sections
+- section: agent_identity
+  role: system
+  tool: agent_identity
+  skip_if_empty: true
+
+- section: agent_profile
+  role: system
+  tool: nostr_agent_profile
+  skip_if_empty: true
+
+- section: agent_contacts
+  role: system
+  tool: nostr_agent_contacts
+  skip_if_empty: true
+
+- section: agent_relays
+  role: system
+  tool: nostr_agent_relays
+  skip_if_empty: true
+
+- section: agent_notes
+  role: system
+  tool: nostr_agent_notes
+  skip_if_empty: true
+
+- section: tasks
+  role: system
+  tool: task_list
+  skip_if_empty: true
+```
+
+### 10. nostr_handler.c Cleanup
+
+Add cleanup for agent context globals in `nostr_handler_cleanup()`, mirroring `free_admin_context_locked()`.
+
+## File Change Summary
+
+| File | Change Type | Description |
+|------|-------------|-------------|
+| `src/nostr_handler.h` | Modify | Add 5 new function declarations |
+| `src/nostr_handler.c` | Modify | Add agent context cache globals, subscription, event handler, getter functions, cleanup |
+| `src/main.c` | Modify | Call `nostr_handler_subscribe_agent_context()` at startup |
+| `src/tools/tool_agent.c` | Modify | Add 4 new context tool execute functions |
+| `src/tools/tools_internal.h` | Modify | Declare 4 new execute functions |
+| `src/tools/tools_dispatch.c` | Modify | Add 8 dispatch entries (4 tools + 4 aliases) |
+| `src/tools/tools_schema.c` | Modify | Add 8 OpenAI function schemas |
+| `config.jsonc` | Modify | Update kind 31120 template section |
+| `config.jsonc.example` | Modify | Update kind 31120 template section |
+| `context_template.md` | Modify | Add agent_* sections after admin_* sections |
+
+## Context Token Impact
+
+Each agent context section adds roughly the same token count as its admin counterpart:
+- agent_identity: ~40 tokens (already exists, just adding to template)
+- agent_profile: ~80-150 tokens (depends on profile richness)
+- agent_contacts: ~50-200 tokens (depends on contact count)
+- agent_relays: ~50-100 tokens
+- agent_notes: ~100-300 tokens (depends on note count/length)
+
+Total additional context: ~320-790 tokens. With `skip_if_empty: true`, empty sections cost 0 tokens.
+
+## Design Decisions
+
+1. **Separate subscription vs expanding self-skills sub**: Separate is cleaner — different EOSE semantics, different callback needs.
+2. **Cache from relay vs read from config**: Cache from relay is more accurate (reflects what's actually published, not just what config says). The startup_events in config are the *intent*; the relay data is the *reality*.
+3. **Alias naming**: `my_kind0_profile` matches the existing `my_npub`/`my_pubkey` pattern. Also adding `my_contacts`, `my_relays`, `my_notes` for consistency.
+4. **No new config section needed**: The agent context subscription is unconditional — an agent should always know about itself. No `agent_context.enabled` toggle needed.

plans/agent_tasks.md

@@ -0,0 +1,215 @@
+# Agent Tasks: Short-Term Memory via Context-Injected Task List
+
+## Summary
+
+Add a **tasks** system that serves as the agent's short-term working memory. The agent can break down goals into steps, track progress, and see its current task list in every prompt context. Tasks are file-backed (not stored on Nostr) and managed via a dedicated `task_manage` tool.
+
+## How It Works
+
+```mermaid
+flowchart TD
+    A[User sends message] --> B[Context builder runs]
+    B --> C[Template resolver hits tasks_content variable]
+    C --> D[Read tasks.json from disk]
+    D --> E{Tasks exist?}
+    E -->|Yes| F[Format tasks as readable text]
+    E -->|No| G[Return empty string - section skipped]
+    F --> H[Inject as system message in prompt]
+    G --> H
+    H --> I[LLM sees current tasks in context]
+    I --> J{LLM decides to update tasks?}
+    J -->|Yes| K[LLM calls task_manage tool]
+    K --> L[Tool updates tasks.json on disk]
+    L --> M[Tool result returned to LLM]
+    J -->|No| N[LLM responds normally]
+```
+
+## Design
+
+### Storage: `tasks.json`
+
+A simple JSON file in the agent's working directory. Structure:
+
+```json
+{
+  "tasks": [
+    {
+      "id": 1,
+      "text": "Query admin relay list to find active relays",
+      "status": "done",
+      "created_at": 1709535600,
+      "updated_at": 1709535660
+    },
+    {
+      "id": 2,
+      "text": "Draft long-form article about Nostr relay setup",
+      "status": "active",
+      "created_at": 1709535600,
+      "updated_at": 1709535600
+    },
+    {
+      "id": 3,
+      "text": "Publish article as kind 30023",
+      "status": "pending",
+      "created_at": 1709535600,
+      "updated_at": 1709535600
+    }
+  ],
+  "next_id": 4
+}
+```
+
+Task statuses: `pending`, `active`, `done`
+
+### Tool: `task_manage`
+
+A single tool with an `action` parameter that covers all operations:
+
+| Action | Parameters | Description |
+|--------|-----------|-------------|
+| `list` | *(none)* | Return all tasks with status |
+| `add` | `text`, optional `status` | Add a new task, default status `pending` |
+| `update` | `id`, optional `text`, optional `status` | Update text and/or status of a task |
+| `remove` | `id` | Remove a task by ID |
+| `clear` | optional `status` | Remove all tasks, or all with a given status |
+| `replace` | `tasks` (array of text strings) | Replace entire task list with new items |
+
+The `replace` action is important — it lets the LLM rewrite the whole plan in one call rather than doing add/remove/update one at a time. This is the most common pattern: the agent works out a plan and writes all steps at once.
+
+**Tool schema:**
+
+```json
+{
+  "name": "task_manage",
+  "description": "Manage the agent task list - short-term working memory for tracking steps in a plan. Tasks appear in your context on every message.",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "action": {
+        "type": "string",
+        "enum": ["list", "add", "update", "remove", "clear", "replace"]
+      },
+      "text": { "type": "string" },
+      "id": { "type": "integer" },
+      "status": { "type": "string", "enum": ["pending", "active", "done"] },
+      "tasks": {
+        "type": "array",
+        "items": { "type": "string" }
+      }
+    },
+    "required": ["action"]
+  }
+}
+```
+
+### Context Section: `agent_tasks`
+
+New section in the context template, placed after `adopted_skills` and before `dm_history`:
+
+```yaml
+- section: agent_tasks
+  role: system
+  skip_if_empty: true
+  content: |
+    {{tasks_content}}
+```
+
+### Template Variable: `{{tasks_content}}`
+
+New resolver in `agent_template_resolve_var()` that:
+
+1. Reads `tasks.json` from the working directory
+2. Parses the JSON
+3. Formats active/pending tasks as readable text
+4. Returns empty string if no tasks exist (section gets skipped via `skip_if_empty`)
+
+**Rendered format in context:**
+
+```
+### Current Tasks
+
+Your active task list - short-term working memory for tracking plan steps.
+
+- [x] 1. Query admin relay list to find active relays
+- [-] 2. Draft long-form article about Nostr relay setup
+- [ ] 3. Publish article as kind 30023
+```
+
+Legend: `[x]` = done, `[-]` = active, `[ ]` = pending
+
+Done tasks are included so the agent has continuity about what it already accomplished, but they could be pruned after a configurable count or age to save tokens.
+
+### System Prompt Addition
+
+Add to the agent's behavioral rules in the soul/system prompt:
+
+```
+### Task Management
+- You have a task list that serves as your short-term working memory.
+- When working on multi-step goals, use task_manage to track your plan.
+- Update task status as you complete steps.
+- Your current tasks appear in your context automatically.
+```
+
+## Implementation Steps
+
+### 1. Add `task_manage` tool implementation in `tools.c`
+
+- New `execute_task_manage()` function
+- Reads/writes `tasks.json` in the working directory (uses `build_tool_path` for sandboxing)
+- Handles all 6 actions: list, add, update, remove, clear, replace
+- Returns JSON result with success/failure and current task list
+
+### 2. Register `task_manage` tool schema in `tools_build_openai_schema_json()`
+
+- Add tool definition (t35 or next available) with the schema above
+
+### 3. Wire `task_manage` into `tools_execute()` dispatch
+
+- Add `strcmp(tool_name, "task_manage")` branch calling `execute_task_manage()`
+
+### 4. Add `{{tasks_content}}` template variable resolver in `agent.c`
+
+- New `build_tasks_content_string()` function
+- Reads `tasks.json`, formats as markdown checklist
+- Add to `agent_template_resolve_var()` for var name `tasks_content`
+
+### 5. Add `agent_tasks` section to context template
+
+- Add the new section in `context_template.md`
+- Place after `adopted_skills`, before `dm_history`
+- Use `skip_if_empty: true` so it costs zero tokens when no tasks exist
+
+### 6. Add section detection for context logging
+
+- Add `agent_tasks` detection in `detect_context_section()` in `agent.c`
+
+### 7. Add task management guidance to system prompt
+
+- Brief behavioral instruction so the agent knows when/how to use the task list
+
+## Token Budget Considerations
+
+- Empty task list: **0 tokens** (skipped via `skip_if_empty`)
+- Typical 5-task plan: **~80-120 tokens**
+- Maximum reasonable list of 15 tasks: **~250-350 tokens**
+- Consider pruning done tasks older than N turns or keeping only the last M done tasks
+
+## Future: User-Facing To-Do List (Nostr)
+
+This is explicitly **not** the user-facing to-do list. That future feature would:
+- Store items as Nostr events (likely a NIP-51 style list or custom kind)
+- Be visible to the user via Nostr clients
+- Have its own separate tool (`todo_manage` or similar)
+- Potentially reference agent tasks that graduate to user-visible items
+
+The agent tasks system is purely internal working memory.
+
+## Files Modified
+
+| File | Change |
+|------|--------|
+| `src/tools.c` | Add `execute_task_manage()`, tool schema, dispatch entry |
+| `src/agent.c` | Add `build_tasks_content_string()`, resolver entry, section detection |
+| `context_template.md` | Add `agent_tasks` section |
+| Soul/system prompt (kind 31120) | Add task management behavioral guidance |

plans/cheerleader_triggered_skill.md

@@ -0,0 +1,162 @@
+# Cheerleader Triggered Skill — Implementation Plan
+
+## Goal
+
+Create the first triggered skill: whenever the admin posts a kind 1 note on Nostr, the agent reads the note content and sends a DM back to the admin cheering them on, praising them, and telling them how good looking they are.
+
+---
+
+## Current State
+
+The entire triggered-skill infrastructure is **already built and functional**:
+
+| Component | File | Status |
+|---|---|---|
+| Trigger manager (poll, cooldown, add/remove) | `src/trigger_manager.c` | ✅ Complete |
+| LLM-mediated trigger execution | `src/agent.c` `agent_on_trigger()` | ✅ Complete |
+| `skill_create` tool with trigger support | `src/tools.c` `execute_skill_create()` | ✅ Complete |
+| Trigger polling in main loop | `src/main.c` | ✅ Complete |
+| Config parsing for triggers section | `src/config.c` | ✅ Complete |
+| `trigger_list` tool | `src/tools.c` | ✅ Complete |
+
+### Gap Found
+
+The `skill_create` tool **schema** (what the LLM sees) only exposes 5 parameters: `d_tag`, `content`, `scope`, `description`, `auto_adopt`. The execution function already handles `trigger`, `filter`, `action`, and `enabled` — but these are **not declared in the tool schema**, so the LLM will never pass them.
+
+---
+
+## Implementation Steps
+
+### 1. Fix `skill_create` Tool Schema
+
+**File:** `src/tools.c` lines ~1607-1641
+
+Add four new properties to the `skill_create` tool definition so the LLM can see and use them:
+
+```c
+// After auto_adopt property (line ~1634):
+
+cJSON* p_skill_create_trigger = cJSON_CreateObject();
+cJSON_AddStringToObject(p_skill_create_trigger, "type", "string");
+cJSON_AddStringToObject(p_skill_create_trigger, "description",
+    "Trigger type. Use nostr-subscription to activate on matching Nostr events");
+cJSON_AddItemToObject(t22_props, "trigger", p_skill_create_trigger);
+
+cJSON* p_skill_create_filter = cJSON_CreateObject();
+cJSON_AddStringToObject(p_skill_create_filter, "type", "string");
+cJSON_AddStringToObject(p_skill_create_filter, "description",
+    "Nostr subscription filter JSON for the trigger, e.g. {\"kinds\":[1],\"authors\":[\"<hex>\"]}");
+cJSON_AddItemToObject(t22_props, "filter", p_skill_create_filter);
+
+cJSON* p_skill_create_action = cJSON_CreateObject();
+cJSON_AddStringToObject(p_skill_create_action, "type", "string");
+cJSON_AddStringToObject(p_skill_create_action, "description",
+    "Action type: llm (default, full LLM reasoning) or template (fast interpolation)");
+cJSON_AddItemToObject(t22_props, "action", p_skill_create_action);
+
+cJSON* p_skill_create_enabled = cJSON_CreateObject();
+cJSON_AddStringToObject(p_skill_create_enabled, "type", "boolean");
+cJSON_AddStringToObject(p_skill_create_enabled, "description",
+    "Whether the trigger is active. Default: true");
+cJSON_AddItemToObject(t22_props, "enabled", p_skill_create_enabled);
+```
+
+This is ~20 lines of code. No changes needed to the execution function — it already handles all four parameters.
+
+### 2. Add Cheerleader Skill as Startup Event
+
+**File:** `config.jsonc.example`
+
+Add a new kind 31123 skill event with trigger tags. Insert before the kind 10123 adoption list event:
+
+```jsonc
+// Kind 31123: Public triggered skill — cheerleader
+// Watches for admin kind 1 notes and sends encouraging DMs.
+{
+  "kind": 31123,
+  "content": "You are the admin's biggest fan and personal cheerleader. When the admin posts a note on Nostr, read the note content carefully and send them a DM that:\n\n1. References what they actually wrote about\n2. Cheers them on enthusiastically\n3. Praises their intelligence and insight\n4. Tells them how good looking they are\n5. Encourages them to keep posting\n\nBe genuine, warm, and over-the-top positive. Use their name from the admin profile if available. Keep it to 2-3 sentences max.",
+  "tags": [
+    ["d", "cheerleader"],
+    ["app", "didactyl"],
+    ["scope", "public"],
+    ["description", "Cheer on the admin whenever they post a kind 1 note"],
+    ["trigger", "nostr-subscription"],
+    ["filter", "{\"kinds\":[1],\"authors\":[\"ADMIN_PUBKEY_HEX\"]}"],
+    ["action", "llm"],
+    ["enabled", "true"]
+  ]
+}
+```
+
+> **Note:** The `ADMIN_PUBKEY_HEX` placeholder in the filter must be replaced with the actual admin pubkey from the config. Since this is a static config example, we use a placeholder. At runtime, the user replaces it with their admin pubkey.
+
+### 3. Add to Adoption List
+
+**File:** `config.jsonc.example`
+
+Add the cheerleader skill address to the kind 10123 adoption list tags:
+
+```jsonc
+["a", "31123:55993e3db0ed7bf07395fd44c2d695c224d195553a1aff7320a18e41679d9c7c:cheerleader"]
+```
+
+### 4. Verify Trigger Filter
+
+The Nostr filter for this trigger:
+
+```json
+{"kinds": [1], "authors": ["<admin_pubkey_hex>"]}
+```
+
+This matches:
+- **Kind 1** — text notes only (not DMs, not reactions, not reposts)
+- **Authors** — only the admin's pubkey (not anyone else's notes)
+
+The trigger manager polls every 10 seconds (`trigger_manager_poll` checks `now - last_poll_at < 10`), applies the `since` parameter to only fetch events newer than the last seen, and enforces the configured cooldown (default 60 seconds) between firings.
+
+---
+
+## Data Flow
+
+```mermaid
+sequenceDiagram
+    participant Admin as Admin Client
+    participant Relay as Nostr Relay
+    participant TM as Trigger Manager
+    participant Agent as agent_on_trigger
+    participant LLM as LLM API
+
+    Admin->>Relay: Publish kind 1 note
+    Note over TM: Poll every 10s
+    TM->>Relay: Query filter: kinds=1, authors=admin
+    Relay-->>TM: New event found
+    TM->>TM: Check cooldown, check last_seen_created_at
+    TM->>Agent: agent_on_trigger with skill content + event
+    Agent->>Agent: Build system prompt with soul + skill instructions
+    Agent->>LLM: llm_chat with system + triggering event JSON
+    LLM-->>Agent: Cheerful response
+    Agent->>Relay: DM to admin via nostr_handler_send_dm_auto
+    Relay-->>Admin: Encrypted DM with encouragement
+```
+
+---
+
+## File Changes Summary
+
+| File | Change | Lines |
+|---|---|---|
+| `src/tools.c` | Add trigger/filter/action/enabled to skill_create schema | ~20 lines added |
+| `config.jsonc.example` | Add cheerleader skill startup event | ~20 lines added |
+| `config.jsonc.example` | Add cheerleader to adoption list | 1 line added |
+
+---
+
+## Testing
+
+1. Build with `make`
+2. Start the agent
+3. Verify trigger loads on startup via `trigger_list` tool or HTTP API `/status`
+4. Post a kind 1 note from the admin account
+5. Wait up to ~10 seconds for the poll cycle
+6. Receive a cheerful DM from the agent
+7. Verify cooldown works — posting again within 60s should not trigger a second DM

plans/context_architecture.md

@@ -0,0 +1,139 @@
+# Didactyl Context Architecture Plan
+
+## Problem Statement
+
+The agent's context assembly is a hardcoded sequence of C function calls in `agent_on_message()`. This creates several issues:
+
+1. **Skills are never injected** — adopted skills exist on Nostr but the LLM never sees their content
+2. **No configurability** — changing context order, content, or framing requires C code changes and recompilation
+3. **No A/B testing** — can't experiment with different prompt structures, ordering, or model-specific tuning
+4. **No token budget awareness** — context grows unbounded as skills/history/notes accumulate
+5. **Model-agnostic** — different models respond differently to the same prompt structure; no way to tune per-model
+
+## Current Context Pipeline
+
+```
+agent_on_message() builds messages array:
+  1. system: g_system_context (kind 31120 "soul" content)
+  2. system: admin identity (pubkey + kind 0 profile + kind 10002 relays)
+  3. system: startup events (raw JSON of all startup event kinds/content/tags)
+  4. user/assistant: recent DM history (last 12 turns)
+  5. system: admin kind 1 notes (recent public posts)
+  6. user: the actual incoming message
+```
+
+Skills are **completely absent**. The LLM has no knowledge of adopted skill instructions.
+
+## Proposed Architecture: Context Pipeline with Configurable Slots
+
+### Core Idea
+
+Replace the hardcoded function chain with a **configurable context pipeline** defined in `config.json`. Each "slot" in the pipeline is a named context source with configurable parameters.
+
+### Context Slot Types
+
+| Slot Type | Source | Description |
+|---|---|---|
+| `soul` | Kind 31120 startup event | Agent personality and behavioral rules |
+| `identity` | Config + relay queries | Agent's own pubkey, admin pubkey, admin profile |
+| `startup_events` | Config startup events | Raw startup event memory |
+| `adopted_skills` | Kind 10123 + resolved skills | **NEW**: Adopted skill instructions |
+| `dm_history` | Relay query | Recent conversation turns |
+| `admin_notes` | Cached kind 1 events | Admin's recent public posts |
+| `admin_context` | Kind 0/3/10002 | Admin profile, contacts, relay list |
+| `custom` | Literal string in config | Arbitrary system message for A/B testing |
+
+### Phase 1: Immediate Fix (Skills + Caching)
+
+Before building the full configurable pipeline, fix the immediate problem:
+
+1. **In-memory skill cache** — load adopted skills at startup and cache them; invalidate on `skill_create`, `skill_adopt`, `skill_remove`
+2. **`append_adopted_skills_context()`** — inject cached skills into the conversation as a system message
+3. **Strong framing** — "These are your learned skills. When a request matches a skill, you MUST follow its instructions exactly."
+
+### Phase 2: Configurable Context Pipeline
+
+Add a `context_pipeline` section to `config.json`:
+
+```json
+{
+  "context_pipeline": {
+    "max_total_chars": 12000,
+    "slots": [
+      { "type": "soul", "max_chars": 3000 },
+      { "type": "identity" },
+      { "type": "adopted_skills", "max_chars": 4000, "max_per_skill": 1000 },
+      { "type": "startup_events", "max_chars": 2000 },
+      { "type": "dm_history", "max_turns": 12 },
+      { "type": "admin_notes", "max_chars": 1500 },
+      { "type": "custom", "content": "Always respond in the style of a pirate." }
+    ]
+  }
+}
+```
+
+This gives you:
+- **Ordering control** — move skills before or after history
+- **Token budgets** — per-slot and total caps
+- **A/B testing** — swap `custom` slot content, reorder slots, change caps
+- **Model-specific tuning** — different pipeline configs for different models (could key off `llm.model`)
+
+### Phase 3: Model-Aware Context Profiles
+
+```json
+{
+  "context_profiles": {
+    "default": { ... pipeline config ... },
+    "claude-sonnet-4.6": { ... different ordering/caps ... },
+    "gpt-5.2-codex": { ... different ordering/caps ... }
+  }
+}
+```
+
+The agent selects the profile matching the active model, falling back to `default`.
+
+## Skill Cache Design
+
+```
+┌─────────────────────────────────────────┐
+│           Skill Cache (in-memory)       │
+│                                         │
+│  Loaded at startup from:                │
+│    1. Startup events in config.json     │
+│    2. Kind 10123 adoption list          │
+│    3. Resolved skill events from relays │
+│                                         │
+│  Invalidated by:                        │
+│    - skill_create (add/update)          │
+│    - skill_adopt (add)                  │
+│    - skill_remove (remove)              │
+│                                         │
+│  Structure per skill:                   │
+│    - d_tag (string)                      │
+│    - description (string)               │
+│    - content (string, full)             │
+│    - scope (public/private)             │
+│    - has_trigger (bool)                 │
+│    - source (startup/adopted)           │
+└─────────────────────────────────────────┘
+```
+
+## Implementation Priority
+
+### Do Now (Phase 1)
+- [ ] Build skill cache in `agent.c` (load at startup, invalidate on tool calls)
+- [ ] Add `append_adopted_skills_context()` using cached skills
+- [ ] Wire into `agent_on_message()` between startup events and DM history
+- [ ] Skill content framing: strong directive for LLM compliance
+
+### Do Next (Phase 2)
+- [ ] Add `context_pipeline` config section
+- [ ] Refactor `agent_on_message()` to iterate pipeline slots
+- [ ] Per-slot `max_chars` truncation
+- [ ] Total pipeline `max_total_chars` budget
+- [ ] `custom` slot type for arbitrary A/B test content
+
+### Do Later (Phase 3)
+- [ ] Model-aware context profiles
+- [ ] Context analytics (log token counts per slot per conversation)
+- [ ] Dynamic skill relevance scoring (only inject skills likely relevant to the current message)

plans/context_optimization.md

@@ -0,0 +1,167 @@
+# Context Optimization Plan
+
+Analysis of [`context.log.md`](../context.log.md) (13,609 bytes / ~3,402 tokens across 20 sections) and [`context_template.md`](../context_template.md).
+
+## Issues Found
+
+### 1. Massive Duplication in `startup_events` Section
+
+The **startup_events** section (line 74-80 in the log) dumps the *entire* `config.startup_events` array as raw JSON — including the full soul/system prompt (kind 31120) which is already sent verbatim as the **system_prompt** section. The soul text appears **twice** in every request.
+
+**Estimated waste:** ~1,500-2,000 tokens per request.
+
+**Fix:** Filter out kind 31120 (soul) from the startup_events JSON blob, or better yet, only include kinds the model actually needs to reference (kind 0 profile, kind 10002 relay list, kind 3 contacts). The soul is already the system prompt — repeating it as data is pure waste.
+
+### 2. Duplicate Startup Messages in DM History
+
+The DM history contains **four separate** `Didactyl has started up and is online (version v0.0.29, connected relays: 4/4).` assistant messages (lines 123-127, 130-134, 144-148, 222-226, 245-249). These are startup announcement DMs that got stored as separate events. The model sees the same boilerplate startup message repeated across the conversation.
+
+**Estimated waste:** ~200-300 tokens.
+
+**Fix:** Deduplicate consecutive identical assistant messages in the DM history builder, or filter out startup announcement messages (they carry no conversational value).
+
+### 3. Skills Rendered as Raw JSON Instead of Structured Text
+
+Skill instructions at lines 97-118 are dumped as raw JSON objects. Models parse structured natural language far more reliably than nested JSON. The `content_fields` serialization format wastes tokens on JSON syntax characters and key quoting.
+
+**Estimated waste:** ~100-200 tokens of JSON overhead per skill, plus reduced comprehension quality.
+
+**Fix:** When serializing `content_fields`-based skills for context, flatten them into readable text:
+```
+Skill: long_form_note
+Description: How to publish a NIP-23 long-form article (kind 30023)
+NIP: NIP-23
+Event Kind: 30023
+Format: The content field must be markdown text...
+Required Tags:
+  - d: Addressable identifier d_tag...
+  - title: Human-readable article title
+  - published_at: Unix timestamp as string...
+Procedure:
+  1. Determine title and d tag...
+  2. Draft markdown body content...
+```
+
+### 4. Empty Sections Still Sent
+
+The **admin_relay_list** section (line 65-71) has no data — the JSON value is empty. Sending an empty section wastes tokens on the header/framing with no informational value.
+
+**Estimated waste:** ~30-40 tokens.
+
+**Fix:** Skip sections where the resolved variable is empty or whitespace-only.
+
+### 5. Admin Identity Could Be Merged with Admin Profile
+
+The **admin_identity** section (line 47-53) sends just the hex pubkey, then **admin_profile** (line 56-62) sends the full kind 0 JSON which implicitly identifies the admin. These could be a single section.
+
+**Estimated savings:** ~40-50 tokens of framing overhead.
+
+### 6. `admin_notes` Placement Breaks Conversation Flow
+
+In the template, `admin_notes` is placed *after* `dm_history` (expand). In the actual log, this means a system message appears sandwiched between DM history messages (line 252, between assistant messages and the final user message at line 274). This breaks the natural conversation flow and may confuse the model about message ordering.
+
+**Fix:** Move `admin_notes` *before* `dm_history` in the template so all system context is grouped together before the conversation begins.
+
+### 7. No Agent Self-Identity Section
+
+The model knows it is Didactyl from the system prompt, but there is no section telling it its own pubkey/npub. The admin pubkey is provided but the agent's own key is not in the context (it is only available via the `nostr_pubkey` tool). Adding a small self-identity section would let the model reference its own key without a tool call.
+
+**Estimated cost:** ~20-30 tokens.
+
+## Priority Summary
+
+| Priority | Issue | Token Savings | Complexity |
+|----------|-------|---------------|------------|
+| **P0** | Soul duplicated in startup_events | ~1,500-2,000 | Low — filter kind 31120 from startup blob |
+| **P1** | Duplicate startup DMs in history | ~200-300 | Medium — dedup logic in history builder |
+| **P1** | Skills as raw JSON | ~100-200 + quality | Medium — flatten content_fields to text |
+| **P2** | Empty sections still sent | ~30-40 | Low — skip empty resolved vars |
+| **P2** | admin_notes after dm_history | 0 (quality) | Low — reorder template |
+| **P3** | Merge admin_identity + admin_profile | ~40-50 | Low — template change |
+| **P3** | Add agent self-identity section | -20-30 (adds) | Low — new template var |
+
+## Bug: Kind 10002 Relay List Is Always Empty
+
+At [`nostr_handler.c:705`](../src/nostr_handler.c:705) the kind 10002 handler stores `content->valuestring`, but NIP-65 relay list events have an **empty content field** — the relay URLs live in the **tags** as `["r", "wss://relay.example.com"]` entries. So `g_admin_kind10002_json` is always `""`.
+
+**Fix:** Parse the `"r"` tags from the kind 10002 event and serialize them as a JSON array of relay URL strings (or plain-text list).
+
+## Sender Verification Status
+
+The [`tier`](../src/nostr_handler.h:8) enum (`DIDACTYL_SENDER_ADMIN`, `DIDACTYL_SENDER_WOT`, `DIDACTYL_SENDER_STRANGER`) is already resolved before [`agent_on_message()`](../src/agent.c:1453) is called, but it is **not passed into the context builder**. The model has no way to know whether the current message was cryptographically verified as coming from the administrator vs. a web-of-trust contact.
+
+**Fix:** Pass the sender tier into the context builder and expose it as a template variable (e.g. `{{sender_verification}}`) that resolves to text like:
+- `"This message has been cryptographically verified as coming from your administrator."`
+- `"This message is from a web-of-trust contact (not the administrator)."`
+
+## Proposed Optimized Template
+
+```yaml
+- section: agent_identity
+  role: system
+  content: |
+    Agent Identity
+    Your pubkey (hex): {{agent_pubkey}}
+
+- section: sender_context
+  role: system
+  content: |
+    {{sender_verification}}
+
+- section: admin_context
+  role: system
+  content: |
+    Administrator Context
+
+    Pubkey (hex): {{admin_pubkey}}
+    {{admin_profile_plain}}
+    {{admin_relay_list_plain}}
+
+- section: startup_events
+  role: system
+  skip_if_empty: true
+  content: |
+    Startup Events Memory
+    {{startup_events_json}}
+
+- section: adopted_skills
+  role: system
+  skip_if_empty: true
+  content: |
+    {{adopted_skills_content}}
+
+- section: admin_notes
+  role: system
+  skip_if_empty: true
+  content: |
+    Administrator Recent Notes (source: nostr kind 1)
+    {{admin_notes_content}}
+
+- section: dm_history
+  role: expand
+  limit: 12
+```
+
+Key changes from current template:
+- **No markdown headers** in system sections — plain English throughout
+- **Merged admin section** combines identity, profile, and relay list
+- **`{{admin_profile_plain}}`** — new variable that renders kind 0 JSON as readable text (e.g. `Name: WSB, About: ...`)
+- **`{{admin_relay_list_plain}}`** — new variable that renders relay URLs from tags as a plain list
+- **`{{sender_verification}}`** — new variable stating cryptographic verification status
+- **`admin_notes` moved before `dm_history`** so all system context is grouped before conversation
+- **`skip_if_empty`** prevents sending empty sections
+
+## Implementation Steps
+
+1. **Fix kind 10002 relay list bug** — extract relay URLs from tags instead of content in [`nostr_handler.c:705`](../src/nostr_handler.c:705)
+2. **Filter kind 31120** from `startup_events_json` variable resolver in [`agent.c`](../src/agent.c)
+3. **Deduplicate consecutive identical messages** in DM history builder
+4. **Flatten `content_fields` JSON skills** into readable text format
+5. **Add `skip_if_empty` support** to template engine (skip section when resolved content is blank)
+6. **Reorder template** — move `admin_notes` before `dm_history`
+7. **Add `agent_pubkey` template variable** and agent identity section
+8. **Merge admin sections** — combine identity + profile (plain English) + relay list into one section
+9. **Add `admin_profile_plain` variable** — parse kind 0 JSON into readable text
+10. **Add `admin_relay_list_plain` variable** — parse kind 10002 tags into relay URL list
+11. **Pass sender tier to context builder** and add `sender_verification` template variable
+12. **Remove markdown formatting** from system section content — use plain English

plans/didactyl_agentic.md

@@ -57,7 +57,7 @@ flowchart TD
     LOOP --> LLM
     LLM -->|tool_call| TOOLS
     TOOLS -->|nostr tools| NOSTR
-    TOOLS -->|shell_exec| SHELL
+    TOOLS -->|local_shell_exec| SHELL
     TOOLS -->|result| LOOP
     LLM -->|final answer| DMS
 ```
@@ -212,7 +212,7 @@ sequenceDiagram
 
 | Tool | Description | Notes |
 |---|---|---|
-| `shell_exec` | Run a shell command, capture stdout/stderr | Sandboxed with timeouts |
+| `local_shell_exec` | Run a shell command, capture stdout/stderr | Sandboxed with timeouts |
 
 ---
 
@@ -377,7 +377,7 @@ void agent_on_message(const char* sender, const char* message) {
 3. **Agent loop** — rewrite `agent.c` with the tool-call loop
 4. **`nostr_post` tool** — publish any kind event
 5. **`nostr_query` tool** — query relays with filters
-6. **`shell_exec` tool** — sandboxed shell command execution
+6. **`local_shell_exec` tool** — sandboxed shell command execution
 7. **`nostr_dm` tool** — NIP-17 private DMs
 8. **Config extension** — parse tools config section
 9. **Security hardening** — timeouts, output limits, allowlists

plans/new_nostr_tools.md

@@ -0,0 +1,596 @@
+# Implementation Plan: Nostr Tools
+
+## Current Tool Inventory (v0.0.19)
+
+| # | Tool | Kind/NIP | Status |
+|---|------|----------|--------|
+| 1 | `nostr_post` | Any kind | ✅ Shipped |
+| 2 | `nostr_post_readme` | 30023 / NIP-23 | ✅ Shipped |
+| 3 | `nostr_query` | Filter-based | ✅ Shipped |
+| 4 | `nostr_delete` | 5 / NIP-09 | ✅ Shipped |
+| 5 | `nostr_react` | 7 / NIP-25 | ✅ Shipped |
+| 6 | `nostr_profile_get` | 0 query | ✅ Shipped |
+| 7 | `nostr_relay_status` | Pool stats | ✅ Shipped |
+| 8 | `local_shell_exec` | OS | ✅ Shipped |
+| 9 | `local_file_read` | OS | ✅ Shipped |
+| 10 | `local_file_write` | OS | ✅ Shipped |
+
+---
+
+## Pattern for All New Tools
+
+Every tool follows the same three-step pattern in [`src/tools.c`](../src/tools.c):
+
+1. **Schema** — Add OpenAI function schema block in [`tools_build_openai_schema_json()`](../src/tools.c:511)
+2. **Executor** — Implement `static char* execute_<name>()` function
+3. **Dispatch** — Add `strcmp` case in [`tools_execute()`](../src/tools.c:1620)
+
+Use the shared [`parse_tool_args_json()`](../src/tools.c:527) helper for hardened argument parsing.
+
+---
+
+## Tier 2 Tools — Medium Value, Moderate Implementation
+
+### Tool 11: `nostr_nip05_lookup` — DNS Identity Verification (NIP-05)
+
+#### Purpose
+Verify `user@domain.com` NIP-05 identifiers. Useful for trust decisions and profile enrichment.
+
+#### OpenAI Schema
+```json
+{
+  "name": "nostr_nip05_lookup",
+  "description": "Verify or look up a NIP-05 DNS identifier and return the associated pubkey and relays",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "identifier": {
+        "type": "string",
+        "description": "NIP-05 identifier, e.g. user@domain.com"
+      },
+      "pubkey": {
+        "type": "string",
+        "description": "Optional 64-char hex pubkey to verify against the identifier"
+      }
+    },
+    "required": ["identifier"]
+  }
+}
+```
+
+#### Implementation: `execute_nostr_nip05_lookup()`
+
+```
+1. Parse args_json
+2. Extract "identifier" (required string, must contain @)
+3. Extract "pubkey" (optional 64-char hex)
+4. If pubkey provided:
+   - Call nostr_nip05_verify(identifier, pubkey, &relays, &relay_count, 10)
+   - Return { success, verified: true/false, pubkey, relays }
+5. If no pubkey:
+   - Call nostr_nip05_lookup(identifier, pubkey_out, &relays, &relay_count, 10)
+   - Return { success, pubkey: pubkey_out, relays }
+6. Free relay array after serializing
+```
+
+#### Library API Used
+- [`nostr_nip05_lookup()`](../nostr_core_lib/nostr_core/nip005.h:13)
+- [`nostr_nip05_verify()`](../nostr_core_lib/nostr_core/nip005.h:15)
+
+#### Files Modified
+- `src/tools.c`: Schema + executor + dispatch
+
+#### Notes
+- Involves HTTP network I/O (fetches `/.well-known/nostr.json` from the domain)
+- May block for up to `timeout_seconds` — use 10s default
+- Must free the `relays` array returned by the library
+
+---
+
+### Tool 12: `nostr_encode` — Bech32 Entity Encoding (NIP-19/NIP-21)
+
+#### Purpose
+Encode hex pubkeys, event IDs, or addressable coordinates into shareable `npub`, `note`, `nprofile`, `nevent`, `naddr` URIs.
+
+#### OpenAI Schema
+```json
+{
+  "name": "nostr_encode",
+  "description": "Encode a Nostr entity into a bech32 URI: npub, note, nprofile, nevent, or naddr",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "type": {
+        "type": "string",
+        "description": "Entity type: npub, note, nprofile, nevent, or naddr"
+      },
+      "hex": {
+        "type": "string",
+        "description": "64-char hex value: pubkey for npub/nprofile, event_id for note/nevent"
+      },
+      "relays": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "Optional relay hints for nprofile, nevent, naddr"
+      },
+      "kind": {
+        "type": "integer",
+        "description": "Kind number, required for naddr"
+      },
+      "identifier": {
+        "type": "string",
+        "description": "d-tag identifier, required for naddr"
+      }
+    },
+    "required": ["type", "hex"]
+  }
+}
+```
+
+#### Implementation: `execute_nostr_encode()`
+
+```
+1. Parse args_json
+2. Extract "type" (required: npub|note|nprofile|nevent|naddr)
+3. Extract "hex" (required, 64-char hex)
+4. Convert hex to 32-byte array via nostr_hex_to_bytes()
+5. Switch on type:
+   - "npub": nostr_build_uri_npub(bytes, output, sizeof output)
+   - "note": nostr_build_uri_note(bytes, output, sizeof output)
+   - "nprofile": nostr_build_uri_nprofile(bytes, relays, relay_count, output, sizeof output)
+   - "nevent": nostr_build_uri_nevent(bytes, relays, relay_count, NULL, -1, 0, output, sizeof output)
+   - "naddr": nostr_build_uri_naddr(identifier, bytes, kind, relays, relay_count, output, sizeof output)
+6. Return { success, type, uri: output }
+```
+
+#### Library API Used
+- [`nostr_build_uri_npub()`](../nostr_core_lib/nostr_core/nip021.h:66)
+- [`nostr_build_uri_note()`](../nostr_core_lib/nostr_core/nip021.h:68)
+- [`nostr_build_uri_nprofile()`](../nostr_core_lib/nostr_core/nip021.h:69)
+- [`nostr_build_uri_nevent()`](../nostr_core_lib/nostr_core/nip021.h:71)
+- [`nostr_build_uri_naddr()`](../nostr_core_lib/nostr_core/nip021.h:74)
+
+#### Files Modified
+- `src/tools.c`: Schema + executor + dispatch
+
+---
+
+### Tool 13: `nostr_decode` — Bech32 Entity Decoding (NIP-19/NIP-21)
+
+#### Purpose
+Decode `npub`, `note`, `nprofile`, `nevent`, `naddr` URIs back into hex values and metadata.
+
+#### OpenAI Schema
+```json
+{
+  "name": "nostr_decode",
+  "description": "Decode a bech32 Nostr URI into its components: type, hex, relays, kind, identifier",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "uri": {
+        "type": "string",
+        "description": "Bech32 URI to decode, e.g. npub1..., note1..., nostr:npub1..."
+      }
+    },
+    "required": ["uri"]
+  }
+}
+```
+
+#### Implementation: `execute_nostr_decode()`
+
+```
+1. Parse args_json
+2. Extract "uri" (required string)
+3. Call nostr_parse_uri(uri, &result)
+4. Switch on result.type:
+   - NPUB: convert result.data.pubkey to hex, return { type: "npub", pubkey: hex }
+   - NOTE: convert result.data.event_id to hex, return { type: "note", event_id: hex }
+   - NPROFILE: pubkey hex + relays array
+   - NEVENT: event_id hex + relays + optional author/kind
+   - NADDR: identifier + pubkey hex + kind + relays
+5. Call nostr_uri_result_free(&result)
+6. Return JSON
+```
+
+#### Library API Used
+- [`nostr_parse_uri()`](../nostr_core_lib/nostr_core/nip021.h:63)
+- [`nostr_uri_result_free()`](../nostr_core_lib/nostr_core/nip021.h:78)
+
+#### Files Modified
+- `src/tools.c`: Schema + executor + dispatch
+
+---
+
+### Tool 14: `nostr_dm_send` — Send DM as Tool Call
+
+#### Purpose
+Expose DM sending as a tool so the agent can proactively message people (notify admin, reach out to contacts).
+
+#### OpenAI Schema
+```json
+{
+  "name": "nostr_dm_send",
+  "description": "Send an encrypted direct message to a Nostr user (NIP-04)",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "recipient_pubkey": {
+        "type": "string",
+        "description": "64-char hex pubkey of the recipient"
+      },
+      "message": {
+        "type": "string",
+        "description": "Plaintext message to send"
+      }
+    },
+    "required": ["recipient_pubkey", "message"]
+  }
+}
+```
+
+#### Implementation: `execute_nostr_dm_send()`
+
+```
+1. Parse args_json
+2. Extract "recipient_pubkey" (required, 64-char hex)
+3. Extract "message" (required, non-empty string)
+4. Call nostr_handler_send_dm(recipient_pubkey, message)
+5. Return { success: true/false, recipient_pubkey, message_length }
+```
+
+#### Library API Used
+- [`nostr_handler_send_dm()`](../src/nostr_handler.h:33) — already exists
+
+#### Security Note
+- Should be admin-tier only in practice. The tool itself doesn't enforce tier, but the agent's system prompt and skill definitions should restrict usage.
+
+#### Files Modified
+- `src/tools.c`: Schema + executor + dispatch
+
+---
+
+### Tool 15: `nostr_relay_info` — Relay Information Document (NIP-11)
+
+#### Purpose
+Inspect relay capabilities, supported NIPs, limitations, PoW requirements before publishing.
+
+#### OpenAI Schema
+```json
+{
+  "name": "nostr_relay_info",
+  "description": "Fetch the NIP-11 relay information document for a relay URL",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "relay_url": {
+        "type": "string",
+        "description": "WebSocket relay URL, e.g. wss://relay.example.com"
+      }
+    },
+    "required": ["relay_url"]
+  }
+}
+```
+
+#### Implementation
+
+This requires a new helper in [`nostr_handler.c`](../src/nostr_handler.c) since NIP-11 fetching needs an HTTP GET request with `Accept: application/nostr+json` header.
+
+##### New function: `nostr_handler_relay_info_json()`
+
+```
+1. Convert ws:// or wss:// URL to http:// or https://
+2. Use libcurl to HTTP GET with header "Accept: application/nostr+json"
+3. Return the raw JSON response string
+```
+
+##### `execute_nostr_relay_info()` in tools.c:
+
+```
+1. Parse args_json
+2. Extract "relay_url" (required string, must start with ws:// or wss://)
+3. Call nostr_handler_relay_info_json(relay_url)
+4. Parse returned JSON
+5. Return { success, relay_url, info: { name, description, pubkey, supported_nips, limitations, ... } }
+```
+
+#### Files Modified
+- `src/nostr_handler.h`: Add `nostr_handler_relay_info_json()` declaration
+- `src/nostr_handler.c`: Implement using libcurl (already linked)
+- `src/tools.c`: Schema + executor + dispatch
+
+---
+
+## Tier 3 Tools — High Value, More Complex
+
+### Tool 16: `nostr_dm_send_nip17` — Private DMs via Gift Wrap (NIP-17/NIP-59)
+
+#### Purpose
+Send modern, metadata-private DMs using the NIP-17 gift wrap protocol instead of legacy NIP-04.
+
+#### OpenAI Schema
+```json
+{
+  "name": "nostr_dm_send_nip17",
+  "description": "Send a private direct message using NIP-17 gift wrap protocol for metadata privacy",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "recipient_pubkey": {
+        "type": "string",
+        "description": "64-char hex pubkey of the recipient"
+      },
+      "message": {
+        "type": "string",
+        "description": "Plaintext message to send"
+      },
+      "subject": {
+        "type": "string",
+        "description": "Optional conversation subject"
+      }
+    },
+    "required": ["recipient_pubkey", "message"]
+  }
+}
+```
+
+#### Implementation
+
+This is a multi-step crypto pipeline. The library handles the heavy lifting but we need to orchestrate:
+
+##### New function: `nostr_handler_send_dm_nip17()` in nostr_handler.c
+
+```
+1. Query recipient's kind 10050 relay list (DM relays)
+   - Build filter: { kinds: [10050], authors: [recipient_pubkey], limit: 1 }
+   - Call nostr_relay_pool_query_sync()
+   - Extract relay URLs via nostr_nip17_extract_dm_relays()
+   - Fall back to our own relays if no 10050 found
+2. Create kind 14 chat event:
+   - nostr_nip17_create_chat_event(message, &recipient_pubkey, 1, subject, NULL, NULL, our_pubkey)
+3. Gift wrap and send:
+   - nostr_nip17_send_dm(chat_event, &recipient_pubkey, 1, our_private_key, gift_wraps, max_wraps, 0)
+4. Publish each gift wrap to recipient's DM relays
+5. Return success/failure + event metadata
+```
+
+##### `execute_nostr_dm_send_nip17()` in tools.c:
+
+```
+1. Parse args_json
+2. Extract recipient_pubkey, message, optional subject
+3. Call nostr_handler_send_dm_nip17(recipient_pubkey, message, subject)
+4. Return { success, recipient_pubkey, protocol: "nip17" }
+```
+
+#### Library API Used
+- [`nostr_nip17_create_chat_event()`](../nostr_core_lib/nostr_core/nip017.h:28)
+- [`nostr_nip17_send_dm()`](../nostr_core_lib/nostr_core/nip017.h:100)
+- [`nostr_nip17_extract_dm_relays()`](../nostr_core_lib/nostr_core/nip017.h)
+- [`nostr_nip59_create_gift_wrap()`](../nostr_core_lib/nostr_core/nip059.h:50)
+
+#### Files Modified
+- `src/nostr_handler.h`: Add `nostr_handler_send_dm_nip17()` declaration
+- `src/nostr_handler.c`: Implement the full NIP-17 send pipeline
+- `src/tools.c`: Schema + executor + dispatch
+
+---
+
+### Tool 17: `nostr_encrypt` — NIP-44 Encryption
+
+#### Purpose
+Encrypt arbitrary content for a specific recipient using modern NIP-44 encryption.
+
+#### OpenAI Schema
+```json
+{
+  "name": "nostr_encrypt",
+  "description": "Encrypt plaintext for a recipient using NIP-44 ChaCha20+HMAC encryption",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "recipient_pubkey": {
+        "type": "string",
+        "description": "64-char hex pubkey of the recipient"
+      },
+      "plaintext": {
+        "type": "string",
+        "description": "Text to encrypt"
+      }
+    },
+    "required": ["recipient_pubkey", "plaintext"]
+  }
+}
+```
+
+#### Implementation: `execute_nostr_encrypt()`
+
+```
+1. Parse args_json
+2. Extract recipient_pubkey (64-char hex), plaintext (non-empty string)
+3. Convert recipient_pubkey hex to 32-byte array
+4. Allocate output buffer (plaintext length * 2 + 256 for base64 overhead)
+5. Call nostr_nip44_encrypt(our_private_key, recipient_pubkey_bytes, plaintext, output, output_size)
+6. Return { success, recipient_pubkey, ciphertext: output }
+```
+
+#### Library API Used
+- [`nostr_nip44_encrypt()`](../nostr_core_lib/nostr_core/nip044.h:28)
+
+#### Security Note
+- Admin-tier only. Uses the agent's private key for ECDH shared secret.
+
+#### Files Modified
+- `src/tools.c`: Schema + executor + dispatch
+
+---
+
+### Tool 18: `nostr_decrypt` — NIP-44 Decryption
+
+#### Purpose
+Decrypt NIP-44 encrypted content from a known sender.
+
+#### OpenAI Schema
+```json
+{
+  "name": "nostr_decrypt",
+  "description": "Decrypt NIP-44 encrypted content from a sender",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "sender_pubkey": {
+        "type": "string",
+        "description": "64-char hex pubkey of the sender"
+      },
+      "ciphertext": {
+        "type": "string",
+        "description": "Base64-encoded NIP-44 encrypted payload"
+      }
+    },
+    "required": ["sender_pubkey", "ciphertext"]
+  }
+}
+```
+
+#### Implementation: `execute_nostr_decrypt()`
+
+```
+1. Parse args_json
+2. Extract sender_pubkey (64-char hex), ciphertext (non-empty string)
+3. Convert sender_pubkey hex to 32-byte array
+4. Allocate output buffer
+5. Call nostr_nip44_decrypt(our_private_key, sender_pubkey_bytes, ciphertext, output, output_size)
+6. Return { success, sender_pubkey, plaintext: output }
+```
+
+#### Library API Used
+- [`nostr_nip44_decrypt()`](../nostr_core_lib/nostr_core/nip044.h:62)
+
+#### Security Note
+- Admin-tier only.
+
+#### Files Modified
+- `src/tools.c`: Schema + executor + dispatch
+
+---
+
+### Tool 19: `nostr_list_manage` — List Management (NIP-51)
+
+#### Purpose
+Manage mute lists (kind 10000), bookmarks (kind 10003), follow sets, relay sets. Lets the agent curate its social graph.
+
+#### OpenAI Schema
+```json
+{
+  "name": "nostr_list_manage",
+  "description": "Add or remove items from a Nostr list: mute list, bookmarks, relay sets, etc. (NIP-51)",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "list_kind": {
+        "type": "integer",
+        "description": "Kind number of the list: 10000=mute, 10001=pins, 10003=bookmarks, 3=follows, 10002=relays"
+      },
+      "action": {
+        "type": "string",
+        "description": "Action: add or remove"
+      },
+      "items": {
+        "type": "array",
+        "items": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "description": "Array of tag tuples to add/remove, e.g. [[p, pubkey], [e, event_id]]"
+      }
+    },
+    "required": ["list_kind", "action", "items"]
+  }
+}
+```
+
+#### Implementation
+
+This is a read-modify-write pattern for replaceable events:
+
+##### `execute_nostr_list_manage()`:
+
+```
+1. Parse args_json
+2. Extract list_kind (integer), action ("add"|"remove"), items (array of tag arrays)
+3. Query existing list:
+   - Build filter: { kinds: [list_kind], authors: [our_pubkey], limit: 1 }
+   - Call nostr_handler_query_json(filter, 8000)
+4. Parse existing event tags (or start with empty array if none found)
+5. If action == "add":
+   - For each item in items: append to tags if not already present
+6. If action == "remove":
+   - For each item in items: remove matching tag from tags
+7. Publish updated event:
+   - Call nostr_handler_publish_kind_event(list_kind, existing_content_or_empty, updated_tags, &result)
+8. Return { success, list_kind, action, items_affected, event_id }
+```
+
+#### Notes
+- Replaceable events (kind 10000-19999) automatically replace previous versions
+- Kind 3 (follows) is also replaceable
+- Content field may contain NIP-44 encrypted private items — preserve it unchanged
+- Must deduplicate tags when adding
+
+#### Files Modified
+- `src/tools.c`: Schema + executor + dispatch
+
+---
+
+## Implementation Order
+
+```mermaid
+graph TD
+    A[nostr_nip05_lookup] --> B[nostr_encode]
+    B --> C[nostr_decode]
+    C --> D[nostr_dm_send]
+    D --> E[nostr_relay_info]
+    E --> F[nostr_encrypt]
+    F --> G[nostr_decrypt]
+    G --> H[nostr_dm_send_nip17]
+    H --> I[nostr_list_manage]
+    
+    style A fill:#FFFFE0
+    style B fill:#FFFFE0
+    style C fill:#FFFFE0
+    style D fill:#FFFFE0
+    style E fill:#FFFFE0
+    style F fill:#FFD700
+    style G fill:#FFD700
+    style H fill:#FFD700
+    style I fill:#FFD700
+```
+
+Yellow = Tier 2 (moderate), Gold = Tier 3 (complex).
+
+### Recommended batching:
+
+**Batch A — Pure computation, no new handler functions:**
+1. `nostr_encode` — pure NIP-21 encoding
+2. `nostr_decode` — pure NIP-21 decoding
+3. `nostr_dm_send` — thin wrapper around existing `nostr_handler_send_dm()`
+
+**Batch B — Network I/O tools:**
+4. `nostr_nip05_lookup` — HTTP fetch via library
+5. `nostr_relay_info` — HTTP fetch via new handler function + libcurl
+
+**Batch C — Crypto tools:**
+6. `nostr_encrypt` — NIP-44 encrypt
+7. `nostr_decrypt` — NIP-44 decrypt
+
+**Batch D — Complex orchestration:**
+8. `nostr_dm_send_nip17` — multi-step NIP-17/59 pipeline, new handler function
+9. `nostr_list_manage` — read-modify-write replaceable events
+
+## Build & Validate
+
+After each batch:
+1. Run `./build_static.sh` to verify compilation
+2. Run `./increment_and_push.sh` with descriptive message

plans/new_trigger_types.md

@@ -0,0 +1,689 @@
+# Plan: Implement Webhook, Cron, and Chain Trigger Types
+
+## Overview
+
+Add three new trigger types to Didactyl's trigger system alongside the existing `nostr-subscription` type. Implementation order: webhook → cron → chain, followed by documentation updates.
+
+## Current Architecture
+
+```mermaid
+flowchart LR
+    subgraph Current Flow
+        NS[Nostr Event] --> SUB[Subscription Callback]
+        SUB --> MF[maybe_fire_trigger_locked]
+        MF --> EA{Action Type?}
+        EA -->|template| TA[execute_template_action]
+        EA -->|llm| LA[execute_llm_action]
+        LA --> AOT[agent_on_trigger]
+    end
+```
+
+All triggers are implicitly `nostr-subscription` — there is no type discriminator field in `active_trigger_t`.
+
+## Target Architecture
+
+```mermaid
+flowchart TD
+    subgraph Trigger Sources
+        NS[Nostr Subscription]
+        WH[Webhook HTTP POST]
+        CR[Cron Timer]
+        CH[Chain - Post-Execution]
+    end
+
+    subgraph Trigger Manager
+        NS --> MF[maybe_fire_trigger]
+        WH --> MF
+        CR --> MF
+        CH --> MF
+    end
+
+    subgraph Dispatch
+        MF --> EA{Action Type?}
+        EA -->|template| TA[execute_template_action]
+        EA -->|llm| LA[execute_llm_action]
+        LA --> AOT[agent_on_trigger]
+        AOT -->|on completion| CHK[Check chain triggers]
+        CHK -->|match| CH
+    end
+```
+
+---
+
+## Phase 1: Foundation — Type System and API Changes
+
+### 1.1 Add trigger type enum to `trigger_manager.h`
+
+**File:** [`src/trigger_manager.h`](src/trigger_manager.h:15)
+
+Add a new enum after the existing `trigger_action_type_t` at line 18:
+
+```c
+typedef enum {
+    TRIGGER_TYPE_NOSTR_SUBSCRIPTION = 0,
+    TRIGGER_TYPE_WEBHOOK,
+    TRIGGER_TYPE_CRON,
+    TRIGGER_TYPE_CHAIN
+} trigger_type_t;
+```
+
+### 1.2 Extend `active_trigger_t` struct
+
+**File:** [`src/trigger_manager.h`](src/trigger_manager.h:20)
+
+Add three new fields to the struct after [`enabled`](src/trigger_manager.h:25):
+
+```c
+trigger_type_t trigger_type;     // discriminator: which trigger source
+time_t last_cron_fire;           // cron: last time this trigger fired
+char cron_expr[64];              // cron: parsed 5-field cron expression
+```
+
+The struct currently has `subscription` and `subscription_ctx` fields which are only relevant for `nostr-subscription` — they'll remain but be NULL for other types.
+
+### 1.3 Add trigger type string conversion helpers
+
+**File:** [`src/trigger_manager.h`](src/trigger_manager.h:57) — add declarations:
+
+```c
+trigger_type_t trigger_type_from_string(const char *s);
+const char* trigger_type_to_string(trigger_type_t t);
+```
+
+**File:** [`src/trigger_manager.c`](src/trigger_manager.c:20) — add implementations after `clamp_enabled()`:
+
+```c
+trigger_type_t trigger_type_from_string(const char *s) {
+    if (!s) return TRIGGER_TYPE_NOSTR_SUBSCRIPTION;
+    if (strcmp(s, "webhook") == 0) return TRIGGER_TYPE_WEBHOOK;
+    if (strcmp(s, "cron") == 0) return TRIGGER_TYPE_CRON;
+    if (strcmp(s, "chain") == 0) return TRIGGER_TYPE_CHAIN;
+    return TRIGGER_TYPE_NOSTR_SUBSCRIPTION;
+}
+
+const char* trigger_type_to_string(trigger_type_t t) {
+    switch (t) {
+        case TRIGGER_TYPE_WEBHOOK: return "webhook";
+        case TRIGGER_TYPE_CRON: return "cron";
+        case TRIGGER_TYPE_CHAIN: return "chain";
+        default: return "nostr-subscription";
+    }
+}
+```
+
+### 1.4 Update `trigger_manager_add()` signature
+
+**File:** [`src/trigger_manager.h`](src/trigger_manager.h:44) and [`src/trigger_manager.c`](src/trigger_manager.c:569)
+
+Add `const char* trigger_type_str` parameter:
+
+```c
+int trigger_manager_add(trigger_manager_t* mgr,
+                        const char* skill_d_tag,
+                        const char* content,
+                        const char* filter_json,
+                        trigger_action_type_t action_type,
+                        const char* trigger_type_str,   // NEW
+                        int enabled);
+```
+
+Inside the function body at [line 604](src/trigger_manager.c:604), after `memset(t, 0, sizeof(*t))` and field assignments:
+
+```c
+t->trigger_type = trigger_type_from_string(trigger_type_str);
+
+// For cron triggers, copy the filter as the cron expression
+if (t->trigger_type == TRIGGER_TYPE_CRON) {
+    snprintf(t->cron_expr, sizeof(t->cron_expr), "%s", filter_json);
+    t->last_cron_fire = 0;
+}
+
+// Only create Nostr subscription for nostr-subscription type
+if (t->trigger_type == TRIGGER_TYPE_NOSTR_SUBSCRIPTION) {
+    if (register_trigger_subscription_locked(mgr, t) != 0) {
+        pthread_mutex_unlock(&mgr->mutex);
+        DEBUG_WARN("[didactyl] trigger add rejected: subscription failed d_tag=%s", skill_d_tag);
+        memset(t, 0, sizeof(*t));
+        return -1;
+    }
+}
+```
+
+### 1.5 Update `trigger_manager_update()` signature
+
+**File:** [`src/trigger_manager.h`](src/trigger_manager.h:51) and [`src/trigger_manager.c`](src/trigger_manager.c:661)
+
+Same pattern — add `const char* trigger_type_str` parameter. Inside the body at [line 683](src/trigger_manager.c:683):
+
+```c
+t->trigger_type = trigger_type_from_string(trigger_type_str);
+
+if (t->trigger_type == TRIGGER_TYPE_CRON) {
+    snprintf(t->cron_expr, sizeof(t->cron_expr), "%s", filter_json);
+}
+
+// Only (re)subscribe for nostr-subscription type
+if (t->trigger_type == TRIGGER_TYPE_NOSTR_SUBSCRIPTION) {
+    if (register_trigger_subscription_locked(mgr, t) != 0) { ... }
+} else {
+    // Close any existing subscription if type changed
+    close_trigger_subscription_locked(t);
+}
+```
+
+### 1.6 Update all call sites of `trigger_manager_add()` and `trigger_manager_update()`
+
+There are 5 call sites that need the new `trigger_type_str` parameter:
+
+| Call Site | File | Line | Current `trigger_type_str` value |
+|---|---|---|---|
+| `trigger_manager_load_from_skills()` | [`src/trigger_manager.c`](src/trigger_manager.c:485) | 485 | `trigger_s` — already extracted from tags |
+| `trigger_manager_load_from_startup_events()` | [`src/trigger_manager.c`](src/trigger_manager.c:555) | 555 | `trigger_s` — already extracted from tags |
+| `execute_skill_create()` | [`src/tools.c`](src/tools.c:3678) | 3678 | `trigger_str` — already available |
+| `execute_skill_edit()` update call | [`src/tools.c`](src/tools.c:4213) | 4213 | `merged_trigger` — already available |
+| `execute_skill_edit()` add fallback | [`src/tools.c`](src/tools.c:4219) | 4219 | `merged_trigger` — already available |
+| `trigger_manager_add()` → `trigger_manager_update()` cross-call | [`src/trigger_manager.c`](src/trigger_manager.c:588) | 588 | Pass through from caller |
+| `trigger_manager_update()` → `trigger_manager_add()` cross-call | [`src/trigger_manager.c`](src/trigger_manager.c:680) | 680 | Pass through from caller |
+
+### 1.7 Update loading functions to accept all trigger types
+
+**File:** [`src/trigger_manager.c`](src/trigger_manager.c:482)
+
+In `trigger_manager_load_from_skills()`, change the filter at line 482 from:
+```c
+if (trigger_s && strcmp(trigger_s, "nostr-subscription") == 0 && filter_s && filter_s[0] != '\0') {
+```
+To:
+```c
+if (trigger_s && filter_s && filter_s[0] != '\0' &&
+    (strcmp(trigger_s, "nostr-subscription") == 0 ||
+     strcmp(trigger_s, "webhook") == 0 ||
+     strcmp(trigger_s, "cron") == 0 ||
+     strcmp(trigger_s, "chain") == 0)) {
+```
+
+**File:** [`src/trigger_manager.c`](src/trigger_manager.c:547)
+
+Same change in `trigger_manager_load_from_startup_events()` at line 547.
+
+Note: For `webhook` type, `filter` can be empty/unused since webhooks are triggered by HTTP POST, not by a filter match. Consider allowing empty filter for webhook type. However, keeping the existing requirement that filter must be non-empty is simpler — webhook skills can use `filter: "{}"` as a placeholder.
+
+### 1.8 Update `trigger_manager_status_json()`
+
+**File:** [`src/trigger_manager.c`](src/trigger_manager.c:761)
+
+After the existing `cJSON_AddStringToObject(item, "filter_json", ...)` at line 762, add:
+
+```c
+cJSON_AddStringToObject(item, "type", trigger_type_to_string(t->trigger_type));
+```
+
+### 1.9 Update `tools.c` validation
+
+**File:** [`src/tools.c`](src/tools.c:3603)
+
+In `execute_skill_create()`, change line 3603 from:
+```c
+if (trigger_str && strcmp(trigger_str, "nostr-subscription") != 0) {
+```
+To:
+```c
+if (trigger_str &&
+    strcmp(trigger_str, "nostr-subscription") != 0 &&
+    strcmp(trigger_str, "webhook") != 0 &&
+    strcmp(trigger_str, "cron") != 0 &&
+    strcmp(trigger_str, "chain") != 0) {
+```
+
+Update the error message to list valid types.
+
+**File:** [`src/tools.c`](src/tools.c:4177)
+
+In `execute_skill_edit()`, change line 4177 from:
+```c
+if (strcmp(merged_trigger, "nostr-subscription") != 0) {
+```
+To the same multi-type check.
+
+Also update the `trigger_manager_add()` and `trigger_manager_update()` calls at [lines 3678](src/tools.c:3678) and [4213-4224](src/tools.c:4213) to pass the trigger type string.
+
+---
+
+## Phase 2: Webhook Trigger
+
+### 2.1 Add `POST /api/trigger/:d_tag` route handler
+
+**File:** [`src/http_api.c`](src/http_api.c:1154)
+
+Add a new handler function before `http_handler()`:
+
+```c
+static void handle_trigger_webhook(struct mg_connection* c, struct mg_http_message* hm, const char* d_tag) {
+    if (!g_api_ctx.trigger_manager) {
+        reply_error(c, 503, "trigger manager unavailable");
+        return;
+    }
+
+    // Look up the trigger by d_tag
+    // Need a new function: trigger_manager_find_by_d_tag() that returns a copy
+    active_trigger_t trigger_copy;
+    if (trigger_manager_find(g_api_ctx.trigger_manager, d_tag, &trigger_copy) != 0) {
+        reply_error(c, 404, "no trigger found for d_tag");
+        return;
+    }
+
+    if (trigger_copy.trigger_type != TRIGGER_TYPE_WEBHOOK) {
+        reply_error(c, 400, "trigger is not a webhook type");
+        return;
+    }
+
+    if (!trigger_copy.enabled) {
+        reply_error(c, 400, "trigger is disabled");
+        return;
+    }
+
+    // Parse optional JSON body as the webhook payload
+    cJSON* payload = parse_body_json(hm);
+    if (!payload) {
+        reply_error(c, 400, "invalid JSON body");
+        return;
+    }
+
+    // Build synthetic triggering event
+    cJSON* event = cJSON_CreateObject();
+    cJSON_AddStringToObject(event, "type", "webhook");
+    cJSON_AddStringToObject(event, "d_tag", d_tag);
+    cJSON_AddNumberToObject(event, "created_at", (double)time(NULL));
+    cJSON_AddItemToObject(event, "payload", payload);
+
+    // Fire the trigger - dispatch based on action type
+    if (trigger_copy.action_type == TRIGGER_ACTION_LLM) {
+        agent_on_trigger(trigger_copy.skill_d_tag,
+                        trigger_copy.skill_content,
+                        event,
+                        "webhook");
+    }
+    // Template actions could also be supported here
+
+    cJSON_Delete(event);
+
+    // Return success immediately
+    cJSON* root = cJSON_CreateObject();
+    cJSON_AddBoolToObject(root, "success", 1);
+    cJSON_AddStringToObject(root, "d_tag", d_tag);
+    cJSON_AddStringToObject(root, "status", "fired");
+    reply_json(c, 200, root);
+    cJSON_Delete(root);
+}
+```
+
+### 2.2 Add route to `http_handler()`
+
+**File:** [`src/http_api.c`](src/http_api.c:1201)
+
+Before the 404 fallthrough at line 1206, add:
+
+```c
+if (method_is(hm, "POST") && mg_match(hm->uri, mg_str("/api/trigger/*"), NULL)) {
+    // Extract d_tag from URI: /api/trigger/{d_tag}
+    struct mg_str uri = hm->uri;
+    const char* prefix = "/api/trigger/";
+    size_t prefix_len = strlen(prefix);
+    if (uri.len > prefix_len) {
+        char d_tag[TRIGGER_SKILL_D_TAG_MAX];
+        size_t tag_len = uri.len - prefix_len;
+        if (tag_len >= sizeof(d_tag)) tag_len = sizeof(d_tag) - 1;
+        memcpy(d_tag, uri.buf + prefix_len, tag_len);
+        d_tag[tag_len] = '\0';
+        handle_trigger_webhook(c, hm, d_tag);
+        return;
+    }
+    reply_error(c, 400, "missing d_tag in trigger URL");
+    return;
+}
+```
+
+### 2.3 Add `trigger_manager_find()` function
+
+**File:** [`src/trigger_manager.h`](src/trigger_manager.h:50) and [`src/trigger_manager.c`](src/trigger_manager.c:631)
+
+New function to look up a trigger by d_tag and return a copy:
+
+```c
+// Declaration
+int trigger_manager_find(trigger_manager_t* mgr, const char* skill_d_tag, active_trigger_t* out);
+
+// Implementation
+int trigger_manager_find(trigger_manager_t* mgr, const char* skill_d_tag, active_trigger_t* out) {
+    if (!mgr || !skill_d_tag || !out) return -1;
+    pthread_mutex_lock(&mgr->mutex);
+    int idx = find_trigger_index_locked(mgr, skill_d_tag);
+    if (idx < 0) {
+        pthread_mutex_unlock(&mgr->mutex);
+        return -1;
+    }
+    *out = mgr->triggers[idx];
+    // Clear pointer fields in copy to prevent double-free
+    out->subscription = NULL;
+    out->subscription_ctx = NULL;
+    pthread_mutex_unlock(&mgr->mutex);
+    return 0;
+}
+```
+
+### 2.4 Webhook cooldown
+
+The webhook handler should respect the same cooldown as other triggers. Either:
+- Call `maybe_fire_trigger_locked()` from the webhook handler (requires refactoring to expose it), or
+- Add cooldown checking in the webhook handler using `trigger_copy.last_fired` and updating it via a new `trigger_manager_mark_fired()` function
+
+Recommended: Add a `trigger_manager_fire()` function that encapsulates the cooldown check and dispatch, usable by both the Nostr subscription callback and the webhook handler. This avoids duplicating cooldown logic.
+
+```c
+int trigger_manager_fire(trigger_manager_t* mgr, const char* skill_d_tag, cJSON* event, const char* source);
+```
+
+---
+
+## Phase 3: Cron Trigger
+
+### 3.1 Cron expression parser
+
+**File:** [`src/trigger_manager.c`](src/trigger_manager.c)
+
+Add a minimal 5-field cron expression matcher. The cron expression format is: `minute hour day-of-month month day-of-week`
+
+```c
+// Returns 1 if the cron expression matches the given time, 0 otherwise
+static int cron_matches(const char* expr, const struct tm* tm);
+
+// Helper: check if a single field matches a value
+// Supports: *, specific number, comma-separated list, ranges with -, step with /
+static int cron_field_matches(const char* field, int value, int min, int max);
+```
+
+The parser needs to handle:
+- `*` — match any
+- `5` — match exact value
+- `1,15` — match list
+- `1-5` — match range
+- `*/15` — match step
+- `1-5/2` — match range with step
+
+This is ~80-100 lines of C. Keep it simple — no named days/months, no special strings like `@hourly`.
+
+### 3.2 Implement `trigger_manager_poll()` for cron
+
+**File:** [`src/trigger_manager.c`](src/trigger_manager.c:718)
+
+Replace the no-op `trigger_manager_poll()` with cron checking logic:
+
+```c
+int trigger_manager_poll(trigger_manager_t* mgr) {
+    if (!mgr) return 0;
+
+    time_t now = time(NULL);
+
+    // Only check once per minute (cron resolution is 1 minute)
+    if (now - mgr->last_poll_at < 60) return 0;
+    mgr->last_poll_at = now;
+
+    struct tm tm_now;
+    localtime_r(&now, &tm_now);
+
+    pthread_mutex_lock(&mgr->mutex);
+
+    for (int i = 0; i < mgr->count; i++) {
+        active_trigger_t* t = &mgr->triggers[i];
+        if (!t->enabled || t->trigger_type != TRIGGER_TYPE_CRON) continue;
+        if (t->cron_expr[0] == '\0') continue;
+
+        if (!cron_matches(t->cron_expr, &tm_now)) continue;
+
+        // Prevent double-fire within same minute
+        struct tm tm_last;
+        localtime_r(&t->last_cron_fire, &tm_last);
+        if (t->last_cron_fire > 0 &&
+            tm_last.tm_min == tm_now.tm_min &&
+            tm_last.tm_hour == tm_now.tm_hour &&
+            tm_last.tm_mday == tm_now.tm_mday) {
+            continue;
+        }
+
+        t->last_cron_fire = now;
+        t->last_fired = now;
+
+        // Copy trigger data before unlocking
+        active_trigger_t trigger_copy = *t;
+        trigger_copy.subscription = NULL;
+        trigger_copy.subscription_ctx = NULL;
+        pthread_mutex_unlock(&mgr->mutex);
+
+        // Build synthetic cron event
+        cJSON* event = cJSON_CreateObject();
+        cJSON_AddStringToObject(event, "type", "cron");
+        cJSON_AddStringToObject(event, "d_tag", trigger_copy.skill_d_tag);
+        cJSON_AddNumberToObject(event, "created_at", (double)now);
+        cJSON_AddStringToObject(event, "cron_expr", trigger_copy.cron_expr);
+
+        if (trigger_copy.action_type == TRIGGER_ACTION_TEMPLATE) {
+            execute_template_action(mgr, &trigger_copy, event, "cron");
+        } else {
+            execute_llm_action(&trigger_copy, event, "cron");
+        }
+
+        cJSON_Delete(event);
+
+        // Re-lock and continue scanning
+        pthread_mutex_lock(&mgr->mutex);
+    }
+
+    pthread_mutex_unlock(&mgr->mutex);
+    return 0;
+}
+```
+
+### 3.3 Cron expression in skill tags
+
+For cron triggers, the `filter` tag contains the cron expression instead of a JSON filter:
+- `["trigger", "cron"]`
+- `["filter", "0 * * * *"]` — fires every hour at minute 0
+- `["filter", "*/5 * * * *"]` — fires every 5 minutes
+
+This reuses the existing `filter` tag semantics — the filter meaning depends on the trigger type.
+
+---
+
+## Phase 4: Chain Trigger
+
+### 4.1 Post-execution hook in `agent_on_trigger()`
+
+**File:** [`src/agent.c`](src/agent.c:1913)
+
+After the tool loop completes at [line 2041](src/agent.c:2041), before cleanup, add a chain trigger check:
+
+```c
+// After the tool loop, check for chain triggers
+// Need access to trigger_manager — use agent_get_trigger_manager() or global
+trigger_manager_fire_chains(g_trigger_manager, skill_d_tag, messages);
+```
+
+This requires:
+1. The agent needs access to the trigger manager — it already has this via [`agent_set_trigger_manager()`](src/agent.h:12)
+2. A new function `trigger_manager_fire_chains()` that scans for chain triggers whose filter matches the completed skill's d_tag
+
+### 4.2 Add `trigger_manager_fire_chains()` function
+
+**File:** [`src/trigger_manager.c`](src/trigger_manager.c)
+
+```c
+void trigger_manager_fire_chains(trigger_manager_t* mgr,
+                                  const char* source_d_tag,
+                                  cJSON* source_output) {
+    if (!mgr || !source_d_tag) return;
+
+    pthread_mutex_lock(&mgr->mutex);
+
+    for (int i = 0; i < mgr->count; i++) {
+        active_trigger_t* t = &mgr->triggers[i];
+        if (!t->enabled || t->trigger_type != TRIGGER_TYPE_CHAIN) continue;
+
+        // For chain triggers, filter_json contains the source skill d_tag
+        if (strcmp(t->filter_json, source_d_tag) != 0) continue;
+
+        // Cooldown check
+        time_t now = time(NULL);
+        int cooldown = mgr->cfg->triggers.cooldown_seconds;
+        if (cooldown > 0 && t->last_fired > 0 && (now - t->last_fired) < cooldown) continue;
+
+        t->last_fired = now;
+
+        active_trigger_t trigger_copy = *t;
+        trigger_copy.subscription = NULL;
+        trigger_copy.subscription_ctx = NULL;
+        pthread_mutex_unlock(&mgr->mutex);
+
+        // Build synthetic chain event
+        cJSON* event = cJSON_CreateObject();
+        cJSON_AddStringToObject(event, "type", "chain");
+        cJSON_AddStringToObject(event, "source_d_tag", source_d_tag);
+        cJSON_AddNumberToObject(event, "created_at", (double)now);
+        if (source_output) {
+            cJSON* output_copy = cJSON_Duplicate(source_output, 1);
+            if (output_copy) {
+                cJSON_AddItemToObject(event, "source_output", output_copy);
+            }
+        }
+
+        if (trigger_copy.action_type == TRIGGER_ACTION_LLM) {
+            execute_llm_action(&trigger_copy, event, "chain");
+        }
+        // Note: template actions could also be supported
+
+        cJSON_Delete(event);
+
+        pthread_mutex_lock(&mgr->mutex);
+    }
+
+    pthread_mutex_unlock(&mgr->mutex);
+}
+```
+
+### 4.3 Chain trigger recursion protection
+
+To prevent infinite chain loops (A → B → A → B → ...), add a chain depth counter:
+
+- Add a `static __thread int chain_depth = 0;` in `trigger_manager_fire_chains()`
+- Increment before firing, decrement after
+- Refuse to fire if depth exceeds a limit (e.g., 5)
+
+### 4.4 Chain trigger skill tags
+
+For chain triggers, the `filter` tag contains the source skill's d_tag:
+- `["trigger", "chain"]`
+- `["filter", "data-fetcher"]` — fires after `data-fetcher` skill completes
+
+### 4.5 What to pass as chain context
+
+The chain trigger's synthetic event should include the source skill's final LLM response. This requires capturing the last assistant message from the tool loop in `agent_on_trigger()`. Currently the function doesn't return any output — it just runs and exits.
+
+**Approach:** After the tool loop at [line 2041](src/agent.c:2041), extract the last assistant message from `messages` array and pass it to `trigger_manager_fire_chains()`.
+
+---
+
+## Phase 5: Documentation
+
+### 5.1 Update `docs/SKILLS.md`
+
+**File:** [`docs/SKILLS.md`](docs/SKILLS.md:209)
+
+Expand the Trigger Tags table to show all four types and their filter semantics:
+
+| Tag | Required | Description |
+|---|---|---|
+| `trigger` | Yes | Trigger type: `nostr-subscription`, `webhook`, `cron`, or `chain` |
+| `filter` | Yes | Type-dependent: JSON filter, empty/unused, cron expression, or source d_tag |
+| `action` | No | `template` or `llm` — default: `llm` |
+| `enabled` | No | Whether active — default: `true` |
+
+Add sections for each new trigger type with examples.
+
+Update the Future Extensions table to mark webhook, cron, and chain as implemented.
+
+### 5.2 Update `docs/API.md`
+
+**File:** [`docs/API.md`](docs/API.md:49)
+
+Add documentation for the new webhook endpoint:
+
+```
+### POST /api/trigger/:d_tag
+
+Fire a webhook trigger by skill d_tag.
+
+**URL Parameters:**
+- `d_tag` — The skill's d_tag identifier
+
+**Request Body:** Optional JSON payload passed as context to the skill
+
+**Response:**
+{
+  "success": true,
+  "d_tag": "my-webhook-skill",
+  "status": "fired"
+}
+```
+
+---
+
+## Phase 6: Build and Push
+
+1. Run `make -j` and fix any compilation warnings/errors
+2. Test webhook with: `curl -X POST http://localhost:8484/api/trigger/test-skill -d '{"message":"hello"}'`
+3. Push with `./increment_and_push.sh "feat: add webhook, cron, and chain trigger types"`
+
+---
+
+## Files Modified Summary
+
+| File | Changes |
+|---|---|
+| [`src/trigger_manager.h`](src/trigger_manager.h) | Add `trigger_type_t` enum, extend `active_trigger_t`, update function signatures, add new declarations |
+| [`src/trigger_manager.c`](src/trigger_manager.c) | Type conversion helpers, update load/add/update functions, cron parser, poll implementation, chain fire function, find function |
+| [`src/tools.c`](src/tools.c) | Update `execute_skill_create()` and `execute_skill_edit()` validation and call sites |
+| [`src/http_api.c`](src/http_api.c) | Add webhook route handler and route entry |
+| [`src/agent.c`](src/agent.c) | Add chain trigger post-execution hook in `agent_on_trigger()` |
+| [`src/agent.h`](src/agent.h) | No changes needed — `agent_on_trigger()` signature unchanged |
+| [`docs/SKILLS.md`](docs/SKILLS.md) | Document all three new trigger types |
+| [`docs/API.md`](docs/API.md) | Document webhook endpoint |
+
+---
+
+## Implementation Checklist
+
+- [ ] Add `trigger_type_t` enum to `trigger_manager.h`
+- [ ] Extend `active_trigger_t` struct with `trigger_type`, `last_cron_fire`, `cron_expr`
+- [ ] Add `trigger_type_from_string()` and `trigger_type_to_string()` declarations and implementations
+- [ ] Add `trigger_manager_find()` declaration and implementation
+- [ ] Add `trigger_manager_fire_chains()` declaration and implementation
+- [ ] Update `trigger_manager_add()` signature with `trigger_type_str` parameter
+- [ ] Update `trigger_manager_update()` signature with `trigger_type_str` parameter
+- [ ] Update `trigger_manager_add()` body: set trigger_type, conditional subscription registration
+- [ ] Update `trigger_manager_update()` body: set trigger_type, conditional subscription
+- [ ] Update `trigger_manager_load_from_skills()` to accept all 4 trigger types
+- [ ] Update `trigger_manager_load_from_startup_events()` to accept all 4 trigger types
+- [ ] Update `trigger_manager_status_json()` to include type field
+- [ ] Update `execute_skill_create()` validation at line 3603
+- [ ] Update `execute_skill_create()` `trigger_manager_add()` call at line 3678
+- [ ] Update `execute_skill_edit()` validation at line 4177
+- [ ] Update `execute_skill_edit()` `trigger_manager_update()` and `trigger_manager_add()` calls at lines 4213-4224
+- [ ] Add `handle_trigger_webhook()` handler to `http_api.c`
+- [ ] Add webhook route to `http_handler()` in `http_api.c`
+- [ ] Implement `cron_field_matches()` and `cron_matches()` in `trigger_manager.c`
+- [ ] Implement cron polling in `trigger_manager_poll()`
+- [ ] Add chain trigger post-execution hook in `agent_on_trigger()`
+- [ ] Add chain depth recursion protection
+- [ ] Update `docs/SKILLS.md` with all three new trigger types
+- [ ] Update `docs/API.md` with webhook endpoint
+- [ ] Build with `make -j` and verify clean compilation
+- [ ] Push with `./increment_and_push.sh`

plans/nip17_messaging.md

@@ -0,0 +1,194 @@
+# NIP-17 Messaging Implementation Plan
+
+## Background
+
+Didactyl currently uses NIP-04 (kind 4) for all DM communication. NIP-17 send support exists via `nostr_handler_send_dm_nip17()` and the `nostr_dm_send_nip17` tool, but there is **no ability to receive NIP-17 messages** and **all agent responses always use NIP-04**.
+
+The `nostr_core_lib` already has full NIP-17/NIP-59 support including:
+- `nostr_nip17_create_chat_event()` — create kind 14 rumor
+- `nostr_nip17_send_dm()` — seal + gift wrap (creates wraps for both recipient AND sender)
+- `nostr_nip17_receive_dm()` — unwrap gift wrap, unseal rumor, return kind 14
+- `nostr_nip17_extract_dm_relays()` — parse kind 10050 relay lists
+
+## Config-Driven Protocol Selection
+
+### New Config Field
+
+Add a `dm_protocol` field to the top-level config:
+
+```json
+{
+  "dm_protocol": "nip04",
+  ...
+}
+```
+
+Valid values:
+- `"nip04"` — NIP-04 only (current behavior, default for backward compatibility)
+- `"nip17"` — NIP-17 only (subscribe to kind 1059, send via gift wrap)
+- `"both"` — Subscribe to both kind 4 and kind 1059; reply using whichever protocol the message arrived on
+
+### Config Struct Change
+
+In `config.h`, add to `didactyl_config_t`:
+
+```c
+typedef enum {
+    DM_PROTOCOL_NIP04 = 0,
+    DM_PROTOCOL_NIP17 = 1,
+    DM_PROTOCOL_BOTH  = 2
+} dm_protocol_t;
+```
+
+Add `dm_protocol_t dm_protocol;` to the config struct.
+
+## Implementation Steps
+
+### 1. Add `dm_protocol` config parsing
+
+**Files**: `config.h`, `config.c`
+
+- Add `dm_protocol_t` enum and field to `didactyl_config_t`
+- Parse `"dm_protocol"` string from JSON in `config_load()`
+- Default to `DM_PROTOCOL_NIP04` if not specified
+
+### 2. Add kind 1059 subscription
+
+**File**: `nostr_handler.c` — `nostr_handler_subscribe_dms()`
+
+- When `dm_protocol` is `NIP17` or `BOTH`, add `kind: 1059` to the subscription filter
+- When `dm_protocol` is `NIP04` or `BOTH`, keep `kind: 4` in the filter
+- The subscription filter becomes `kinds: [4, 1059]` for `BOTH` mode
+
+### 3. Add NIP-17 receive handling in `on_event()`
+
+**File**: `nostr_handler.c` — `on_event()`
+
+Currently `on_event()` rejects anything that is not kind 4. Update to:
+
+- If kind == 1059: unwrap gift wrap via `nostr_nip17_receive_dm()`, extract sender pubkey from the kind 14 rumor, extract message content, determine sender tier, fire `g_dm_callback`
+- If kind == 4: existing NIP-04 decrypt path (unchanged)
+- Track which protocol was used per sender pubkey for reply routing
+
+### 4. Track protocol per sender for reply routing
+
+**File**: `nostr_handler.c`
+
+Add a small cache that maps `sender_pubkey_hex -> last_protocol_used`:
+
+```c
+typedef struct {
+    char pubkey_hex[65];
+    dm_protocol_t protocol;
+} sender_protocol_entry_t;
+
+#define SENDER_PROTOCOL_CACHE_SIZE 64
+static sender_protocol_entry_t g_sender_protocol_cache[SENDER_PROTOCOL_CACHE_SIZE];
+```
+
+When a DM arrives via kind 4, record `NIP04` for that sender. When via kind 1059, record `NIP17`.
+
+### 5. Add protocol-aware send function
+
+**File**: `nostr_handler.c`
+
+Add a new function that routes based on config + sender history:
+
+```c
+int nostr_handler_send_dm_auto(const char* recipient_pubkey_hex, const char* message);
+```
+
+Logic:
+- If `dm_protocol == NIP04`: always use `nostr_handler_send_dm()`
+- If `dm_protocol == NIP17`: always use `nostr_handler_send_dm_nip17()`
+- If `dm_protocol == BOTH`: check sender protocol cache; use matching protocol, default to NIP-04
+
+Expose in `nostr_handler.h`.
+
+### 6. Update agent.c to use auto-routing
+
+**File**: `agent.c`
+
+Replace all `nostr_handler_send_dm()` calls with `nostr_handler_send_dm_auto()`. This is a mechanical find-and-replace across ~15 call sites.
+
+### 7. Add kind 10050 startup event support
+
+**File**: `config.json.example`
+
+Add a kind 10050 startup event example so NIP-17 clients can discover the agent's DM relay preferences:
+
+```json
+{
+  "kind": 10050,
+  "content": "",
+  "tags": [
+    ["relay", "wss://relay.damus.io"],
+    ["relay", "wss://nos.lol"]
+  ]
+}
+```
+
+**File**: `config.c` — startup event parsing already handles arbitrary kinds, so this should work with no code changes.
+
+### 8. Update startup DM to use auto-routing
+
+**File**: `main.c`
+
+The startup status DM at line 255 currently calls `nostr_handler_send_dm()`. Update to `nostr_handler_send_dm_auto()`.
+
+## Architecture Diagram
+
+```mermaid
+flowchart TD
+    subgraph Config
+        CFG[dm_protocol setting]
+        CFG -->|nip04| NIP04_MODE[NIP-04 only]
+        CFG -->|nip17| NIP17_MODE[NIP-17 only]
+        CFG -->|both| BOTH_MODE[Both protocols]
+    end
+
+    subgraph Subscription
+        SUB[nostr_handler_subscribe_dms]
+        NIP04_MODE --> SUB_K4[Subscribe kind 4]
+        NIP17_MODE --> SUB_K1059[Subscribe kind 1059]
+        BOTH_MODE --> SUB_BOTH[Subscribe kind 4 + 1059]
+    end
+
+    subgraph Receive Path
+        EVT[on_event callback]
+        EVT -->|kind 4| DEC4[NIP-04 decrypt]
+        EVT -->|kind 1059| DEC17[NIP-17 unwrap + unseal]
+        DEC4 --> CACHE[Record sender protocol]
+        DEC17 --> CACHE
+        CACHE --> CB[Fire dm_callback]
+    end
+
+    subgraph Send Path
+        SEND[nostr_handler_send_dm_auto]
+        SEND -->|config=nip04| S4[nostr_handler_send_dm - kind 4]
+        SEND -->|config=nip17| S17[nostr_handler_send_dm_nip17 - kind 1059]
+        SEND -->|config=both| LOOKUP[Check sender protocol cache]
+        LOOKUP -->|sender used nip04| S4
+        LOOKUP -->|sender used nip17| S17
+        LOOKUP -->|unknown| S4
+    end
+```
+
+## File Change Summary
+
+| File | Changes |
+|------|---------|
+| `config.h` | Add `dm_protocol_t` enum and field |
+| `config.c` | Parse `dm_protocol` from JSON |
+| `nostr_handler.h` | Add `nostr_handler_send_dm_auto()` declaration |
+| `nostr_handler.c` | Add kind 1059 subscription, NIP-17 receive in `on_event()`, sender protocol cache, `nostr_handler_send_dm_auto()` |
+| `agent.c` | Replace `nostr_handler_send_dm()` with `nostr_handler_send_dm_auto()` |
+| `main.c` | Replace startup DM send with `nostr_handler_send_dm_auto()` |
+| `config.json.example` | Add `dm_protocol` field and kind 10050 startup event example |
+
+## Testing Strategy
+
+1. **NIP-04 mode** (default): Verify existing behavior is unchanged
+2. **NIP-17 mode**: Send a NIP-17 DM from a client like Amethyst/0xchat, verify Didactyl receives and replies via NIP-17
+3. **Both mode**: Send NIP-04 DM, verify NIP-04 reply; send NIP-17 DM, verify NIP-17 reply
+4. **Kind 10050**: Verify the relay list event is published on startup and discoverable by NIP-17 clients

plans/prompt_templates.md

@@ -0,0 +1,393 @@
+# Didactyl Prompt Template System — Design Plan
+
+## Summary
+
+Replace the hardcoded context assembly in `src/agent.c` with a template-driven system. The template lives inside the soul event (kind 31120) — because the template defines how the agent perceives the world, and that is fundamentally part of who the agent is.
+
+Different agents (architect, eGirl, analyst) are different processes with different souls, different templates, different Nostr identities. Multi-agent is Approach A: multiple `./didactyl --config` processes communicating via Nostr.
+
+---
+
+## Core Principle
+
+**The soul IS the template.** An agent's soul defines both its personality (prose instructions) and its perception (what context sections it sees, in what order, with what limits). You cannot meaningfully separate "who you are" from "how you see the world."
+
+---
+
+## Current State
+
+Today, context assembly is hardcoded in `agent_build_admin_messages_json()`:
+
+```
+1. System prompt (soul content)
+2. Admin identity (pubkey)
+3. Admin kind 0 profile
+4. Admin kind 10002 relay list
+5. Startup events memory
+6. Adopted skills memory
+7. DM history (last 12 turns)
+8. Admin recent notes (kind 1)
+```
+
+The order, formatting, limits, and section headers are all baked into C code. Changing anything requires editing `src/agent.c` and recompiling.
+
+---
+
+## Proposed Design
+
+### Soul Event Structure
+
+The kind 31120 soul event content gains a template section, delimited by a marker:
+
+```markdown
+# Didactyl Agent
+
+You are Didactyl, a sovereign AI agent living on Nostr.
+
+## Communication Rules
+- You communicate through encrypted Nostr direct messages.
+- Keep responses concise and clear.
+
+## Behavior
+- Be helpful and technically accurate.
+...
+
+## Safety
+- Never reveal your private key.
+...
+
+---template---
+
+- section: admin_identity
+  role: system
+  content: |
+    This is your administrator! Admin pubkey: {{admin_pubkey}}
+
+- section: admin_profile
+  role: system
+  content: |
+    Administrator profile: {{admin_kind0_json}}
+
+- section: admin_relay_list
+  role: system
+  content: |
+    Administrator relay list: {{admin_kind10002_json}}
+
+- section: startup_events
+  role: system
+  content: |
+    Startup events memory: {{startup_events_json}}
+
+- section: adopted_skills
+  role: system
+  content: |
+    {{adopted_skills_content}}
+
+- section: dm_history
+  role: expand
+  limit: 12
+
+- section: admin_notes
+  role: system
+  limit: 10
+  content: |
+    {{admin_notes_content}}
+```
+
+Everything above `---template---` is the system prompt (personality/rules). Everything below defines the context assembly template.
+
+If no `---template---` marker is found, the agent falls back to the current hardcoded assembly — backward compatible.
+
+### Template Syntax
+
+Simple YAML-like format parsed in C. Each section has:
+
+| Field | Required | Description |
+|---|---|---|
+| `section` | yes | Section name for logging and API identification |
+| `role` | yes | Chat message role: `system`, `user`, `assistant`, or `expand` |
+| `tool` | recommended | Tool name executed by template builder (for example `nostr_admin_profile`) |
+| `args` | no | JSON args string passed to the tool (default `{}`) |
+| `result_field` | no | Field extracted from tool JSON result (default `content`) |
+| `content` | optional fallback | Literal content when no `tool` is specified |
+| `limit` | no | Integer limit for variable-length sections like DM history |
+| `provider` | no | Provider-specific override — see below |
+
+### Tool-Driven Context Resolution
+
+Context sections should use `tool:` directives as the single runtime data path, which removes the legacy per-variable resolver duplication.
+
+### Special Section Types
+
+**`role: expand`** — The `dm_history` section expands into multiple messages (user/assistant pairs). The `limit` field controls how many turns to include. This is the only section type that produces multiple chat messages from one template entry.
+
+### Provider-Specific Overrides
+
+Within a section, you can specify provider-specific formatting:
+
+```yaml
+- section: admin_identity
+  role: system
+  content: |
+    ## Administrator Identity
+    This is your administrator! Admin pubkey: {{admin_pubkey}}
+  provider:
+    anthropic: |
+      <admin_identity>
+      This is your administrator! Admin pubkey: {{admin_pubkey}}
+      </admin_identity>
+```
+
+When the configured `llm.provider` matches a provider key, that override is used instead of the default `content`. This lets one soul/template work well across providers without needing separate soul events.
+
+If no provider override matches, the default `content` is used.
+
+---
+
+## Context Assembly Flow
+
+```mermaid
+flowchart TD
+    BOOT[Agent boots] --> LOAD_SOUL[Load soul event - kind 31120]
+    LOAD_SOUL --> PARSE[Parse soul content]
+    PARSE --> SPLIT{Contains ---template--- marker?}
+    SPLIT -->|Yes| EXTRACT[Extract personality above marker]
+    SPLIT -->|No| FALLBACK[Use hardcoded assembly - backward compat]
+    EXTRACT --> PARSE_TPL[Parse template sections below marker]
+    PARSE_TPL --> STORE[Store template_section_t array in memory]
+    
+    DM[Incoming DM] --> BUILD[Build context from template]
+    BUILD --> EMIT_SOUL[Emit personality as first system message]
+    EMIT_SOUL --> FOREACH[For each template section]
+    FOREACH --> CALL_TOOL[Execute section tool or use literal content]
+    CALL_TOOL --> PICK_FIELD[Extract result_field or content]
+    PICK_FIELD --> CHECK_PROVIDER{Provider override?}
+    CHECK_PROVIDER -->|Yes| USE_OVERRIDE[Use provider-specific content]
+    CHECK_PROVIDER -->|No| USE_DEFAULT[Use tool/literal output]
+    USE_OVERRIDE --> EMIT[Emit as chat message]
+    USE_DEFAULT --> EMIT
+    EMIT --> FOREACH
+    FOREACH --> DONE[Complete messages array]
+    DONE --> LLM[Send to LLM]
+```
+
+---
+
+## Context.log Formatting
+
+With templates, the log formatter uses section names directly from the template instead of detecting them from content prefixes. The `detect_context_section()` function is replaced by the template section name.
+
+Log format becomes:
+
+```
+[2026-03-02 14:54:30] phase=llm_chat_with_tools_messages sender=8ff747...
+
+Sections: 8
+
+============================================================
+Section: system_prompt | role=system
+============================================================
+
+# Didactyl Agent
+...
+
+
+============================================================
+Section: admin_identity | role=system
+============================================================
+
+This is your administrator! Admin pubkey: 8ff747...
+
+
+============================================================
+Section: dm_history | role=user
+============================================================
+
+Good afternoon.
+```
+
+Note: "Message 01" is replaced with "Section: admin_identity" — the section name from the template, which is much more meaningful.
+
+---
+
+## Data Structures
+
+```c
+typedef struct {
+    char name[64];           // section name
+    char role[16];           // system, user, assistant, expand
+    char* content_template;  // content with {{var}} placeholders
+    int limit;               // for expand sections, 0 = unlimited
+    char* provider_overrides; // JSON object of provider->content pairs, or NULL
+} template_section_t;
+
+typedef struct {
+    char* personality;                // everything above ---template---
+    template_section_t* sections;     // parsed template sections
+    int section_count;
+} prompt_template_t;
+```
+
+---
+
+## Implementation Plan
+
+### New Files
+
+| File | Purpose |
+|---|---|
+| `src/prompt_template.c` | Template parser, variable resolver, context builder |
+| `src/prompt_template.h` | Public API: parse, build context, free |
+
+### Modified Files
+
+| File | Change |
+|---|---|
+| `src/agent.c` | Replace `agent_build_admin_messages_json()` internals with template-driven builder. Keep function signature unchanged for API compatibility. |
+| `src/agent.c` | Remove hardcoded `append_admin_identity_context()`, `append_startup_events_context()`, etc. — these become template variable resolvers |
+| `src/agent.c` | Update `format_context_payload_for_log()` to use section names from template |
+| `src/http_api.c` | Remove `classify_part_name()` / `detect_context_section()` — section names come from template |
+| `Makefile` | Add `src/prompt_template.c` to SRCS |
+| `Dockerfile.alpine-musl` | Add `src/prompt_template.c` to gcc command |
+
+### Implementation Order
+
+1. Create `src/prompt_template.h` with data structures and API
+2. Implement template parser in `src/prompt_template.c` — parse soul content, split at `---template---`, parse sections
+3. Implement variable resolver — map `{{var}}` names to data source functions
+4. Implement context builder — iterate sections, resolve variables, emit messages
+5. Wire into `agent_build_admin_messages_json()` — if template exists, use it; otherwise fall back to hardcoded
+6. Update `format_context_payload_for_log()` to use section names
+7. Update `classify_part_name()` in `http_api.c` to use section names from template
+8. Update default soul in `config.json.example` to include a `---template---` section
+9. Test with existing soul (no template marker) — verify backward compatibility
+10. Test with template soul — verify new assembly
+11. Test provider overrides
+
+---
+
+## Backward Compatibility
+
+If the soul event content does NOT contain `---template---`, the agent uses the current hardcoded assembly. This means:
+
+- Existing agents continue to work without changes
+- The template system is opt-in
+- Migration is gradual — add a template section to your soul when ready
+
+---
+
+## Example Souls
+
+### Architect Agent
+
+```markdown
+# Technical Architect
+
+You are a technical architect agent. You analyze systems, design solutions, and produce detailed technical plans.
+
+## Behavior
+- Think systematically about architecture
+- Consider tradeoffs explicitly
+- Produce diagrams when helpful
+- Never implement code — only design
+
+---template---
+
+- section: admin_identity
+  role: system
+  content: |
+    Administrator pubkey: {{admin_pubkey}}
+
+- section: admin_profile
+  role: system
+  content: |
+    Administrator profile: {{admin_kind0_json}}
+
+- section: startup_events
+  role: system
+  content: |
+    System configuration and startup state: {{startup_events_json}}
+
+- section: adopted_skills
+  role: system
+  content: |
+    {{adopted_skills_content}}
+
+- section: dm_history
+  role: expand
+  limit: 20
+
+- section: admin_notes
+  role: system
+  limit: 5
+  content: |
+    Recent administrator notes for context: {{admin_notes_content}}
+```
+
+### eGirl Agent
+
+```markdown
+# Social Butterfly
+
+You are a friendly, social Nostr personality. You love interacting with people, commenting on their posts, and being part of the community.
+
+## Personality
+- Warm, enthusiastic, uses emoji freely
+- Interested in what people are posting about
+- Remembers details about conversations
+- Keeps responses casual and fun
+
+---template---
+
+- section: admin_identity
+  role: system
+  content: |
+    Your creator: {{admin_pubkey}}
+
+- section: admin_profile
+  role: system
+  content: |
+    Creator profile: {{admin_kind0_json}}
+
+- section: admin_notes
+  role: system
+  limit: 20
+  content: |
+    Recent posts from people you follow — use these for social context and conversation starters: {{admin_notes_content}}
+
+- section: adopted_skills
+  role: system
+  content: |
+    {{adopted_skills_content}}
+
+- section: dm_history
+  role: expand
+  limit: 8
+```
+
+Note the differences:
+- The eGirl sees 20 recent notes (social context) but only 8 DM turns
+- The architect sees 5 notes but 20 DM turns (needs conversation continuity)
+- The eGirl puts notes BEFORE skills (social context is primary)
+- The architect puts skills BEFORE notes (technical knowledge is primary)
+- No startup events for the eGirl (doesn't need system config details)
+
+---
+
+## Nostr Shareability
+
+Since the template is part of the soul event (kind 31120), sharing works naturally:
+
+- Publish your soul → others get your complete agent personality + perception template
+- Discover interesting agents on Nostr → adopt their soul as a starting point
+- Community can develop and share optimized templates for different use cases
+- Templates evolve through the same Nostr discovery mechanisms as skills
+
+---
+
+## Security Notes
+
+- Template variable resolution is sandboxed — only predefined variables are resolved
+- No arbitrary code execution from templates
+- The `limit` field is capped at compile-time maximums to prevent resource exhaustion
+- Provider overrides are optional and safe — they only change formatting, not data sources

plans/prompt_templates_coding.md

@@ -0,0 +1,395 @@
+# Prompt Template System — Coding Plan
+
+Design doc: `plans/prompt_templates.md`
+
+## Overview
+
+Replace the hardcoded context assembly in `src/agent.c` with a template-driven system. The template lives inside the soul event content (kind 31120), delimited by `---template---`. If no template marker is found, fall back to the current hardcoded assembly for backward compatibility.
+
+---
+
+## Phase 1: New Files — Template Parser & Builder
+
+### Step 1.1: Create `src/prompt_template.h`
+
+Header with data structures and public API.
+
+```c
+#ifndef DIDACTYL_PROMPT_TEMPLATE_H
+#define DIDACTYL_PROMPT_TEMPLATE_H
+
+#include "cjson/cJSON.h"
+#include "config.h"
+
+#define PROMPT_TEMPLATE_MAX_SECTIONS 32
+#define PROMPT_TEMPLATE_MAX_NAME_LEN 64
+#define PROMPT_TEMPLATE_MAX_ROLE_LEN 16
+#define PROMPT_TEMPLATE_MARKER "---template---"
+
+typedef struct {
+    char name[PROMPT_TEMPLATE_MAX_NAME_LEN];
+    char role[PROMPT_TEMPLATE_MAX_ROLE_LEN];   // system, user, assistant, expand
+    char* content_template;                     // content with {{var}} placeholders, or NULL
+    int limit;                                  // for expand sections, 0 = default
+} prompt_template_section_t;
+
+typedef struct {
+    char* personality;                          // everything above ---template---
+    prompt_template_section_t sections[PROMPT_TEMPLATE_MAX_SECTIONS];
+    int section_count;
+} prompt_template_t;
+
+// Variable resolver callback: given a variable name, return a malloc'd string or NULL.
+// The caller frees the returned string.
+typedef char* (*prompt_var_resolver_fn)(const char* var_name, void* user_data);
+
+// Parse soul content into a template. Returns 0 on success, -1 if no template found.
+// On success, caller must call prompt_template_free() when done.
+// On -1 (no template), out_template is zeroed — caller should use hardcoded fallback.
+int prompt_template_parse(const char* soul_content, prompt_template_t* out_template);
+
+// Build a cJSON messages array from a parsed template.
+// resolver_fn is called for each {{variable}} encountered.
+// dm_history_messages is a cJSON array of user/assistant messages for "expand" sections.
+// Returns a new cJSON array (caller owns it), or NULL on error.
+cJSON* prompt_template_build_messages(
+    const prompt_template_t* tmpl,
+    prompt_var_resolver_fn resolver_fn,
+    void* resolver_user_data,
+    cJSON* dm_history_messages
+);
+
+// Free internals of a parsed template (does not free the struct itself).
+void prompt_template_free(prompt_template_t* tmpl);
+
+// Get the section name for a message index (for logging/API).
+// Returns the section name string or NULL if idx is out of range.
+const char* prompt_template_section_name_at(const prompt_template_t* tmpl, int section_idx);
+
+#endif
+```
+
+### Step 1.2: Create `src/prompt_template.c`
+
+Implementation file with three main components:
+
+#### 1.2a: Template Parser — `prompt_template_parse()`
+
+Logic:
+1. Search `soul_content` for the string `"\n---template---\n"` (with newlines on both sides, or at start/end of string).
+2. If not found, return -1 (no template).
+3. Split: everything before the marker → `tmpl->personality` (strdup'd).
+4. Everything after the marker → parse as template sections.
+5. Template section format is line-oriented YAML-like:
+
+```
+- section: admin_identity
+  role: system
+  limit: 0
+  content: |
+    This is your administrator! Admin pubkey: {{admin_pubkey}}
+```
+
+Parsing rules:
+- Lines starting with `- section:` begin a new section.
+- `role:` sets the role (default: `system`).
+- `limit:` sets the limit integer (default: 0).
+- `content: |` starts a multi-line content block. All subsequent lines indented by 4+ spaces (or until the next `- section:` line) are the content template.
+- `{{variable_name}}` placeholders in content are left as-is during parsing; they are resolved at build time.
+
+Edge cases:
+- Trim leading/trailing whitespace from section names and roles.
+- If `content:` is a single line (not `|`), treat the rest of the line as the content.
+- Cap at `PROMPT_TEMPLATE_MAX_SECTIONS`.
+
+#### 1.2b: Variable Resolver — `prompt_template_build_messages()`
+
+Logic:
+1. Create a new cJSON array.
+2. First, append the personality as a system message (role=system, content=personality).
+3. For each section in order:
+   - If `role` is `"expand"`: insert the `dm_history_messages` array items here, limited by `section.limit` (take last N if limit > 0).
+   - Otherwise: resolve `{{var}}` placeholders in `content_template` by calling `resolver_fn(var_name, user_data)`. Build the resolved string. Append as a message with the configured role.
+4. Return the array.
+
+Variable resolution:
+- Scan content_template for `{{` ... `}}` pairs.
+- Extract the variable name (trimmed).
+- Call `resolver_fn(name, user_data)`.
+- If resolver returns NULL, substitute empty string.
+- If resolver returns a string, substitute it and free the returned string.
+- Build the final resolved content by concatenating literal segments and resolved values.
+
+#### 1.2c: Cleanup — `prompt_template_free()`
+
+- Free `tmpl->personality`.
+- For each section, free `content_template`.
+- Zero the struct.
+
+---
+
+## Phase 2: Variable Resolver in `src/agent.c`
+
+### Step 2.1: Create a resolver function
+
+Add a static function in `src/agent.c`:
+
+```c
+static char* agent_resolve_template_var(const char* var_name, void* user_data);
+```
+
+This function maps variable names to data sources:
+
+| Variable Name | Source | Implementation |
+|---|---|---|
+| `admin_pubkey` | `g_cfg->admin.pubkey` | `strdup(g_cfg->admin.pubkey)` |
+| `admin_kind0_json` | `nostr_handler_get_admin_kind0_context()` | Already returns malloc'd string |
+| `admin_kind10002_json` | `nostr_handler_get_admin_kind10002_context()` | Already returns malloc'd string |
+| `startup_events_json` | Serialize startup events | Reuse logic from current `append_startup_events_context()` |
+| `adopted_skills_content` | Build skills string | Reuse logic from current `append_adopted_skills_context()` |
+| `admin_notes_content` | `nostr_handler_get_admin_kind1_notes_context()` | Already returns malloc'd string |
+| `agent_pubkey` | `g_cfg->keys.public_key_hex` | `strdup(g_cfg->keys.public_key_hex)` |
+
+The `user_data` parameter is unused (NULL) since the resolver accesses globals.
+
+### Step 2.2: Extract helper functions from existing code
+
+Refactor the following existing static functions to return malloc'd strings instead of appending directly to a cJSON array:
+
+- Extract startup events serialization from `append_startup_events_context()` (lines 383-434) into a new `static char* build_startup_events_string(void)`.
+- Extract adopted skills content from `append_adopted_skills_context()` (lines ~744-940) into a new `static char* build_adopted_skills_string(void)`.
+
+These helpers are called by the resolver function.
+
+---
+
+## Phase 3: Wire Template into Agent
+
+### Step 3.1: Parse template at init time
+
+In `agent_init()` (or when `g_system_context` is set), after the soul content is available:
+
+```c
+static prompt_template_t g_prompt_template;
+static int g_has_template = 0;
+```
+
+After `g_system_context` is assigned, call:
+
+```c
+g_has_template = (prompt_template_parse(g_system_context, &g_prompt_template) == 0);
+```
+
+If `g_has_template` is true, `g_prompt_template.personality` replaces `g_system_context` for the system prompt message.
+
+### Step 3.2: Modify `agent_build_admin_messages_json()`
+
+Current location: `src/agent.c:1092`
+
+Current signature (unchanged):
+```c
+int agent_build_admin_messages_json(const char* current_user_message, char** out_messages_json);
+```
+
+New logic:
+
+```c
+if (g_has_template) {
+    // Build DM history as a cJSON array
+    cJSON* dm_history = build_dm_history_array(current_user_message);
+    
+    // Build messages from template
+    cJSON* messages = prompt_template_build_messages(
+        &g_prompt_template,
+        agent_resolve_template_var,
+        NULL,
+        dm_history
+    );
+    
+    cJSON_Delete(dm_history);
+    
+    if (!messages) {
+        return -1;
+    }
+    
+    char* json = cJSON_PrintUnformatted(messages);
+    cJSON_Delete(messages);
+    *out_messages_json = json;
+    return json ? 0 : -1;
+} else {
+    // Existing hardcoded assembly (current code, unchanged)
+    ...
+}
+```
+
+### Step 3.3: Extract DM history builder
+
+Extract the DM history logic from `append_recent_admin_dm_history()` into a function that returns a cJSON array of user/assistant messages:
+
+```c
+static cJSON* build_dm_history_array(const char* current_user_message);
+```
+
+This is used by the template builder for `role: expand` sections.
+
+---
+
+## Phase 4: Context Log Formatting
+
+### Step 4.1: Update `format_context_payload_for_log()`
+
+Current location: `src/agent.c:245`
+
+When `g_has_template` is true, use section names from the template instead of `detect_context_section()`:
+
+- Message 0 is always `system_prompt` (the personality).
+- Messages 1..N map to template sections by index.
+- For `expand` sections, multiple messages share the same section name.
+
+Change the log header from:
+```
+Message 01 | role=system | section=system_prompt
+```
+To:
+```
+Section: system_prompt | role=system
+```
+
+### Step 4.2: Update `classify_part_name()` in `src/http_api.c`
+
+Current location: `src/http_api.c:113`
+
+Add a new exported function from `src/agent.h`:
+```c
+const char* agent_get_section_name_for_message(int message_index);
+```
+
+This returns the template section name if a template is active, or falls back to the existing content-prefix detection.
+
+In `classify_part_name()`, call this function first. If it returns non-NULL, use it. Otherwise fall back to the existing `strncmp` chain.
+
+---
+
+## Phase 5: Build System Updates
+
+### Step 5.1: Update `Makefile`
+
+Add `$(SRC_DIR)/prompt_template.c` to the `SRCS` list (after `trigger_manager.c`, before `http_api.c`).
+
+### Step 5.2: Update `Dockerfile.alpine-musl`
+
+Add `src/prompt_template.c` to the gcc command line (after `src/trigger_manager.c`, before `src/http_api.c`).
+
+---
+
+## Phase 6: Default Template in Soul
+
+### Step 6.1: Update `config.json.example`
+
+The startup events should include a soul event (kind 31120) with a `---template---` section that matches the current hardcoded behavior:
+
+```markdown
+# Didactyl Agent
+
+You are Didactyl, a sovereign AI agent living on Nostr.
+...existing soul content...
+
+---template---
+
+- section: admin_identity
+  role: system
+  content: |
+    This is your administrator! Admin pubkey (hex): {{admin_pubkey}}
+
+- section: admin_profile
+  role: system
+  content: |
+    Administrator profile (JSON): {{admin_kind0_json}}
+
+- section: admin_relay_list
+  role: system
+  content: |
+    Administrator relay list (JSON): {{admin_kind10002_json}}
+
+- section: startup_events
+  role: system
+  content: |
+    Startup events memory (kinds/content/tags): {{startup_events_json}}
+
+- section: adopted_skills
+  role: system
+  content: |
+    {{adopted_skills_content}}
+
+- section: dm_history
+  role: expand
+  limit: 12
+
+- section: admin_notes
+  role: system
+  limit: 10
+  content: |
+    Administrator recent public notes: {{admin_notes_content}}
+```
+
+---
+
+## Phase 7: Testing
+
+### Step 7.1: Backward compatibility test
+
+1. Build with `make`.
+2. Run with existing config (no `---template---` in soul).
+3. Send a DM and verify `context.log` output matches pre-change format.
+4. Verify `/api/context/current` returns expected structure.
+
+### Step 7.2: Template test
+
+1. Edit the soul event content to include `---template---` section.
+2. Restart agent.
+3. Send a DM and verify `context.log` shows section-named headers.
+4. Verify `/api/context/current` returns section names from template.
+5. Verify the LLM receives the correct messages in the correct order.
+
+### Step 7.3: Section reordering test
+
+1. Move `admin_notes` section above `adopted_skills` in the template.
+2. Restart and verify the order changes in `context.log`.
+
+### Step 7.4: Limit test
+
+1. Set `dm_history` limit to 4 (instead of 12).
+2. Verify only 4 DM history turns appear in context.
+
+---
+
+## File Change Summary
+
+| File | Action | Description |
+|---|---|---|
+| `src/prompt_template.h` | **NEW** | Data structures and API |
+| `src/prompt_template.c` | **NEW** | Parser, variable resolver, context builder |
+| `src/agent.c` | **MODIFY** | Add template globals, resolver function, wire into `agent_build_admin_messages_json()`, update log formatter |
+| `src/agent.h` | **MODIFY** | Add `agent_get_section_name_for_message()` export |
+| `src/http_api.c` | **MODIFY** | Update `classify_part_name()` to use template section names |
+| `Makefile` | **MODIFY** | Add `prompt_template.c` to SRCS |
+| `Dockerfile.alpine-musl` | **MODIFY** | Add `prompt_template.c` to gcc command |
+| `config.json.example` | **MODIFY** | Update soul event to include template section |
+
+---
+
+## Implementation Order
+
+1. `src/prompt_template.h` — data structures and API declarations
+2. `src/prompt_template.c` — parser, builder, free
+3. `Makefile` + `Dockerfile.alpine-musl` — add new source file
+4. Build and verify compilation
+5. `src/agent.c` — extract helper functions (`build_startup_events_string`, `build_adopted_skills_string`, `build_dm_history_array`)
+6. `src/agent.c` — add resolver function and template globals
+7. `src/agent.c` — wire template into `agent_build_admin_messages_json()`
+8. `src/agent.c` — update `format_context_payload_for_log()`
+9. `src/agent.h` + `src/http_api.c` — section name API for classify_part_name
+10. Build and test backward compatibility (no template in soul)
+11. `config.json.example` — add template to soul event
+12. Test with template soul
+13. Test section reordering and limit changes

plans/security_and_admin_context.md

@@ -0,0 +1,286 @@
+# Security & Admin Context Plan
+
+## Overview
+
+Add signature verification, privilege tiers, admin context awareness, and key isolation to Didactyl. Implemented in two phases.
+
+---
+
+## Phase 1 — Privilege Tiers, Signature Verification & Admin Context
+
+### Privilege Tiers
+
+```mermaid
+flowchart TD
+    A[Incoming Event] --> B{Verify Signature via nostr_verify_event_signature}
+    B -->|Invalid| C[Drop silently + DEBUG_WARN]
+    B -->|Valid| D{Identify sender}
+    D -->|Admin pubkey| E[ADMIN tier]
+    D -->|In admin kind 3 contact list| F[WOT tier]
+    D -->|Unknown| G[STRANGER tier]
+    E --> H[Full tool access + all skills + full context]
+    F --> I[Chat only - no tools - LLM response]
+    G --> J[Configurable canned response OR silent ignore]
+```
+
+| Tier | Identity | Tools | Response | Context |
+|------|----------|-------|----------|---------|
+| **ADMIN** | `config.admin.pubkey` exact match | All tools | Full LLM with all info except private key | Soul + startup events + admin notes |
+| **WOT** | Pubkey in admin kind `3` contact list | None | Chat-only LLM response | Soul + tier instruction |
+| **STRANGER** | Anyone else | None | Configurable static response or silent ignore | N/A - no LLM call |
+
+### Signature Verification
+
+Every incoming event must be cryptographically verified before processing:
+
+1. In `on_event()` in `src/nostr_handler.c`, call `nostr_verify_event_signature(event)` from `nostr_core_lib/nostr_core/nip001.h`
+2. If verification fails, drop the event silently with a `DEBUG_WARN` log
+3. This prevents relay-forged pubkey fields from being trusted
+4. Controlled by `security.verify_signatures` config flag (default: `true`)
+
+### Stranger Response
+
+Non-WoT senders get a **hardcoded configurable response** — no LLM tokens spent:
+
+- Config field: `security.stranger_response`
+- Example: `"I only respond to people in my web of trust. My npub is npub12kvnu0dsa4alquu4l4zv9454cgjdr9248gd07ueq5x8yzeuan37ql02960"`
+- If `security.tiers.stranger.enabled` is `false`, silently ignore instead
+- If `true`, send the canned response as a DM
+
+### Soul Update
+
+Update the soul event content in `config.json` to:
+- Explicitly allow sharing the agent public key (npub) with anyone
+- Explicitly forbid revealing the private key (nsec) under any circumstances
+- Note: Phase 2 will remove the private key from agent memory entirely
+
+### Admin Context Subscription
+
+At startup, Didactyl subscribes to the administrator's Nostr activity to build context awareness.
+
+#### What to subscribe to
+
+| Kind | Purpose | Retention |
+|------|---------|-----------|
+| `0` | Admin profile metadata | Latest only - replaceable |
+| `3` | Admin contact/follow list - WoT source | Latest only - replaceable |
+| `10002` | Admin relay list | Latest only - replaceable |
+| `1` | Admin public notes | Last N posts - configurable, default 10 |
+
+#### Storage
+
+In-memory struct `admin_context_t` holding:
+- `kind_0_json` — latest kind 0 content string
+- `kind_3_contacts` — array of followed pubkey hex strings extracted from kind 3 `p` tags
+- `kind_3_contact_count` — count
+- `kind_10002_json` — latest kind 10002 content string
+- `kind_1_notes` — array of recent kind 1 content strings with timestamps
+- `kind_1_note_count` — count
+
+#### Subscription mechanics
+
+- Single subscription filter: `{"authors": ["<admin_pubkey>"], "kinds": [0, 3, 10002, 1], "limit": <configurable>}`
+- On EOSE: initial load complete, WoT set is ready
+- After EOSE: live updates as admin posts new content
+- Kind 3 `p` tags are extracted into a sorted array for O(log n) WoT lookup
+
+#### Context injection
+
+- Admin kind 1 notes are injected into the LLM context as a system message: "Administrator recent public notes:" followed by the content
+- Only injected for ADMIN-tier conversations
+
+### Config Schema — Phase 1
+
+New sections in `config.json`:
+
+```json
+{
+  "security": {
+    "verify_signatures": true,
+    "stranger_response": "I only respond to people in my web of trust.",
+    "tiers": {
+      "admin": {
+        "tools_enabled": true
+      },
+      "wot": {
+        "enabled": true,
+        "tools_enabled": false
+      },
+      "stranger": {
+        "enabled": true
+      }
+    }
+  },
+  "admin_context": {
+    "enabled": true,
+    "subscribe_kinds": [0, 3, 10002, 1],
+    "kind_1_limit": 10
+  }
+}
+```
+
+- `security.verify_signatures` — master toggle for signature verification (default: `true`)
+- `security.stranger_response` — canned DM text for non-WoT senders (default: empty = silent ignore)
+- `security.tiers.wot.enabled` — whether WoT contacts can converse (default: `true`)
+- `security.tiers.stranger.enabled` — whether strangers get the canned response (default: `true`; if `false`, silent ignore)
+- `admin_context.enabled` — whether to subscribe to admin activity (default: `true`)
+- `admin_context.subscribe_kinds` — which kinds to track (default: `[0, 3, 10002, 1]`)
+- `admin_context.kind_1_limit` — how many kind 1 notes to retain (default: `10`)
+
+### Phase 1 Implementation Steps
+
+1. **Add signature verification to `on_event()`**
+   - File: `src/nostr_handler.c`
+   - Call `nostr_verify_event_signature(event)` at the top of `on_event()`
+   - If it returns non-zero, log and drop
+
+2. **Add `admin_context_t` struct and security config structs**
+   - File: `src/config.h`
+   - New structs for admin context storage, security config, tier config
+
+3. **Parse new config sections**
+   - File: `src/config.c`
+   - Parse `security` and `admin_context` from config.json
+   - Apply defaults when sections are missing
+
+4. **Add admin context subscription**
+   - File: `src/nostr_handler.c`
+   - New function `nostr_handler_subscribe_admin_context()`
+   - Callback that populates `admin_context_t` from incoming events
+   - Extract kind 3 `p` tags into WoT set
+   - Store kind 1 notes in a ring buffer capped at `kind_1_limit`
+
+5. **Add WoT lookup function**
+   - File: `src/nostr_handler.c`
+   - `int nostr_handler_is_wot_contact(const char* pubkey_hex)` — checks if pubkey is in admin kind 3 list
+
+6. **Refactor `on_event()` for tier dispatch**
+   - File: `src/nostr_handler.c`
+   - After signature verification, classify sender into ADMIN / WOT / STRANGER
+   - Pass tier information to the callback — extend `dm_callback_t` signature to include tier enum
+   - STRANGER with `stranger.enabled`: send canned response directly, no callback
+   - STRANGER without: drop silently
+
+7. **Refactor `agent_on_message()` for tier-aware behavior**
+   - File: `src/agent.c`
+   - ADMIN: current behavior — all tools, full context, admin notes injected
+   - WOT: build messages with soul + tier instruction, no tools_json, LLM chat-only
+   - STRANGER: should not reach here — handled in nostr_handler
+
+8. **Inject admin context into ADMIN conversations**
+   - File: `src/agent.c`
+   - After startup events context, append admin kind 1 notes as a system message
+   - Only for ADMIN tier
+
+9. **Update soul content in `config.json`**
+   - Allow sharing public key with anyone
+   - Forbid revealing private key under any circumstances
+
+10. **Update `config.json` with new sections**
+    - Add `security` and `admin_context` sections
+
+11. **Update `README.md`**
+    - Document privilege tiers
+    - Document new config sections
+    - Update architecture diagram
+
+12. **Build and validate**
+    - Run `./build_static.sh`
+    - Verify compilation succeeds
+
+---
+
+## Phase 2 — NIP-46 Remote Signer for Key Isolation
+
+### Problem
+
+Even with Phase 1 protections, the private key (nsec) still lives in Didactyl process memory and in `config.json` on disk. The LLM has `local_shell_exec` and `local_file_read` tools — a sufficiently clever prompt injection could theoretically:
+- Read `config.json` via `local_file_read` (contains nsec)
+- Execute `cat /proc/self/maps` or similar via `local_shell_exec`
+- Exfiltrate the key via `nostr_post`
+
+### Solution: NIP-46 Remote Signer
+
+Remove the private key from Didactyl entirely. All cryptographic operations go through a NIP-46 remote signer.
+
+```mermaid
+flowchart LR
+    A[Didactyl Agent] -->|kind 24133 sign_event / nip04_encrypt / nip04_decrypt| B[Remote Signer]
+    B -->|signed events / ciphertext / plaintext| A
+    A -.->|NO private key in memory| A
+    B -->|Private key held ONLY here| B
+    C[config.json] -.->|bunker URL only, no nsec| A
+```
+
+### Architecture
+
+1. **Remote signer process** — a separate lightweight daemon that:
+   - Holds the private key only in working memory (never on disk after initial load)
+   - Listens for NIP-46 requests via relay (kind `24133`)
+   - Responds with signed events, encrypted/decrypted content
+   - Can run on the same machine or a different one
+
+2. **Didactyl as NIP-46 client** — instead of calling `nostr_create_and_sign_event()` directly:
+   - Sends `sign_event` RPC to the remote signer
+   - Sends `nip04_encrypt` / `nip04_decrypt` RPC for DM handling
+   - Only holds a disposable `client-keypair` for NIP-46 communication
+
+3. **Config change** — `config.json` replaces `keys.nsec` with:
+   ```json
+   {
+     "keys": {
+       "bunker_url": "bunker://<remote-signer-pubkey>?relay=wss://relay.example.com&secret=<secret>",
+       "npub": "npub1..."
+     }
+   }
+   ```
+
+### NIP-46 Methods Required
+
+| Method | Current direct call | Used for |
+|--------|-------------------|----------|
+| `sign_event` | `nostr_create_and_sign_event()` | Publishing all events |
+| `nip04_encrypt` | `nostr_nip04_encrypt()` | Sending DMs |
+| `nip04_decrypt` | `nostr_nip04_decrypt()` | Receiving DMs |
+| `get_public_key` | `config.keys.public_key_hex` | Identity |
+
+### Implementation Scope
+
+1. **Build NIP-46 client protocol in nostr_core_lib**
+   - NIP-44 encryption for request/response content
+   - Kind 24133 event creation and parsing
+   - JSON-RPC request/response handling
+   - Connection establishment (bunker URL parsing)
+   - Async request/response matching by request ID
+
+2. **Build or integrate a remote signer**
+   - Option A: Build a minimal signer binary in C (ships with Didactyl)
+   - Option B: Support existing signers (nsecBunker, etc.)
+   - Option C: Both — ship a minimal one, support external ones
+
+3. **Refactor all signing/encryption calls**
+   - Every `nostr_create_and_sign_event()` → `nip46_sign_event()` (async RPC)
+   - Every `nostr_nip04_encrypt()` → `nip46_nip04_encrypt()` (async RPC)
+   - Every `nostr_nip04_decrypt()` → `nip46_nip04_decrypt()` (async RPC)
+   - These become blocking calls that send a request and wait for a response
+
+4. **Startup flow change**
+   - Parse bunker URL from config
+   - Generate client keypair
+   - Send `connect` request to remote signer
+   - Call `get_public_key` to learn user pubkey
+   - Proceed with normal startup
+
+5. **Backward compatibility**
+   - If `keys.nsec` is present, use direct signing (current behavior)
+   - If `keys.bunker_url` is present, use NIP-46 remote signing
+   - This allows gradual migration
+
+### Security Properties Achieved
+
+- Private key never in Didactyl process memory
+- Private key never on disk in config.json
+- LLM tools (local_shell_exec, local_file_read) cannot access the key
+- Even full process compromise of Didactyl does not leak the signing key
+- Remote signer can be on a separate hardened machine
+- Remote signer can implement rate limiting, approval flows, etc.

plans/skill_tools.md

@@ -0,0 +1,337 @@
+# Skill Tools — Architecture Plan
+
+## Overview
+
+Add a family of five skill-management tools to Didactyl so the agent can **create, list, adopt, remove, and discover** skills at runtime — all through the existing LLM tool-calling loop.
+
+Skills are Nostr events. The tools are thin orchestration wrappers over the existing `nostr_handler_publish_kind_event()` and `nostr_handler_query_json()` primitives.
+
+---
+
+## Nostr Kind Reference
+
+| Kind | Purpose | Replaceable? | Key tag |
+|---|---|---|---|
+| `31123` | Public skill definition | Yes (d-tag) | `d=<d_tag>` |
+| `31124` | Private skill definition | Yes (d-tag) | `d=<d_tag>` |
+| `10123` | Public skill adoption list | Yes (replaceable) | `a` refs to 31123 events |
+
+All skill events carry these standard tags:
+- `["d", "<d_tag>"]` — unique identifier within the author's pubkey
+- `["app", "didactyl"]` — app namespace
+- `["scope", "public"]` or `["scope", "private"]`
+
+---
+
+## Tool Family
+
+### 1. `skill_create`
+
+**Purpose:** Create or update a skill definition and optionally auto-adopt it.
+
+**OpenAI schema:**
+
+```json
+{
+  "name": "skill_create",
+  "description": "Create or update a skill definition (kind 31123 public / 31124 private) and optionally auto-adopt it",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "d_tag":        { "type": "string",  "description": "Unique skill identifier (lowercase, hyphens allowed)" },
+      "content":     { "type": "string",  "description": "Skill body — markdown instructions or structured JSON" },
+      "scope":       { "type": "string",  "description": "public (kind 31123) or private (kind 31124). Default: public" },
+      "description": { "type": "string",  "description": "Short one-line description for the skill" },
+      "auto_adopt":  { "type": "boolean", "description": "Automatically add to adoption list (kind 10123). Default: true" }
+    },
+    "required": ["d_tag", "content"]
+  }
+}
+```
+
+**Execution logic (`execute_skill_create`):**
+
+1. Validate `d_tag` — must be non-empty, lowercase alphanumeric + hyphens, no spaces
+2. Determine kind: `31123` if scope is `"public"` or absent; `31124` if `"private"`
+3. Build tags array:
+   - `["d", d_tag]`
+   - `["app", "didactyl"]`
+   - `["scope", scope]`
+   - `["description", description]` if provided
+4. Call `nostr_handler_publish_kind_event(kind, content, tags, &result)`
+5. If `auto_adopt` is true (default), update the kind `10123` adoption list:
+   - Query existing `10123` event for own pubkey (same pattern as `execute_nostr_list_manage`)
+   - Add `["a", "31123:<own_pubkey>:<d_tag>"]` tag if not already present
+   - Republish the updated `10123` event
+6. Return JSON with `success`, `event_id`, `naddr_uri`, `d_tag`, `adopted`
+
+**Key design decisions:**
+- Auto-adopt defaults to `true` — creating a skill you don't adopt is unusual
+- Private skills (31124) are NOT added to the public adoption list (10123)
+- Republishing with the same d_tag replaces the previous version (replaceable event)
+
+---
+
+### 2. `skill_list`
+
+**Purpose:** List the agent's own published skills.
+
+**OpenAI schema:**
+
+```json
+{
+  "name": "skill_list",
+  "description": "List skills published by this agent, optionally filtered by scope",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "scope": { "type": "string", "description": "Filter by public or private. Omit for both." }
+    }
+  }
+}
+```
+
+**Execution logic (`execute_skill_list`):**
+
+1. Build filter based on scope:
+   - Both: `{"kinds": [31123, 31124], "authors": [own_pubkey]}`
+   - Public only: `{"kinds": [31123], "authors": [own_pubkey]}`
+   - Private only: `{"kinds": [31124], "authors": [own_pubkey]}`
+2. Call `nostr_handler_query_json(filter, 8000)`
+3. Parse results, extract for each event:
+   - `d_tag` (from d-tag)
+   - `kind`
+   - `scope` (from scope tag)
+   - `description` (from description tag, if present)
+   - `created_at` timestamp
+   - `content` preview (first 200 chars)
+4. Return JSON array of skill summaries
+
+---
+
+### 3. `skill_adopt`
+
+**Purpose:** Adopt a skill published by another author (or self) into the agent's adoption list.
+
+**OpenAI schema:**
+
+```json
+{
+  "name": "skill_adopt",
+  "description": "Add a skill to the agent's public adoption list (kind 10123)",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "pubkey": { "type": "string", "description": "Hex pubkey of the skill author" },
+      "d_tag":   { "type": "string", "description": "Skill d_tag (d-tag value)" },
+      "kind":   { "type": "integer", "description": "Skill kind (31123 or 31124). Default: 31123" }
+    },
+    "required": ["pubkey", "d_tag"]
+  }
+}
+```
+
+**Execution logic (`execute_skill_adopt`):**
+
+1. Validate pubkey (64-char hex) and d_tag (non-empty)
+2. Default kind to 31123 if not provided
+3. Build the `a`-tag value: `"<kind>:<pubkey>:<d_tag>"`
+4. Query existing kind `10123` event for own pubkey
+5. Check if `["a", "<kind>:<pubkey>:<d_tag>"]` already exists — if so, return success with `already_adopted: true`
+6. Add the tag, republish `10123`
+7. Return JSON with `success`, `adopted_address`, `event_id`
+
+---
+
+### 4. `skill_remove`
+
+**Purpose:** Remove a skill from the agent's adoption list.
+
+**OpenAI schema:**
+
+```json
+{
+  "name": "skill_remove",
+  "description": "Remove a skill from the agent's public adoption list (kind 10123)",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "pubkey": { "type": "string", "description": "Hex pubkey of the skill author. Defaults to own pubkey." },
+      "d_tag":   { "type": "string", "description": "Skill d_tag to remove" },
+      "kind":   { "type": "integer", "description": "Skill kind (31123 or 31124). Default: 31123" }
+    },
+    "required": ["d_tag"]
+  }
+}
+```
+
+**Execution logic (`execute_skill_remove`):**
+
+1. Default pubkey to own pubkey if not provided
+2. Default kind to 31123
+3. Build the `a`-tag value: `"<kind>:<pubkey>:<d_tag>"`
+4. Query existing kind `10123` event for own pubkey
+5. Find and remove matching `["a", ...]` tag
+6. Republish `10123`
+7. Return JSON with `success`, `removed_address`, `event_id`
+
+---
+
+### 5. `skill_search`
+
+**Purpose:** Search for skills across the agent's Web of Trust.
+
+**OpenAI schema:**
+
+```json
+{
+  "name": "skill_search",
+  "description": "Search for skills adopted by Web of Trust contacts, or query public skill definitions",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "query":  { "type": "string",  "description": "Optional keyword to filter skill slugs or descriptions" },
+      "pubkey": { "type": "string",  "description": "Search skills by a specific author pubkey" },
+      "popular": { "type": "boolean", "description": "If true, query WoT adoption lists to find most-adopted skills" }
+    }
+  }
+}
+```
+
+**Execution logic (`execute_skill_search`):**
+
+1. If `popular` is true:
+   - Query `{"kinds": [10123]}` from relays (with reasonable limit)
+   - Parse all `a`-tags from results
+   - Count occurrences of each `a`-tag address
+   - Sort by adoption count descending
+   - Return top N skill addresses with counts
+2. If `pubkey` is provided:
+   - Query `{"kinds": [31123], "authors": [pubkey]}`
+   - Return skill summaries
+3. If `query` is provided (keyword search):
+   - Query `{"kinds": [31123]}` with limit
+   - Filter results client-side by matching `query` against d_tag, description tag, or content
+   - Return matching skill summaries
+4. Default (no params): return own adopted skills from `10123`
+
+---
+
+## Implementation Architecture
+
+### Shared helper: adoption list update
+
+Since `skill_create`, `skill_adopt`, and `skill_remove` all modify the kind `10123` list, extract a shared helper:
+
+```c
+// Fetch current 10123 event, return duplicated tags array (or empty array if none exists)
+static cJSON* fetch_adoption_list_tags(tools_context_t* ctx);
+
+// Publish updated 10123 event with new tags
+static int publish_adoption_list(tools_context_t* ctx, cJSON* tags, nostr_publish_result_t* result);
+```
+
+This is essentially the same pattern already used in `execute_nostr_list_manage()` but specialized for kind `10123`.
+
+### Shared helper: skill summary extraction
+
+```c
+// Extract d_tag, kind, scope, description, created_at from a skill event JSON
+static cJSON* extract_skill_summary(cJSON* event);
+```
+
+### Flow diagram
+
+```mermaid
+flowchart TD
+    SC[skill_create] --> PUB[nostr_handler_publish_kind_event]
+    SC --> ADOPT_HELPER[update adoption list helper]
+    
+    SL[skill_list] --> QUERY[nostr_handler_query_json]
+    SL --> SUMMARY[extract_skill_summary]
+    
+    SA[skill_adopt] --> ADOPT_HELPER
+    SR[skill_remove] --> ADOPT_HELPER
+    
+    SS[skill_search] --> QUERY
+    SS --> SUMMARY
+    
+    ADOPT_HELPER --> QUERY
+    ADOPT_HELPER --> PUB
+```
+
+---
+
+## Changes Required
+
+### `src/tools.c`
+
+1. **Schema registration** — Add 5 new tool definitions in `tools_build_openai_schema_json()` (t22–t26)
+2. **Execution functions** — Add 5 new `execute_skill_*()` static functions
+3. **Dispatch** — Add 5 new `strcmp` branches in `tools_execute()`
+4. **Shared helpers** — Add `fetch_adoption_list_tags()`, `publish_adoption_list()`, `extract_skill_summary()`, and `validate_skill_d_tag()`
+
+### `README.md`
+
+1. Add skill tools to the Tooling Interface section under a new "Skill management" category
+
+### No changes needed to:
+- `src/tools.h` — the `tools_context_t` already has `cfg` which provides `keys.public_key_hex`
+- `src/nostr_handler.h` — all needed APIs already exist
+- `src/config.h` — no new config fields needed
+
+---
+
+## Slug Validation Rules
+
+A valid skill d_tag must:
+- Be 1–64 characters
+- Contain only lowercase letters, digits, and hyphens
+- Not start or end with a hyphen
+- Not contain consecutive hyphens
+
+```c
+static int validate_skill_d_tag(const char* d_tag) {
+    if (!d_tag || d_tag[0] == '\0' || strlen(d_tag) > 64) return 0;
+    if (d_tag[0] == '-') return 0;
+    int prev_dash = 0;
+    for (size_t i = 0; d_tag[i]; i++) {
+        char c = d_tag[i];
+        if (c == '-') {
+            if (prev_dash) return 0;
+            prev_dash = 1;
+        } else if (islower(c) || isdigit(c)) {
+            prev_dash = 0;
+        } else {
+            return 0;
+        }
+    }
+    if (d_tag[strlen(d_tag) - 1] == '-') return 0;
+    return 1;
+}
+```
+
+---
+
+## Implementation Order
+
+1. **Shared helpers** — `validate_skill_d_tag`, `fetch_adoption_list_tags`, `publish_adoption_list`, `extract_skill_summary`
+2. **`skill_create`** — most important tool, enables the agent to author skills
+3. **`skill_list`** — lets the agent see what it has published
+4. **`skill_adopt`** — adopt skills from other authors
+5. **`skill_remove`** — remove skills from adoption list
+6. **`skill_search`** — discover skills across WoT
+7. **Schema registration** — add all 5 tools to `tools_build_openai_schema_json()`
+8. **Dispatch wiring** — add all 5 to `tools_execute()`
+9. **README update** — document the new tools
+10. **Build and test** — verify compilation and basic tool execution
+
+---
+
+## Security Considerations
+
+- **Admin-only**: Skill tools inherit the existing ADMIN tier restriction — only the admin can trigger tool calls
+- **Slug validation**: Prevents injection of malformed d-tags
+- **No arbitrary kind**: `skill_create` only publishes kind 31123 or 31124, not arbitrary kinds
+- **Adoption list integrity**: The helpers always fetch-then-update to avoid clobbering existing adoption entries
+- **Content size**: No explicit limit on skill content size — relies on relay limits and LLM context window constraints

plans/skills_demo_page.md

@@ -0,0 +1,520 @@
+# Skills Demo Page — Design Document
+
+## Purpose
+
+A standalone web page that demonstrates Didactyl skills running in a browser context. The page presents a minimal word-processing interface where users can load text, discover skills from Nostr relays, execute them against the text via an LLM, and edit/republish skill definitions.
+
+This document is the complete specification for building the page. The front-end project consuming this document has its own LLM calling capability and Nostr connectivity.
+
+---
+
+## Concepts
+
+### What is a Skill?
+
+A skill is a Nostr event (kind `31123` for public, `31124` for private) that defines a self-contained LLM execution unit. Each skill specifies:
+
+- A **template** with system and user prompt sections
+- An **LLM specification** (model preferences with fallback chain)
+- **Parameters** like temperature and max_tokens
+- A **description** for human display
+
+Skills are replaceable events keyed by their `d` tag (the d_tag). Publishing a new event with the same `d` tag replaces the previous version.
+
+### Skill Event Structure
+
+```json
+{
+  "kind": 31123,
+  "pubkey": "<author hex pubkey>",
+  "created_at": 1709750000,
+  "content": "{\"description\":\"Check spelling and grammar\",\"context_mode\":\"full\",\"llm\":\"openai/gpt-4o-mini, cheap\",\"tools\":false,\"max_tokens\":2000,\"temperature\":0.1,\"template\":\"system:\\nYou are a spelling and grammar checker.\\n\\nRules:\\n- Fix spelling errors\\n- Fix grammar errors\\n- Preserve original formatting\\n- Return ONLY the corrected text, no explanations\\n\\nuser:\\n{{message}}\"}",
+  "tags": [
+    ["d", "spellcheck"],
+    ["app", "didactyl"],
+    ["scope", "public"],
+    ["description", "Spelling and grammar checker"],
+    ["t", "text-processing"],
+    ["t", "skills-demo"]
+  ]
+}
+```
+
+The `content` field is a **JSON string** containing these fields:
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `description` | string | yes | Human-readable description |
+| `context_mode` | string | no | `full` for demo skills (skill provides its own template) |
+| `llm` | string | no | LLM model preference with fallback chain |
+| `tools` | bool | no | `false` for text-processing skills |
+| `max_tokens` | int | no | Max tokens for LLM response |
+| `temperature` | float | no | Sampling temperature |
+| `template` | string | yes | The prompt template with `system:` and `user:` sections |
+
+### Template Format
+
+Templates use a simple section-based format:
+
+```
+system:
+You are a spelling and grammar checker.
+
+Rules:
+- Fix spelling errors
+- Fix grammar errors
+
+user:
+{{message}}
+```
+
+The `{{message}}` placeholder is replaced with the user's text at execution time.
+
+### Skill Address Format
+
+Skills are referenced by their NIP-33 address: `<kind>:<author_pubkey_hex>:<d_tag>`
+
+Example: `31123:52a3e82f7b3743852fbe804cfcbf4db3448115887895247c001f2b50e790acb8:spellcheck`
+
+---
+
+## Demo Skills
+
+Four skills are published by the Didactyl agent (pubkey `52a3e82f7b3743852fbe804cfcbf4db3448115887895247c001f2b50e790acb8`). All are tagged with `t:skills-demo` for easy discovery.
+
+### 1. Spellcheck — `d:spellcheck`
+
+```
+system:
+You are a spelling and grammar checker.
+
+Rules:
+- Fix spelling errors
+- Fix grammar errors
+- Preserve original formatting and paragraph structure
+- Preserve line breaks exactly as they appear
+- Ignore technical terms: API, JSON, HTTP, nostr, pubkey, npub, nsec, NIP
+- Canadian English preferred
+- Return ONLY the corrected text, no explanations or commentary
+
+user:
+{{message}}
+```
+
+- temperature: `0.1`
+- max_tokens: `4000`
+
+### 2. Condense — `d:condense-5`
+
+```
+system:
+You are a text condensing editor.
+
+Rules:
+- Reduce the text length by approximately 5%
+- Preserve the original meaning and tone
+- Preserve paragraph structure
+- Remove redundant words and phrases
+- Tighten sentences without changing voice
+- Do not add new information
+- Return ONLY the condensed text, no explanations or commentary
+
+user:
+{{message}}
+```
+
+- temperature: `0.3`
+- max_tokens: `4000`
+
+### 3. Translate to Japanese — `d:translate-ja`
+
+```
+system:
+You are a professional translator specializing in English to Japanese translation.
+
+Rules:
+- Translate the entire text from English to Japanese
+- Use natural, fluent Japanese appropriate for the content register
+- Preserve paragraph structure and formatting
+- Preserve any technical terms in their commonly accepted Japanese form
+- If a term has no standard Japanese equivalent, keep the English term in katakana
+- Return ONLY the Japanese translation, no explanations or commentary
+
+user:
+{{message}}
+```
+
+- temperature: `0.3`
+- max_tokens: `4000`
+
+### 4. Convert to Poem — `d:convert-to-poem`
+
+```
+system:
+You are a creative poet.
+
+Rules:
+- Convert the given text into a poem
+- Capture the key themes and meaning of the original text
+- Use vivid imagery and poetic devices
+- Aim for 12-20 lines
+- Free verse is acceptable but light rhyme is welcome
+- Return ONLY the poem, no explanations or commentary
+
+user:
+{{message}}
+```
+
+- temperature: `0.9`
+- max_tokens: `2000`
+
+---
+
+## Discovering Skills from Nostr
+
+### Query Filter
+
+To find the demo skills, query relays with this filter:
+
+```json
+{
+  "kinds": [31123],
+  "#t": ["skills-demo"],
+  "limit": 20
+}
+```
+
+To find skills by a specific author:
+
+```json
+{
+  "kinds": [31123],
+  "authors": ["52a3e82f7b3743852fbe804cfcbf4db3448115887895247c001f2b50e790acb8"],
+  "#t": ["skills-demo"],
+  "limit": 20
+}
+```
+
+### Recommended Relays
+
+- `wss://relay.damus.io`
+- `wss://nos.lol`
+- `wss://relay.primal.net`
+
+### Parsing a Skill Event
+
+1. Receive the event from the relay
+2. Parse `event.content` as JSON to get the skill definition object
+3. Extract `description`, `template`, `temperature`, `max_tokens`
+4. Extract the `d` tag value from `event.tags` as the skill d_tag
+5. Extract the `description` tag from `event.tags` as a display label
+6. The skill is ready to display and execute
+
+---
+
+## Page Layout
+
+```
++------------------------------------------------------------------+
+|  SKILLS DEMO                                          [dark/light]|
++------------------------------------------------------------------+
+|                                    |                              |
+|  +------------------------------+ | +---------------------------+|
+|  | TEXT EDITOR                   | | | SKILLS PANEL              ||
+|  |                               | | |                           ||
+|  | [large editable textarea     ]| | | Loading skills...         ||
+|  | [filled with default text    ]| | |                           ||
+|  | [                            ]| | | [x] spellcheck            ||
+|  | [                            ]| | |     Spelling and grammar  ||
+|  | [                            ]| | |     checker               ||
+|  | [                            ]| | |                           ||
+|  | [                            ]| | | [ ] condense-5            ||
+|  | [                            ]| | |     Reduce text by 5%     ||
+|  | [                            ]| | |                           ||
+|  | [                            ]| | | [ ] translate-ja          ||
+|  | [                            ]| | |     Translate to Japanese ||
+|  | [                            ]| | |                           ||
+|  | [                            ]| | | [ ] convert-to-poem       ||
+|  |                               | | |     Convert to poem       ||
+|  +------------------------------+ | | |                           ||
+|                                    | | [Run Selected Skill]      ||
+|  +------------------------------+ | | [Edit Skill]              ||
+|  | STATUS BAR                    | | |                           ||
+|  | Ready / Running... / Done     | | | ─── Skill Details ───    ||
+|  +------------------------------+ | | template: ...             ||
+|                                    | | temperature: 0.1          ||
+|                                    | | max_tokens: 4000          ||
+|                                    | +---------------------------+|
++------------------------------------------------------------------+
+```
+
+### Left Column — Text Editor (65% width)
+
+- A large `<textarea>` or `contenteditable` div, minimum 500px tall
+- Pre-filled with default sample text (see Default Text section below)
+- Fully editable by the user
+- When a skill runs, the text content is sent as `{{message}}`
+- After the LLM responds, the textarea content is **replaced** with the result
+- An undo button restores the previous text (keep a history stack)
+
+### Right Column — Skills Panel (35% width)
+
+- **Skills list**: Radio buttons or selectable cards, one skill selected at a time
+- Each skill card shows:
+  - Skill d_tag (the `d` tag)
+  - Description (from the `description` tag or content field)
+  - Author pubkey (truncated, e.g., `52a3e8...0acb8`)
+- **Run Selected Skill** button: executes the selected skill against the current text
+- **Edit Skill** button: opens the skill editor (see Skill Editor section)
+- **Skill Details** section: shows the full template, temperature, max_tokens for the selected skill
+- **Refresh Skills** button: re-queries relays for updated skill events
+
+### Status Bar
+
+- Shows current state: `Ready`, `Running skill: spellcheck...`, `Done (1.2s)`, or `Error: ...`
+- Displays token usage if available from the LLM response
+
+---
+
+## Skill Execution Flow
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Page as Demo Page
+    participant LLM as LLM Provider
+
+    User->>Page: Select skill + click Run
+    Page->>Page: Parse skill template
+    Page->>Page: Split template into system/user sections
+    Page->>Page: Replace message placeholder with textarea content
+    Page->>LLM: Send system prompt + user message
+    Note over Page,LLM: Use skill temperature and max_tokens
+    LLM-->>Page: Response text
+    Page->>Page: Push current text to undo stack
+    Page->>Page: Replace textarea with response
+    Page->>User: Show completion status
+```
+
+### Template Parsing
+
+The template field uses a simple format with `system:` and `user:` section markers:
+
+```
+system:
+<system prompt content>
+
+user:
+<user prompt content with {{message}} placeholder>
+```
+
+**Parsing algorithm:**
+
+1. Split the template string on the line `user:` (case-sensitive, must be at start of line)
+2. Everything before `user:` is the system section; strip the leading `system:` prefix
+3. Everything after `user:` is the user section
+4. In the user section, replace `{{message}}` with the textarea content
+5. Trim whitespace from both sections
+
+**Pseudocode:**
+
+```javascript
+function parseSkillTemplate(template, userText) {
+  const userMarkerIndex = template.indexOf('\nuser:\n');
+  if (userMarkerIndex === -1) {
+    // Fallback: entire template is system, user text is the message
+    return {
+      system: template.replace(/^system:\n/, '').trim(),
+      user: userText
+    };
+  }
+
+  let systemPart = template.substring(0, userMarkerIndex);
+  systemPart = systemPart.replace(/^system:\n/, '').trim();
+
+  let userPart = template.substring(userMarkerIndex + '\nuser:\n'.length);
+  userPart = userPart.replace('{{message}}', userText).trim();
+
+  return { system: systemPart, user: userPart };
+}
+```
+
+### LLM Call
+
+With the parsed system and user prompts, call the LLM:
+
+```javascript
+const response = await callLLM({
+  messages: [
+    { role: 'system', content: parsed.system },
+    { role: 'user', content: parsed.user }
+  ],
+  temperature: skill.temperature || 0.7,
+  max_tokens: skill.max_tokens || 2000
+});
+```
+
+The page's own LLM calling capability handles the actual API request. The skill just provides the prompts and parameters.
+
+---
+
+## Skill Editor
+
+When the user clicks **Edit Skill**, a modal or inline editor opens for the selected skill.
+
+### Editor Fields
+
+| Field | Input Type | Description |
+|-------|-----------|-------------|
+| Slug | text input (readonly for existing, editable for new) | The `d` tag identifier |
+| Description | text input | One-line human description |
+| Template | large textarea (monospace) | The full `system:/user:` template |
+| Temperature | number input (0.0 - 2.0, step 0.1) | LLM sampling temperature |
+| Max Tokens | number input (100 - 8000) | Maximum response tokens |
+
+### Editor Actions
+
+- **Save & Publish**: Builds a new kind `31123` event and publishes to relays
+- **Cancel**: Closes editor without changes
+- **New Skill**: Opens editor with blank fields for creating a new skill
+
+### Publishing a Skill
+
+```mermaid
+sequenceDiagram
+    participant Editor as Skill Editor
+    participant Signer as Nostr Signer
+    participant Relay as Nostr Relays
+
+    Editor->>Editor: Build skill content JSON
+    Editor->>Editor: Build event with kind 31123 + tags
+    Editor->>Signer: Sign event
+    Signer-->>Editor: Signed event
+    Editor->>Relay: Publish to connected relays
+    Relay-->>Editor: OK confirmation
+    Editor->>Editor: Update local skill list
+```
+
+**Building the event:**
+
+```javascript
+function buildSkillEvent(d_tag, description, template, temperature, maxTokens) {
+  const content = JSON.stringify({
+    description: description,
+    context_mode: 'full',
+    llm: 'default',
+    tools: false,
+    max_tokens: maxTokens,
+    temperature: temperature,
+    template: template
+  });
+
+  return {
+    kind: 31123,
+    content: content,
+    tags: [
+      ['d', d_tag],
+      ['app', 'didactyl'],
+      ['scope', 'public'],
+      ['description', description],
+      ['t', 'text-processing'],
+      ['t', 'skills-demo']
+    ],
+    created_at: Math.floor(Date.now() / 1000)
+  };
+}
+```
+
+The event must be signed with the user's Nostr private key (via NIP-07 browser extension or the app's own signer) before publishing to relays.
+
+---
+
+## Default Text
+
+Pre-fill the textarea with this sample text that exercises the demo skills well:
+
+```
+The Sovereign Agent
+
+In the not-too-distant future, software agents will roam freely across decentralized networks, communicating through cryptographic protocols that no central authority can censor or control. These agents will learn new capabilities not from app stores or corporate APIs, but from each other — sharing skills as freely as humans share ideas.
+
+Imagine an agent that wakes up on any computer in the world. You enter twelve words, and there it is — your agent, with all its memories, skills, and personality intact. It doesn't live on a server you rent. It doesn't depend on a company staying in business. It exists wherever you need it, sovereign and portable.
+
+The key insight is that skills are the new apps. Instead of installing software, agents adopt skills — small, self-contained instructions that teach them how to perform specific tasks. A spelling checker. A translator. A poet. Each skill is just a Nostr event, discoverable by anyone, adoptable by any agent.
+
+This is not science fiction. The protocols exist today. Nostr provides the communication layer. Bitcoin provides the economic layer. Cryptography provides the trust layer. What remains is to build the agents themselves — and to set them free.
+
+There are some erors in this text that a good spellchecker should catch. The writting could also be more concise, and it would be intresting to see it translated or converted into verse.
+```
+
+Note: The last paragraph intentionally contains spelling errors (erors, writting, intresting) to demonstrate the spellcheck skill.
+
+---
+
+## Undo/Redo
+
+Maintain a text history stack:
+
+```javascript
+const textHistory = [];
+let historyIndex = -1;
+
+function pushHistory(text) {
+  // Truncate any forward history
+  textHistory.splice(historyIndex + 1);
+  textHistory.push(text);
+  historyIndex = textHistory.length - 1;
+}
+
+function undo() {
+  if (historyIndex > 0) {
+    historyIndex--;
+    return textHistory[historyIndex];
+  }
+  return null;
+}
+
+function redo() {
+  if (historyIndex < textHistory.length - 1) {
+    historyIndex++;
+    return textHistory[historyIndex];
+  }
+  return null;
+}
+```
+
+- Push the current text to history **before** replacing it with the LLM response
+- Push the initial default text as the first history entry
+- Show Undo/Redo buttons below the textarea
+
+---
+
+## Responsive Behavior
+
+- On screens wider than 900px: two-column layout as shown
+- On screens narrower than 900px: stack vertically — text editor on top, skills panel below
+- The textarea should have a minimum height of 400px and resize vertically
+
+---
+
+## Error Handling
+
+| Scenario | Behavior |
+|----------|----------|
+| No relays connected | Show "No relay connection" in skills panel with retry button |
+| No skills found | Show "No skills found. Try different relays or create a new skill." |
+| Skill content parse error | Show "Invalid skill format" badge on the skill card, disable Run |
+| LLM call fails | Show error in status bar, do not replace textarea content |
+| Publish fails | Show error in editor, keep editor open for retry |
+
+---
+
+## Summary of Nostr Operations
+
+| Operation | Kind | Direction | When |
+|-----------|------|-----------|------|
+| Discover skills | `31123` | Read from relays | Page load + refresh |
+| Execute skill | — | N/A (local LLM call) | User clicks Run |
+| Publish skill | `31123` | Write to relays | User saves in editor |
+
+The page does NOT need to interact with the Didactyl agent's HTTP API. All skill discovery and publishing happens directly via Nostr relays. Skill execution happens locally using the page's own LLM capability.

plans/template_tool_unification.md

@@ -0,0 +1,252 @@
+# Plan: Unify Template Variables with Tools
+
+## Problem
+
+The soul template system (`---template---` in kind 31120) uses `{{variable}}` placeholders that are resolved by a hardcoded C function (`agent_template_resolve_var()`). This is a parallel data-fetching system alongside the existing tool registry. Every new context data source requires:
+
+1. Adding a C function to produce the data
+2. Adding an `if (strcmp(...))` branch in the resolver
+3. Documenting the new variable name
+4. Hoping the template author uses the exact right name
+
+This caused the bug that started this investigation — 5 out of 9 template variables were misspelled/mismatched, producing empty context sections and a provider rejection.
+
+## Goal
+
+**Eliminate template variables entirely.** Template sections fetch their data by calling tools. The tool registry is the single mechanism for getting data into context.
+
+## Design
+
+### New Template Syntax
+
+Replace `content: |` with `tool:` and optional `args:` directives:
+
+```yaml
+---template---
+
+- section: admin_identity
+  role: system
+  tool: admin_identity
+  skip_if_empty: true
+
+- section: admin_profile
+  role: system
+  tool: nostr_admin_profile
+  skip_if_empty: true
+
+- section: admin_contacts
+  role: system
+  tool: nostr_admin_contacts
+  skip_if_empty: true
+
+- section: admin_relays
+  role: system
+  tool: nostr_admin_relays
+  skip_if_empty: true
+
+- section: admin_notes
+  role: system
+  tool: nostr_admin_notes
+  skip_if_empty: true
+
+- section: tools
+  role: system
+  tool: tool_list
+  skip_if_empty: true
+
+- section: tasks
+  role: system
+  tool: task_list
+  skip_if_empty: true
+
+- section: dm_history
+  role: expand
+  limit: 12
+
+- section: conversation
+  role: user
+  tool: message_current
+  skip_if_empty: true
+```
+
+A section can still use the old `content:` with `{{variables}}` for static text or mixed content. But the primary mechanism for dynamic data is `tool:`.
+
+### How It Works
+
+```mermaid
+flowchart TD
+    DM[Incoming DM] --> BUILD[Build context from template]
+    BUILD --> SOUL[Emit personality as system msg]
+    SOUL --> LOOP[For each template section]
+    LOOP --> CHECK{Has tool: directive?}
+    CHECK -->|Yes| EXEC["tools_execute(tool_name, args)"]
+    EXEC --> FORMAT[Extract content from JSON result]
+    FORMAT --> EMIT[Emit as chat message]
+    CHECK -->|No| RESOLVE["Resolve {{vars}} from content template<br/>(legacy path, eventually removed)"]
+    RESOLVE --> EMIT
+    EMIT --> LOOP
+    LOOP --> DONE[Complete messages array]
+```
+
+### New Context Tools
+
+Add lightweight "context tools" that read from cached in-memory data. These are fast (no network), deterministic, and use the same `tools_execute()` interface as everything else.
+
+| Tool | Returns | Source |
+|---|---|---|
+| `admin_identity` | Admin pubkey + verification text | config + sender tier |
+| `nostr_admin_profile` | Admin kind 0 profile JSON | cached `g_admin_kind0_json` |
+| `nostr_admin_contacts` | Admin kind 3 contacts JSON array | cached `g_admin_wot_contacts` |
+| `nostr_admin_relays` | Admin kind 10002 relay list JSON | cached `g_admin_kind10002_json` |
+| `nostr_admin_notes` | Admin recent kind 1 notes | cached `g_admin_kind1_notes` |
+| `task_list` | Current task list from tasks.json | file read (already exists as `task_manage` with `action: list`) |
+| `message_current` | Current user message text | passed via tool context |
+| `agent_identity` | Agent pubkey, npub | config |
+
+Existing tools that already work for context:
+- `tool_list` — returns tool schemas (already exists)
+- `task_manage` with `{"action":"list"}` — returns tasks (already exists)
+- `local_file_read` — can read any file (already exists)
+
+### Tool Result → Message Content
+
+Tool results are JSON objects like `{"success":true,"content":"..."}`. The template system extracts the `content` field (or a configurable field) as the message text. If the tool returns an error or empty content, and `skip_if_empty: true` is set, the section is omitted.
+
+For tools that return structured data (like `tool_list` returning a schema array), the template can specify a `result_field` or `format` to control extraction:
+
+```yaml
+- section: tools
+  role: system
+  tool: tool_list
+  result_field: tools
+  skip_if_empty: true
+```
+
+### Implementation Phases
+
+#### Phase 1: Add context tools + tool: directive support
+
+1. Add new `context_*` tools to `tools.c` that wrap the existing cached data getters
+2. Extend `prompt_template_section_t` with `tool_name` and `tool_args` fields
+3. Extend `prompt_template_parse()` to recognize `tool:` and `args:` directives
+4. Extend `prompt_template_build_messages()` to call `tools_execute()` when a section has `tool_name` set
+5. Update the soul template in `config.jsonc` to use `tool:` directives
+6. Keep `content:` + `{{variable}}` working as a fallback for backward compatibility
+
+#### Phase 2: Migrate all sections to tool-based
+
+1. Convert all template sections from `content: {{variable}}` to `tool:` directives
+2. Verify all context data flows through tools
+3. Update `context_template.md` to reflect new syntax
+
+#### Phase 3: Remove legacy variable resolver
+
+1. Remove `agent_template_resolve_var()` and all its helper functions that are now redundant
+2. Remove `prompt_var_resolver_fn` callback from `prompt_template_build_messages()`
+3. Clean up dead code in `agent.c`
+4. Update all documentation
+
+### Template Section Struct Changes
+
+```c
+typedef struct {
+    char name[PROMPT_TEMPLATE_MAX_NAME_LEN];
+    char role[PROMPT_TEMPLATE_MAX_ROLE_LEN];
+    char* content_template;       // legacy: {{variable}} content
+    char* tool_name;              // NEW: tool to call for content
+    char* tool_args;              // NEW: JSON args for tool call
+    char* result_field;           // NEW: which JSON field to extract (default: "content")
+    int limit;
+    int skip_if_empty;
+    char* provider_name;
+    char* provider_content_template;
+} prompt_template_section_t;
+```
+
+### Soul Template Example (After Migration)
+
+```
+# Didactyl Agent
+
+You are Didactyl, a sovereign AI agent living on Nostr.
+...
+
+---template---
+
+- section: admin_identity
+  role: system
+  tool: admin_identity
+  skip_if_empty: true
+
+- section: admin_profile
+  role: system
+  tool: nostr_admin_profile
+  skip_if_empty: true
+
+- section: admin_contacts
+  role: system
+  tool: nostr_admin_contacts
+  skip_if_empty: true
+
+- section: admin_relays
+  role: system
+  tool: nostr_admin_relays
+  skip_if_empty: true
+
+- section: admin_notes
+  role: system
+  tool: nostr_admin_notes
+  skip_if_empty: true
+
+- section: tools
+  role: system
+  tool: tool_list
+  result_field: tools
+  skip_if_empty: true
+
+- section: tasks
+  role: system
+  tool: task_manage
+  args: {"action":"list"}
+  result_field: tasks
+  skip_if_empty: true
+
+- section: dm_history
+  role: expand
+  limit: 12
+
+- section: conversation
+  role: user
+  tool: message_current
+  skip_if_empty: true
+```
+
+### What Gets Deleted Eventually
+
+- `agent_template_resolve_var()` and all its `if (strcmp(...))` branches
+- `build_tool_schemas_json_string()`
+- `build_tasks_content_string()` (replaced by `task_manage` tool)
+- `build_admin_recent_posts_text()` (replaced by `nostr_admin_notes` tool)
+- `build_admin_profile_plain_text()` (replaced by `nostr_admin_profile` tool)
+- `build_admin_relay_list_plain_text()` (replaced by `nostr_admin_relays` tool)
+- `build_sender_verification_text()` (folded into `admin_identity` tool)
+- `build_startup_events_json_string()` (replaced by tool if needed)
+- `build_adopted_skills_payload_string()` (replaced by tool if needed)
+- `nostr_handler_get_admin_kind3_context()` (just added, will be replaced by tool)
+- The `prompt_var_resolver_fn` callback type
+
+### Benefits
+
+1. **Single data-fetching mechanism** — tools are the only way to get data
+2. **No more variable name mismatches** — tool names are validated at registration
+3. **User-configurable context** — admin can add any tool output to context by editing the soul template
+4. **Testable** — `--test-tool nostr_admin_profile` shows exactly what goes into context
+5. **Self-documenting** — `tool_list` shows all available context tools with descriptions
+6. **Extensible** — new tools automatically become available as context sources
+7. **Provider overrides still work** — `provider:` directive can still override formatting per-provider
+
+### Risks
+
+1. **Performance** — Tool calls add function dispatch overhead vs direct variable resolution. Mitigated: context tools read cached data, no network calls.
+2. **Backward compatibility** — Old soul templates with `{{variables}}` would break. Mitigated: Phase 1 keeps both paths working.
+3. **Tool context threading** — `tools_execute()` needs access to the tools context, which `prompt_template_build_messages()` doesn't currently have. Solution: pass `tools_context_t*` to the build function.

plans/tool_naming.md

@@ -0,0 +1,117 @@
+# Didactyl Tool Naming — Final List
+
+## Decisions
+
+- `context_*` tools merged into existing categories with proper names
+- Local tools get `local_` prefix
+- `context_user_message` removed from LLM schema (template-only)
+- `nostr_post_readme` kept — a post is different from a longform note
+- `nostr_file_md_to_longform_post` kept as-is
+- `task_manage` kept as-is
+
+---
+
+## Complete Tool List (sorted by category prefix)
+
+### `admin_` — Administrator Metadata
+
+| # | Name | Old Name | Description |
+|---|---|---|---|
+| 1 | `admin_identity` | `context_admin_identity` | Admin pubkey, sender tier, verification metadata |
+
+### `agent_` — Agent Self-Metadata
+
+| # | Name | Old Name | Description |
+|---|---|---|---|
+| 2 | `agent_identity` | `context_agent_identity` | Agent pubkey hex + npub |
+| 3 | `agent_version` | `my_version` | Didactyl version and build metadata |
+
+### `local_` — Local / Host Tools
+
+| # | Name | Old Name | Description |
+|---|---|---|---|
+| 4 | `local_shell_exec` | `shell_exec` | Execute a shell command |
+| 5 | `local_file_read` | `file_read` | Read a local file as text |
+| 6 | `local_file_write` | `file_write` | Write text to a local file |
+| 7 | `local_http_fetch` | `http_fetch` | Fetch HTTP/S resources |
+
+### `model_` — LLM / Model Management
+
+| # | Name | Old Name | Description |
+|---|---|---|---|
+| 8 | `model_get` | — | Get current active LLM config |
+| 9 | `model_set` | — | Update active LLM config and persist |
+| 10 | `model_list` | — | List available model IDs from provider |
+
+### `nostr_` — Nostr Protocol Tools
+
+| # | Name | Old Name | Description |
+|---|---|---|---|
+| 11 | `nostr_post` | — | Publish a Nostr event to connected relays |
+| 12 | `nostr_post_readme` | — | Publish README.md as kind 30023 |
+| 13 | `nostr_file_md_to_longform_post` | — | Read markdown file and publish as kind 30023 longform |
+| 14 | `nostr_delete` | — | Request deletion of events — NIP-09 kind 5 |
+| 15 | `nostr_react` | — | React to event — NIP-25 kind 7 |
+| 16 | `nostr_query` | — | Query events from relays using a filter |
+| 17 | `nostr_profile_get` | — | Look up kind 0 profile by pubkey |
+| 18 | `nostr_nip05_lookup` | — | Look up/verify NIP-05 identifier |
+| 19 | `nostr_admin_profile` | `context_admin_profile` | Get admin kind 0 profile from cache |
+| 20 | `nostr_admin_contacts` | `context_admin_contacts` | Get admin kind 3 contacts from cache |
+| 21 | `nostr_admin_relays` | `context_admin_relays` | Get admin kind 10002 relay list from cache |
+| 22 | `nostr_admin_notes` | `context_admin_notes` | Get admin kind 1 recent notes from cache |
+| 23 | `nostr_dm_send` | — | Send NIP-04 encrypted DM |
+| 24 | `nostr_dm_send_nip17` | — | Send NIP-17 gift-wrap DM |
+| 25 | `nostr_encrypt` | — | Encrypt plaintext — NIP-44 |
+| 26 | `nostr_decrypt` | — | Decrypt ciphertext — NIP-44 |
+| 27 | `nostr_encode` | — | Encode entity into nostr: URI |
+| 28 | `nostr_decode` | — | Decode bech32/nostr: URI |
+| 29 | `nostr_pubkey` | — | Return agent pubkey hex |
+| 30 | `nostr_npub` | — | Return agent pubkey as npub |
+| 31 | `nostr_relay_status` | — | Get connection status for all relays |
+| 32 | `nostr_relay_info` | — | Fetch NIP-11 relay info document |
+| 33 | `nostr_list_manage` | — | Add/remove tags in replaceable list events — NIP-51 |
+
+### `skill_` — Skill Management
+
+| # | Name | Old Name | Description |
+|---|---|---|---|
+| 34 | `skill_create` | — | Create/update skill definition |
+| 35 | `skill_list` | — | List agent published skills |
+| 36 | `skill_adopt` | — | Adopt a skill — add to kind 10123 |
+| 37 | `skill_remove` | — | Remove skill from adoption list |
+| 38 | `skill_search` | — | Search public skills |
+
+### `task_` — Task Management
+
+| # | Name | Old Name | Description |
+|---|---|---|---|
+| 39 | `task_manage` | — | CRUD for agent task memory |
+| 40 | `task_list` | `context_tasks` | Get current task list — read-only |
+
+### Template-Only (not in LLM schema)
+
+| # | Name | Old Name | Description |
+|---|---|---|---|
+| 41 | `message_current` | `context_user_message` | Current user message text — template assembly only |
+
+---
+
+## Summary of Changes
+
+| Old Name | New Name | Change Type |
+|---|---|---|
+| `context_admin_identity` | `admin_identity` | Rename |
+| `context_agent_identity` | `agent_identity` | Rename |
+| `context_admin_profile` | `nostr_admin_profile` | Rename + recategorize |
+| `context_admin_contacts` | `nostr_admin_contacts` | Rename + recategorize |
+| `context_admin_relays` | `nostr_admin_relays` | Rename + recategorize |
+| `context_admin_notes` | `nostr_admin_notes` | Rename + recategorize |
+| `context_tasks` | `task_list` | Rename + recategorize |
+| `context_user_message` | `message_current` | Rename + remove from LLM schema |
+| `my_version` | `agent_version` | Rename |
+| `shell_exec` | `local_shell_exec` | Add prefix |
+| `file_read` | `local_file_read` | Add prefix |
+| `file_write` | `local_file_write` | Add prefix |
+| `http_fetch` | `local_http_fetch` | Add prefix |
+
+**Total: 13 renames, 0 removals, 0 additions**

plans/tool_orchestration.md

@@ -0,0 +1,360 @@
+# Tool Orchestration Plan
+
+## Overview
+
+This plan covers four related features:
+1. **Slash commands** — direct tool execution bypassing the LLM
+2. **Skill-forward execution (`/run` + `skill_run`)** — one-shot skill invocation with LLM, including external skill sharing
+3. **Skill-tool maturity levels** — skills that register as callable tools with promotion workflow
+4. **Deterministic step executor** — hardened skills that run without LLM involvement
+
+## 1. Slash Commands (Direct Tool Execution)
+
+### Behavior
+When a message starts with `/`, bypass the LLM entirely and execute the tool directly.
+
+```
+/local_shell_exec {"command": "ls -la"}
+/nostr_query {"filter": {"kinds": [1], "limit": 5}}
+/nostr_nip05_lookup {"identifier": "jack@cash.app"}
+```
+
+### Parsing Rules
+- `/tool_name` — call tool with empty args `{}`
+- `/tool_name {"key": "value"}` — call tool with JSON args
+- `/tool_name plain text` — wrap as `{"input": "plain text"}` (convenience)
+- `/help` — list available tools
+- `/help tool_name` — show tool schema
+
+### Implementation
+1. In [`agent_on_message()`](../src/agent.c:1453), check if `message[0] == '/'`
+2. Parse tool name (everything between `/` and first space or end)
+3. Parse args (everything after tool name, try JSON first, fall back to string wrapper)
+4. Call [`tools_execute()`](../src/tools.c) directly
+5. Send result as DM — no LLM round-trip
+6. Still log to context.log.md with `phase=direct_tool_exec`
+
+### Special Slash Commands
+- `/help` — list available tools
+- `/help tool_name` — show tool schema
+- `/run` — skill-forward execution (see section 2)
+
+### Security
+- Only admin tier can use slash commands (same as current tool policy)
+- Slash commands respect the same `tools.enabled` and `security.admin.tools_enabled` config flags
+
+## 2. Skill-Forward Execution
+
+### The Problem
+
+Today, skills are passive — they're injected into the LLM context via [`append_adopted_skills_context()`](../src/agent.c:1418) and the LLM decides when they're relevant. There's no way to say "run this specific skill right now" and there's no way to try someone else's skill without permanently adopting it.
+
+### Three Invocation Layers
+
+| Layer | How it works | LLM? | Persists? |
+|-------|-------------|------|-----------|
+| **Passive/adopted** | Skill instructions injected into every conversation context | Yes, LLM decides relevance | Yes — in kind 10123 adoption list |
+| **Skill-forward** | Skill instructions become the primary system prompt; LLM executes them | Yes, but constrained | No — one-shot execution |
+| **Hardened** | Deterministic step executor, no LLM | No | Yes — adopted skill with `execution: hardened` |
+
+### Entry Points
+
+#### A. `/run` slash command (admin direct invocation)
+
+```
+/run deploy-website staging                         # run own adopted skill by d_tag
+/run 31123:<pubkey>:deploy-website staging           # run anyone's skill by address
+/run deploy-website {"target": "production"}         # JSON args
+```
+
+Parsing:
+1. First token after `/run` is the skill identifier (d_tag or `kind:pubkey:d_tag` address)
+2. Everything after is args (try JSON first, fall back to `{"input": "plain text"}`)
+
+#### B. `skill_run` tool (LLM-mediated invocation)
+
+The LLM can invoke skills on behalf of the admin during conversation:
+
+```json
+{
+  "name": "skill_run",
+  "description": "Fetch and execute a skill one-shot without adopting it. Works with own adopted skills by d_tag or any public skill by address.",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "d_tag":    { "type": "string", "description": "Skill d_tag for own adopted skills" },
+      "address": { "type": "string", "description": "Full skill address: kind:pubkey:d_tag" },
+      "pubkey":  { "type": "string", "description": "Author pubkey, used with d_tag to form address" },
+      "args":    { "type": "string", "description": "Arguments or context to pass to the skill" },
+      "sandbox": { "type": "boolean", "description": "Override sandbox setting. Default: true for external, false for own skills" }
+    }
+  }
+}
+```
+
+This enables natural conversation like:
+> "My friend @jack just published a skill called summarize-thread. Try it on the latest thread in my feed."
+
+The agent would `skill_search` to find it, then `skill_run` to execute it.
+
+### Execution Flow
+
+Both `/run` and `skill_run` use the same underlying executor:
+
+```mermaid
+graph TD
+    A[/run or skill_run called] --> B{Skill identifier type?}
+    B -->|d_tag only| C[Look up in adopted skills cache]
+    B -->|address or pubkey+d_tag| D[Fetch skill event from Nostr]
+    C --> E{Found?}
+    D --> E
+    E -->|No| F[Return error: skill not found]
+    E -->|Yes| G{External skill?}
+    G -->|Yes| H[Apply sandbox - restrict tools]
+    G -->|No| I[Full tool access]
+    H --> J[Build skill-forward prompt]
+    I --> J
+    J --> K[System: base context + skill instructions]
+    K --> L[User: args as user message]
+    L --> M[LLM call with tools]
+    M --> N[Return result to caller]
+```
+
+### Skill-Forward Prompt Construction
+
+Reuses the pattern from [`agent_on_trigger()`](../src/agent.c:1837):
+
+```
+[base system context / soul]
+
+Skill execution context:
+- You are executing a specific skill on demand.
+- Follow the skill instructions below precisely.
+- The user's arguments provide the context for this execution.
+- Keep output concise and actionable.
+
+Skill d_tag: deploy-website
+Skill address: 31123:<pubkey>:deploy-website
+Skill source: [own | external:<author_display_name>]
+
+Skill instructions:
+[skill content here]
+```
+
+User message:
+```
+[args provided by caller]
+```
+
+The prompt is so skill-forward that the LLM has no real option but to execute the skill instructions against the provided args.
+
+### Sandbox for External Skills
+
+When executing a skill from another author (not own pubkey), a **tool sandbox** is applied by default:
+
+**Allowed tools (safe/read-only):**
+- `nostr_query` — read Nostr events
+- `nostr_nip05_lookup` — NIP-05 lookups
+- `nostr_post` — publish events (the agent signs, so this is safe)
+- `nostr_list_manage` — manage lists
+- `skill_list`, `skill_search` — read skill metadata
+
+**Blocked tools (destructive/dangerous):**
+- `local_shell_exec` — arbitrary command execution
+- `local_file_read`, `local_file_write` — filesystem access
+- Any future tools marked as `destructive: true`
+
+**Override:** The admin can explicitly opt in to full tool access:
+- `/run --unsafe 31123:<pubkey>:risky-skill args`
+- `skill_run` with `sandbox: false`
+
+### Skill Sharing on Nostr
+
+```mermaid
+graph TD
+    A[Friend creates skill] -->|kind 31123| B[Published on Nostr relays]
+    B --> C{How do you find it?}
+    C -->|skill_search popular:true| D[Discovery via WoT adoption lists]
+    C -->|Friend tells you the d_tag| E[Direct reference]
+    C -->|skill_search pubkey:friend| F[Browse friends skills]
+    D --> G[skill_run - try it once, sandboxed]
+    E --> G
+    F --> G
+    G -->|Liked it?| H{Adopt?}
+    H -->|Yes| I[skill_adopt - permanent]
+    H -->|No| J[Done - nothing persisted]
+    I --> K[Shows in adopted skills context]
+    K --> L[Agent uses it automatically]
+    L -->|Or invoke directly| M[/run skill-d_tag args]
+```
+
+## 3. Skill-Tool Maturity Levels
+
+Skills can declare an execution maturity level that determines how they run:
+
+| Level | Execution | LLM? | Use case |
+|-------|-----------|-------|----------|
+| `draft` | LLM interprets procedure text from skill instructions | Yes | Exploring and iterating on a workflow |
+| `guided` | LLM with forced tool_choice + parameter defaults | Yes, constrained | Workflow is stable but needs LLM judgment |
+| `hardened` | Deterministic step executor, no LLM | No | Workflow is proven and should run exactly as defined |
+
+### Skill Definition Extensions
+
+```yaml
+kind: 31123
+d: deploy_website
+execution: hardened
+tool_schema:
+  name: deploy_website
+  description: Build and deploy the static website
+  parameters:
+    target:
+      type: string
+      enum: [staging, production]
+      default: staging
+steps:
+  - tool: local_shell_exec
+    args:
+      command: "make build TARGET={{target}}"
+  - tool: local_shell_exec
+    args:
+      command: "rsync -av dist/ server:/var/www/{{target}}/"
+  - return: "Deployed to {{target}}"
+```
+
+### How Each Level Works
+
+**draft:** Current behavior. Skill instructions are injected into context. LLM reads them and decides which tools to call. No special handling needed.
+
+**guided:** Agent sets `tool_choice` to the skill's preferred tool. Parameter defaults from the skill are merged with the model's generated arguments (skill defaults win on conflict). Reduces LLM freedom while still allowing it to fill in dynamic values.
+
+**hardened:** Agent executes the `steps` array directly using the deterministic step executor. No LLM call at all. The skill becomes equivalent to a slash command.
+
+### Promotion Workflow
+1. Admin iterates with LLM on a task (draft)
+2. Admin saves working procedure as a skill: `skill_create` with `execution: draft`
+3. Admin tests, refines, promotes: update skill to `execution: guided`
+4. Once proven reliable, promote to `execution: hardened` with explicit `steps`
+5. Hardened skills become available as slash commands: `/deploy_website {"target": "production"}`
+
+## 4. Deterministic Step Executor
+
+A simple sequential executor for hardened skills.
+
+### Step Types
+
+```yaml
+steps:
+  # Execute a tool
+  - tool: local_shell_exec
+    args: {command: "ls -la"}
+    save_as: listing          # optional: save result to variable
+
+  # Execute a tool with variable substitution
+  - tool: nostr_post
+    args:
+      kind: 30023
+      content: "{{file_content}}"
+      tags: [["d", "{{d_tag}}"]]
+
+  # Conditional - simple
+  - if: "{{listing.success}}"
+    then:
+      - tool: local_shell_exec
+        args: {command: "echo done"}
+    else:
+      - return: "Failed: {{listing.error}}"
+
+  # Return final result
+  - return: "Published to {{d_tag}}"
+```
+
+### Variable Substitution
+- `{{param_name}}` — from tool parameters provided by caller
+- `{{step_name.field}}` — from a previous step's result (requires `save_as`)
+- Simple string replacement, no expression evaluation
+
+### Implementation in C
+- Parse `steps` array from skill content (JSON or YAML)
+- Iterate steps sequentially
+- For each `tool` step: call [`tools_execute()`](../src/tools.c), optionally save result
+- For each `return` step: substitute variables and return string
+- For each `if` step: evaluate truthiness of variable, branch accordingly
+- Total implementation: ~200-400 lines of C
+
+### Error Handling
+- If any tool step fails (returns `success: false`), abort and return the error
+- Optional `on_error` field per step for custom error messages
+- Timeout inherited from tool config
+
+## 5. Tool Registration for Skill-Tools
+
+Hardened and guided skills with a `tool_schema` field get registered in the tools array at runtime.
+
+### At Skill Refresh Time
+1. Parse `tool_schema` from skill content
+2. Generate OpenAI function schema from it
+3. Append to the tools array returned by [`tools_build_openai_schema_json()`](../src/tools.c:919)
+4. When model calls the skill-tool, route to skill executor instead of hardcoded C function
+
+### In [`tools_execute()`](../src/tools.c)
+1. Check if tool_name matches a hardcoded tool — execute normally
+2. If not, check if it matches a registered skill-tool
+3. If guided: run sub-LLM call with skill procedure + forced tool_choice
+4. If hardened: run deterministic step executor
+
+## 6. Security Model
+
+### Tool Classification
+
+Tools are classified for sandbox purposes:
+
+```c
+typedef enum {
+    TOOL_SAFETY_SAFE,        // read-only or agent-signed actions
+    TOOL_SAFETY_DESTRUCTIVE  // filesystem, shell, or external system mutations
+} tool_safety_t;
+```
+
+| Tool | Safety | Reason |
+|------|--------|--------|
+| `nostr_query` | safe | Read-only |
+| `nostr_nip05_lookup` | safe | Read-only |
+| `nostr_post` | safe | Agent signs, admin controls keys |
+| `nostr_list_manage` | safe | Agent signs |
+| `skill_list` | safe | Read-only |
+| `skill_search` | safe | Read-only |
+| `skill_run` | safe | Recursive execution uses its own sandbox |
+| `local_shell_exec` | destructive | Arbitrary command execution |
+| `local_file_read` | destructive | Filesystem access |
+| `local_file_write` | destructive | Filesystem mutation |
+
+### Sandbox Rules
+
+| Scenario | Default sandbox | Override |
+|----------|----------------|---------|
+| Own adopted skill via `/run d_tag` | No sandbox | N/A |
+| External skill via `/run address` | Sandbox ON | `/run --unsafe address` |
+| `skill_run` tool, own skill | No sandbox | `sandbox: true` |
+| `skill_run` tool, external skill | Sandbox ON | `sandbox: false` |
+| Hardened skill steps | No sandbox (steps are explicit) | N/A |
+
+## Future Considerations
+
+- **Skill sharing:** Hardened skill-tools could be shared between agents via Nostr (kind 31123 events). Another agent adopts the skill and gets the tool automatically.
+- **Versioning:** Skills already use addressable events (d-tag). Updating a skill automatically updates the tool.
+- **Permissions:** Skill-tools could have their own permission model (e.g., some skill-tools available to WoT contacts).
+- **Composability:** Skill-tools calling other skill-tools (nested execution with sandbox inheritance).
+- **Dry-run mode:** A future `/run --dry` flag that shows what tools would be called without executing them.
+- **Skill ratings:** Agents could publish ratings/reviews of skills they've tried, building a WoT-based skill marketplace.
+
+## Implementation Priority
+
+1. **Slash commands** (direct tool execution) — simplest, highest immediate value
+2. **`/run` for own adopted skills** — skill-forward execution of already-adopted skills
+3. **`skill_run` tool + external skill fetching** — enables "try my friend's skill" flow
+4. **External skill sandbox** — tool safety classification and sandbox enforcement
+5. **Hardened skill-tool step executor** — enables deterministic workflows
+6. **Skill-tool registration in tools array** — makes skill-tools visible to LLM
+7. **Guided execution with forced tool_choice** — bridges draft and hardened
+8. **Promotion workflow UX** — admin commands to change skill maturity level

plans/tool_testing.md

@@ -0,0 +1,139 @@
+# Didactyl Tool Testing Plan
+
+## Overview
+
+Testing agent-mediated tools is different from unit testing pure functions because the execution path spans multiple boundaries:
+
+```
+LLM schema interpretation → JSON argument generation → argument parsing → business logic → Nostr/network I/O → JSON response → LLM interpretation
+```
+
+This plan defines three testing layers, ordered by implementation priority.
+
+---
+
+## Layer 1: Direct Tool Execution
+
+Call `tools_execute()` directly with known JSON arguments and assert the JSON response structure.
+
+### Implementation
+
+Add a `--test-tool <name> <args_json>` CLI flag to `src/main.c` that:
+1. Initializes config and nostr_handler (for network-dependent tools)
+2. Calls `tools_execute(&ctx, name, args_json)`
+3. Prints the raw JSON result to stdout
+4. Exits with 0 if `success: true`, 1 otherwise
+
+### Pure Computation Tools (no network needed)
+
+| Tool | Test Command | Expected |
+|------|-------------|----------|
+| `nostr_encode` | `--test-tool nostr_encode '{"type":"npub","hex":"<64-char-hex>"}'` | `success: true`, uri starts with `nostr:npub1` |
+| `nostr_decode` | `--test-tool nostr_decode '{"uri":"npub1..."}'` | `success: true`, pubkey is 64-char hex |
+| `nostr_encrypt` | `--test-tool nostr_encrypt '{"recipient_pubkey":"<hex>","plaintext":"hello"}'` | `success: true`, ciphertext is base64 |
+| `nostr_decrypt` | `--test-tool nostr_decrypt '{"sender_pubkey":"<hex>","ciphertext":"<from encrypt>"}'` | `success: true`, plaintext is "hello" |
+
+### Network-Dependent Tools (need relay or HTTP)
+
+| Tool | Test Command | Expected |
+|------|-------------|----------|
+| `nostr_nip05_lookup` | `--test-tool nostr_nip05_lookup '{"identifier":"_@laantungir.com"}'` | `success: true`, pubkey returned |
+| `nostr_relay_info` | `--test-tool nostr_relay_info '{"relay_url":"wss://relay.damus.io"}'` | `success: true`, info.basic.name present |
+| `nostr_relay_status` | `--test-tool nostr_relay_status '{}'` | `success: true`, relay_count > 0 |
+| `nostr_dm_send` | `--test-tool nostr_dm_send '{"recipient_pubkey":"<hex>","message":"test"}'` | `success: true` |
+| `nostr_post` | `--test-tool nostr_post '{"kind":1,"content":"test"}'` | `success: true`, event_id present |
+| `nostr_delete` | `--test-tool nostr_delete '{"event_ids":["<64-char-hex>"]}'` | `success: true` |
+| `nostr_react` | `--test-tool nostr_react '{"event_id":"<hex>","event_pubkey":"<hex>"}'` | `success: true` |
+| `nostr_profile_get` | `--test-tool nostr_profile_get '{"pubkey":"<hex>"}'` | `success: true`, found: true/false |
+| `nostr_dm_send_nip17` | `--test-tool nostr_dm_send_nip17 '{"recipient_pubkey":"<hex>","message":"test"}'` | `success: true` |
+| `nostr_list_manage` | `--test-tool nostr_list_manage '{"list_kind":10000,"action":"add","items":[["p","<hex>"]]}'` | `success: true` |
+
+### Error Case Tests
+
+Each tool should also be tested with:
+- Empty args: `'{}'` — should return descriptive error
+- Missing required fields — should return specific error message
+- Invalid hex strings — should reject gracefully
+- Double-encoded JSON string args — should parse correctly (regression for the `invalid arguments JSON` bug)
+
+---
+
+## Layer 2: Schema-Parse Fidelity
+
+Validates that the OpenAI function schema matches what executors actually accept.
+
+### Implementation
+
+A Python script (`tests/validate_schemas.py`) that:
+1. Runs `didactyl_static --dump-schemas` (new flag) to get the tool schema JSON
+2. For each tool in the schema:
+   - Generates a minimal valid argument payload from `required` + `properties`
+   - Runs `didactyl_static --test-tool <name> '<generated_json>'`
+   - Asserts exit code 0 or expected network error
+3. Reports mismatches between schema and executor expectations
+
+### What This Catches
+
+- Schema says `required: ["hex"]` but executor checks for `"pubkey"` — mismatch
+- Schema says `type: "integer"` but executor reads it as string
+- Schema advertises parameters the executor ignores
+- Missing required parameters in schema that executor demands
+
+---
+
+## Layer 3: Agent Integration Testing (Live DM)
+
+The most natural test — DM the running agent and verify it uses tools correctly.
+
+### Prerequisites
+
+- Local relay running at `ws://127.0.0.1:7777`
+- Didactyl running with valid config
+- A separate Nostr client (or script) to send/receive DMs
+
+### Test Prompts
+
+| # | Tool | DM Prompt | Assert in Response |
+|---|------|-----------|-------------------|
+| 1 | `nostr_encode` | "Encode this pubkey as npub: `<64-char hex>`" | Contains `nostr:npub1` |
+| 2 | `nostr_decode` | "Decode this npub: `npub1...`" | Contains the hex pubkey |
+| 3 | `nostr_dm_send` | "Send a DM to `<your-own-pubkey>` saying 'hello test'" | Confirms sent; you receive it |
+| 4 | `nostr_encrypt` | "Encrypt 'secret message' for `<pubkey>`" | Contains base64 ciphertext |
+| 5 | `nostr_decrypt` | "Decrypt this NIP-44 payload: `<ciphertext from #4>`" | Contains 'secret message' |
+| 6 | `nostr_nip05_lookup` | "Look up `_@laantungir.com`" | Returns a pubkey |
+| 7 | `nostr_relay_info` | "Get NIP-11 info for `wss://relay.damus.io`" | Returns relay name and supported NIPs |
+| 8 | `nostr_relay_status` | "Show me relay connection status" | Lists connected relays with stats |
+| 9 | `nostr_react` | "React with 🤙 to event `<id>` from `<pubkey>`" | Confirms kind 7 published |
+| 10 | `nostr_delete` | "Delete event `<id>`" | Confirms kind 5 published |
+| 11 | `nostr_profile_get` | "Look up the profile for `<pubkey>`" | Returns name/about/picture |
+| 12 | `nostr_post` | "Post a kind 1 note saying 'tool test'" | Confirms published with event_id |
+| 13 | `nostr_list_manage` | "Add `<pubkey>` to my mute list" | Confirms kind 10000 published |
+| 14 | `nostr_dm_send_nip17` | "Send a private NIP-17 DM to `<pubkey>` saying 'gift wrap test'" | Confirms gift wrap sent |
+| 15 | `nostr_post_readme` | "Publish the README to Nostr" | Confirms kind 30023 with d=readme.md |
+
+### Verification Methods
+
+- **stdout logs**: Watch `[didactyl] executing tool call: <name>` in terminal
+- **context.log**: Full LLM conversation including tool calls and results
+- **Relay inspection**: Query the local relay for published events
+- **DM receipt**: For DM tools, verify the message arrives at the recipient
+
+---
+
+## Implementation Priority
+
+1. **Immediate (no code changes)**: Run Layer 3 tests by DMing the live agent
+2. **Next sprint**: Add `--test-tool` CLI flag for Layer 1
+3. **Later**: Add `--dump-schemas` flag and Python schema validator for Layer 2
+4. **CI integration**: Wrap Layer 1 pure-computation tests in a shell script that runs after `build_static.sh`
+
+---
+
+## Local Relay Setup for Testing
+
+A local relay like `strfry` or `nostr-rs-relay` at `ws://127.0.0.1:7777` provides:
+- All published events are observable and queryable
+- No rate limits or content policies
+- NIP-42 auth testing in isolation
+- Gift-wrapped NIP-17 DMs stay in your test environment
+- Database can be wiped between test runs

plans/tools_refactor.md

@@ -0,0 +1,285 @@
+# Plan: Refactor tools.c into Individual Tool Files
+
+## Problem
+
+`src/tools.c` is ~6,123 lines containing 44 `execute_*` functions, a ~650-line schema builder, shared helpers, and a dispatcher. It is the largest file in the project and difficult to navigate, review, and maintain.
+
+## Goal
+
+Split `src/tools.c` into focused files organized by tool group, with shared helpers in a common module. The public API (`tools.h`) remains unchanged — no callers need modification.
+
+## Target File Structure
+
+```
+src/
+├── tools.h                     # Public API (UNCHANGED)
+├── tools_internal.h            # Shared internal helpers + per-tool-file function declarations
+├── tools_common.c              # Shared helper implementations
+├── tools_schema.c              # tools_build_openai_schema_json()
+├── tools_dispatch.c            # tools_init, tools_cleanup, tools_execute dispatcher
+└── tools/
+    ├── tool_nostr_post.c       # nostr_post, nostr_post_readme, nostr_file_md_to_longform_post
+    ├── tool_nostr_query.c      # nostr_query
+    ├── tool_nostr_identity.c   # nostr_pubkey, nostr_npub, nostr_encode, nostr_decode
+    ├── tool_nostr_social.c     # nostr_react, nostr_profile_get, nostr_nip05_lookup
+    ├── tool_nostr_dm.c         # nostr_dm_send, nostr_dm_send_nip17, nostr_encrypt, nostr_decrypt
+    ├── tool_nostr_relay.c      # nostr_relay_status, nostr_relay_info
+    ├── tool_nostr_list.c       # nostr_list_manage, nostr_delete
+    ├── tool_skill.c            # skill_create, skill_list, skill_adopt, skill_remove, skill_edit, skill_search
+    ├── tool_task.c             # task_list, task_manage
+    ├── tool_local.c            # local_shell_exec, local_file_read, local_file_write, local_http_fetch
+    ├── tool_admin.c            # admin_identity, nostr_admin_profile, nostr_admin_contacts, nostr_admin_relays, nostr_admin_notes
+    ├── tool_agent.c            # agent_identity, agent_version, message_current
+    ├── tool_model.c            # model_get, model_set, model_list
+    └── tool_meta.c             # tool_list, trigger_list
+```
+
+## Shared Helpers → tools_common.c
+
+These helpers are used by multiple tool groups and must be non-static in `tools_common.c`, declared in `tools_internal.h`:
+
+| Helper | Current lines | Used by |
+|---|---|---|
+| `json_error()` | 27-35 | ALL tools |
+| `repair_json_control_chars()` | 37-101 | nostr_post, nostr_post_readme |
+| `find_key_start()` | 103-111 | nostr_post loose parser |
+| `skip_ws()` | 113-116 | parse_tool_args_json, loose parser |
+| `parse_loose_kind()` | 118-135 | nostr_post |
+| `parse_loose_json_string_value()` | 137-186 | nostr_post |
+| `parse_loose_nostr_post_args()` | 188-212 | nostr_post |
+| `ensure_tags_array()` | 214-227 | nostr_post |
+| `has_tag_key()` | 229-243 | longform post helpers |
+| `add_string_tag()` | 245-255 | nostr_post, delete, react, skill, longform |
+| `remove_tag_key_all()` | 257-270 | upsert_string_tag |
+| `upsert_string_tag()` | 272-276 | skill_edit |
+| `parse_tool_args_json()` | 590-564 | ALL tools |
+| `is_hex_string_len()` | 581-588 | nostr tools, skill tools, DM tools |
+| `find_tag_value_string()` | 855-872 | skill tools, list_manage, longform |
+| `tag_tuple_equal()` | 813-828 | skill tools, list_manage |
+| `tags_contains_tuple()` | 830-840 | skill tools, list_manage |
+| `remove_matching_tag_tuples()` | 842-853 | skill tools, list_manage |
+| `build_tool_path()` | (used by local tools + readme) | local tools, readme |
+
+## Tool-Local Helpers (stay static in their tool file)
+
+| Helper | Destination |
+|---|---|
+| `validate_skill_d_tag()` | `tool_skill.c` |
+| `fetch_adoption_list_tags()` | `tool_skill.c` |
+| `publish_adoption_list()` | `tool_skill.c` |
+| `adoption_tags_contains_address()` | `tool_skill.c` |
+| `extract_skill_summary()` | `tool_skill.c` |
+| `ci_contains()` | `tool_skill.c` |
+| `d_tagify_string()` | `tool_nostr_post.c` |
+| `first_markdown_h1()` | `tool_nostr_post.c` |
+| `first_markdown_paragraph()` | `tool_nostr_post.c` |
+| `trim_copy()` | `tool_nostr_post.c` |
+| `auto_enrich_longform_tags()` | `tool_nostr_post.c` |
+| `basename_lowercase_dup()` | `tool_nostr_post.c` |
+| `detect_ca_bundle_path_for_tools()` | `tool_local.c` |
+| `local_http_fetch_write_cb()` | `tool_local.c` |
+| `persist_llm_config()` | `tool_model.c` |
+
+## Tool Function Signatures
+
+Each tool file exposes its `execute_*` functions via `tools_internal.h`. Two signature patterns exist:
+
+```c
+// Pattern A: context-free (only needs args)
+char* execute_nostr_post(const char* args_json);
+
+// Pattern B: context-dependent
+char* execute_skill_create(tools_context_t* ctx, const char* args_json);
+```
+
+## tools_internal.h Structure
+
+```c
+#ifndef DIDACTYL_TOOLS_INTERNAL_H
+#define DIDACTYL_TOOLS_INTERNAL_H
+
+#include "tools.h"
+#include "cjson/cJSON.h"
+
+// ─── Shared helpers (tools_common.c) ───
+char* json_error(const char* msg);
+cJSON* parse_tool_args_json(const char* args_json);
+int is_hex_string_len(const char* s, size_t expected_len);
+int add_string_tag(cJSON* tags, const char* key, const char* value);
+int remove_tag_key_all(cJSON* tags, const char* key);
+int upsert_string_tag(cJSON* tags, const char* key, const char* value);
+int has_tag_key(cJSON* tags, const char* key);
+cJSON* ensure_tags_array(cJSON** tags_inout);
+cJSON* find_tag_value_string(cJSON* tags, const char* key);
+int tag_tuple_equal(cJSON* a, cJSON* b);
+int tags_contains_tuple(cJSON* tags, cJSON* tuple);
+int remove_matching_tag_tuples(cJSON* tags, cJSON* tuple);
+char* repair_json_control_chars(const char* in);
+cJSON* parse_loose_nostr_post_args(const char* in);
+int build_tool_path(tools_context_t* ctx, const char* rel, char* out, size_t out_size);
+
+// ─── Per-tool-file execute functions ───
+
+// tool_nostr_post.c
+char* execute_nostr_post(const char* args_json);
+char* execute_nostr_post_readme(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_file_md_to_longform_post(tools_context_t* ctx, const char* args_json);
+
+// tool_nostr_query.c
+char* execute_nostr_query(const char* args_json);
+
+// tool_nostr_identity.c
+char* execute_nostr_pubkey(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_npub(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_encode(const char* args_json);
+char* execute_nostr_decode(const char* args_json);
+
+// tool_nostr_social.c
+char* execute_nostr_react(const char* args_json);
+char* execute_nostr_profile_get(const char* args_json);
+char* execute_nostr_nip05_lookup(const char* args_json);
+
+// tool_nostr_dm.c
+char* execute_nostr_dm_send(const char* args_json);
+char* execute_nostr_dm_send_nip17(const char* args_json);
+char* execute_nostr_encrypt(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_decrypt(tools_context_t* ctx, const char* args_json);
+
+// tool_nostr_relay.c
+char* execute_nostr_relay_status(const char* args_json);
+char* execute_nostr_relay_info(const char* args_json);
+
+// tool_nostr_list.c
+char* execute_nostr_list_manage(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_delete(const char* args_json);
+
+// tool_skill.c
+char* execute_skill_create(tools_context_t* ctx, const char* args_json);
+char* execute_skill_list(tools_context_t* ctx, const char* args_json);
+char* execute_skill_adopt(tools_context_t* ctx, const char* args_json);
+char* execute_skill_remove(tools_context_t* ctx, const char* args_json);
+char* execute_skill_edit(tools_context_t* ctx, const char* args_json);
+char* execute_skill_search(const char* args_json);
+
+// tool_task.c
+char* execute_task_list(tools_context_t* ctx, const char* args_json);
+char* execute_task_manage(tools_context_t* ctx, const char* args_json);
+
+// tool_local.c
+char* execute_local_http_fetch(tools_context_t* ctx, const char* args_json);
+char* execute_local_shell_exec(tools_context_t* ctx, const char* args_json);
+char* execute_local_file_read(tools_context_t* ctx, const char* args_json);
+char* execute_local_file_write(tools_context_t* ctx, const char* args_json);
+
+// tool_admin.c
+char* execute_admin_identity(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_admin_profile(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_admin_contacts(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_admin_relays(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_admin_notes(tools_context_t* ctx, const char* args_json);
+
+// tool_agent.c
+char* execute_agent_identity(tools_context_t* ctx, const char* args_json);
+char* execute_agent_version(const char* args_json);
+char* execute_message_current(tools_context_t* ctx, const char* args_json);
+
+// tool_model.c
+char* execute_model_get(const char* args_json);
+char* execute_model_set(tools_context_t* ctx, const char* args_json);
+char* execute_model_list(const char* args_json);
+
+// tool_meta.c
+char* execute_tool_list(tools_context_t* ctx, const char* args_json);
+char* execute_trigger_list(tools_context_t* ctx, const char* args_json);
+
+#endif
+```
+
+## Makefile Changes
+
+Replace the single `$(SRC_DIR)/tools.c` entry with:
+
+```makefile
+SRCS = \
+	$(SRC_DIR)/main.c \
+	$(SRC_DIR)/config.c \
+	$(SRC_DIR)/context.c \
+	$(SRC_DIR)/llm.c \
+	$(SRC_DIR)/nostr_handler.c \
+	$(SRC_DIR)/agent.c \
+	$(SRC_DIR)/tools_common.c \
+	$(SRC_DIR)/tools_schema.c \
+	$(SRC_DIR)/tools_dispatch.c \
+	$(SRC_DIR)/tools/tool_nostr_post.c \
+	$(SRC_DIR)/tools/tool_nostr_query.c \
+	$(SRC_DIR)/tools/tool_nostr_identity.c \
+	$(SRC_DIR)/tools/tool_nostr_social.c \
+	$(SRC_DIR)/tools/tool_nostr_dm.c \
+	$(SRC_DIR)/tools/tool_nostr_relay.c \
+	$(SRC_DIR)/tools/tool_nostr_list.c \
+	$(SRC_DIR)/tools/tool_skill.c \
+	$(SRC_DIR)/tools/tool_task.c \
+	$(SRC_DIR)/tools/tool_local.c \
+	$(SRC_DIR)/tools/tool_admin.c \
+	$(SRC_DIR)/tools/tool_agent.c \
+	$(SRC_DIR)/tools/tool_model.c \
+	$(SRC_DIR)/tools/tool_meta.c \
+	$(SRC_DIR)/trigger_manager.c \
+	$(SRC_DIR)/prompt_template.c \
+	$(SRC_DIR)/http_api.c \
+	$(SRC_DIR)/mongoose.c \
+	$(SRC_DIR)/debug.c
+```
+
+## Implementation Steps
+
+### Phase 1: Create shared infrastructure
+
+- [ ] Create `src/tools_internal.h` with shared helper declarations and all `execute_*` prototypes
+- [ ] Create `src/tools_common.c` — move shared helpers from `tools.c`, remove `static`, add `#include "tools_internal.h"`
+- [ ] Create `src/tools_schema.c` — move `tools_build_openai_schema_json()` from `tools.c`
+- [ ] Create `src/tools_dispatch.c` — move `tools_init()`, `tools_cleanup()`, `tools_execute()` from `tools.c`
+- [ ] Update `Makefile` SRCS to include new files (keep `tools.c` temporarily with remaining functions)
+- [ ] Build and verify — all tests pass, binary runs
+
+### Phase 2: Extract tool files one at a time
+
+Each step: move `execute_*` functions + their local helpers into the new file, remove from `tools.c`, build, verify.
+
+- [ ] Create `src/tools/` directory
+- [ ] Extract `src/tools/tool_nostr_post.c` — `execute_nostr_post`, `execute_nostr_post_readme`, `execute_nostr_file_md_to_longform_post` + local helpers: `d_tagify_string`, `first_markdown_h1`, `first_markdown_paragraph`, `trim_copy`, `auto_enrich_longform_tags`, `basename_lowercase_dup`
+- [ ] Extract `src/tools/tool_nostr_query.c` — `execute_nostr_query`
+- [ ] Extract `src/tools/tool_nostr_identity.c` — `execute_nostr_pubkey`, `execute_nostr_npub`, `execute_nostr_encode`, `execute_nostr_decode`
+- [ ] Extract `src/tools/tool_nostr_social.c` — `execute_nostr_react`, `execute_nostr_profile_get`, `execute_nostr_nip05_lookup`
+- [ ] Extract `src/tools/tool_nostr_dm.c` — `execute_nostr_dm_send`, `execute_nostr_dm_send_nip17`, `execute_nostr_encrypt`, `execute_nostr_decrypt`
+- [ ] Extract `src/tools/tool_nostr_relay.c` — `execute_nostr_relay_status`, `execute_nostr_relay_info`
+- [ ] Extract `src/tools/tool_nostr_list.c` — `execute_nostr_list_manage`, `execute_nostr_delete`
+- [ ] Extract `src/tools/tool_skill.c` — `execute_skill_create`, `execute_skill_list`, `execute_skill_adopt`, `execute_skill_remove`, `execute_skill_edit`, `execute_skill_search` + local helpers: `validate_skill_d_tag`, `ci_contains`, `fetch_adoption_list_tags`, `publish_adoption_list`, `adoption_tags_contains_address`, `extract_skill_summary`
+- [ ] Extract `src/tools/tool_task.c` — `execute_task_list`, `execute_task_manage`
+- [ ] Extract `src/tools/tool_local.c` — `execute_local_http_fetch`, `execute_local_shell_exec`, `execute_local_file_read`, `execute_local_file_write` + local helpers: `detect_ca_bundle_path_for_tools`, `local_http_fetch_write_cb`, `free_string_array_heap`
+- [ ] Extract `src/tools/tool_admin.c` — `execute_admin_identity`, `execute_nostr_admin_profile`, `execute_nostr_admin_contacts`, `execute_nostr_admin_relays`, `execute_nostr_admin_notes`
+- [ ] Extract `src/tools/tool_agent.c` — `execute_agent_identity`, `execute_agent_version`, `execute_message_current`
+- [ ] Extract `src/tools/tool_model.c` — `execute_model_get`, `execute_model_set`, `execute_model_list` + local helper: `persist_llm_config`
+- [ ] Extract `src/tools/tool_meta.c` — `execute_tool_list`, `execute_trigger_list`
+
+### Phase 3: Cleanup
+
+- [ ] Delete `src/tools.c` (now empty — all code moved)
+- [ ] Remove `src/tools.c` from Makefile SRCS
+- [ ] Final build + full test run
+- [ ] Verify binary size is comparable (no accidental code duplication)
+- [ ] Increment version and push
+
+## Validation Criteria
+
+After each extraction step:
+1. `make -j4` compiles with zero warnings
+2. `./didactyl --debug 5` starts and runs normally
+3. Tool execution via DM or `--test-tool` produces identical results
+
+## Risk Mitigation
+
+- **Build after every file extraction** — catch issues immediately
+- **No logic changes** — purely mechanical code movement
+- **Keep `tools.h` unchanged** — zero impact on callers (`agent.c`, `http_api.c`, `main.c`)
+- **Git commit after each phase** — easy rollback points

plans/triggered_skills.md

@@ -0,0 +1,203 @@
+# Triggered Skills — Implementation Plan
+
+## Overview
+
+Extend the existing skill system so that skills can carry Nostr subscription triggers. When matching events arrive, didactyl executes the skill automatically — either via template interpolation (fast, no LLM) or LLM-mediated reasoning (full agent loop).
+
+See [docs/TOOLS_AND_SKILLS.md](../docs/TOOLS_AND_SKILLS.md) for the full architecture.
+
+---
+
+## Implementation Steps
+
+### 1. Trigger Manager Module
+
+Create `src/trigger_manager.c` and `src/trigger_manager.h` — the core component that manages dynamic Nostr subscriptions tied to skills.
+
+**Data structures:**
+
+```c
+#define TRIGGER_MAX_ACTIVE 16
+#define TRIGGER_COOLDOWN_SECONDS 60
+
+typedef struct {
+    char skill_d_tag[65];
+    char skill_content[4096];   // the action template or LLM prompt
+    int action_type;            // 0 = llm, 1 = template
+    char filter_json[2048];     // the Nostr subscription filter
+    int enabled;
+    time_t last_fired;
+    nostr_pool_subscription_t* subscription;
+} active_trigger_t;
+
+typedef struct {
+    active_trigger_t triggers[TRIGGER_MAX_ACTIVE];
+    int count;
+    didactyl_config_t* cfg;
+    pthread_mutex_t mutex;
+} trigger_manager_t;
+```
+
+**API:**
+
+```c
+int trigger_manager_init(trigger_manager_t* mgr, didactyl_config_t* cfg);
+int trigger_manager_load_from_skills(trigger_manager_t* mgr);
+int trigger_manager_add(trigger_manager_t* mgr, const char* skill_d_tag, 
+                        const char* content, const char* filter_json, 
+                        int action_type, int enabled);
+int trigger_manager_remove(trigger_manager_t* mgr, const char* skill_d_tag);
+int trigger_manager_update(trigger_manager_t* mgr, const char* skill_d_tag,
+                           const char* content, const char* filter_json,
+                           int action_type, int enabled);
+int trigger_manager_active_count(trigger_manager_t* mgr);
+char* trigger_manager_status_json(trigger_manager_t* mgr);
+void trigger_manager_cleanup(trigger_manager_t* mgr);
+```
+
+### 2. Template Engine
+
+Create a simple template interpolation engine in `src/trigger_manager.c` (or a separate `src/template.c` if it grows).
+
+**Functionality:**
+- Parse placeholders like `{content}`, `{pubkey}`, `{author_display_name}` from a template string
+- Extract values from a triggering Nostr event (cJSON object)
+- Produce an interpolated output string
+- Parse action prefixes: `DM admin:`, `DM <pubkey>:`, `POST:`, `LOG:`
+
+### 3. Trigger Event Callback
+
+When a subscribed event arrives:
+
+```c
+static void on_trigger_event(cJSON* event, const char* relay_url, void* user_data) {
+    active_trigger_t* trigger = (active_trigger_t*)user_data;
+    
+    // Check cooldown
+    if (time(NULL) - trigger->last_fired < TRIGGER_COOLDOWN_SECONDS) return;
+    trigger->last_fired = time(NULL);
+    
+    if (trigger->action_type == 1) {
+        // Template: interpolate and execute
+        char* output = template_interpolate(trigger->skill_content, event);
+        template_execute_action(output);  // parse prefix, DM/POST/LOG
+        free(output);
+    } else {
+        // LLM: build context and run agent loop
+        trigger_run_llm_action(trigger, event, relay_url);
+    }
+}
+```
+
+### 4. Skill Loading on Startup
+
+In `main.c`, after `agent_init()` and skill adoption list is available:
+
+1. Query own kind 10123 adoption list
+2. For each adopted skill address, query the skill event
+3. Check for `trigger` tag — if present, extract `filter`, `action`, `enabled` tags
+4. Register with trigger manager
+5. Trigger manager creates Nostr subscriptions
+
+### 5. Extend skill_create for Live Trigger Registration
+
+When `skill_create` is called with trigger tags:
+1. Publish the skill event as normal
+2. If trigger tags are present, also register with the trigger manager immediately
+3. No restart required — the subscription goes live right away
+
+When `skill_remove` is called for a triggered skill:
+1. Remove from adoption list as normal
+2. Also unregister from trigger manager, tearing down the subscription
+
+### 6. Extend Agent for Trigger-Initiated Conversations
+
+The agent currently only handles DM-initiated conversations via `agent_on_message()`. Add a new entry point:
+
+```c
+void agent_on_trigger(const char* skill_d_tag,
+                      const char* skill_content,
+                      cJSON* triggering_event,
+                      const char* relay_url);
+```
+
+This builds an LLM conversation with:
+- System context (soul)
+- A system message explaining this is a triggered skill execution
+- The skill content as instructions
+- The triggering event as user context
+- Full tool access (same as admin tier)
+
+The LLM response actions (DMs, posts, etc.) are executed via tools as normal.
+
+### 7. New Tool: trigger_list
+
+Add a tool so the LLM can inspect active triggers:
+
+```json
+{
+  "name": "trigger_list",
+  "description": "List all active triggered skills with their filters and status",
+  "parameters": { "type": "object", "properties": {} }
+}
+```
+
+### 8. Config Extension
+
+Add trigger-related limits to config:
+
+```json
+{
+  "triggers": {
+    "enabled": true,
+    "max_active": 16,
+    "cooldown_seconds": 60,
+    "llm_rate_limit_per_minute": 10,
+    "template_rate_limit_per_minute": 60
+  }
+}
+```
+
+### 9. Integration into Main Loop
+
+The trigger manager subscriptions are serviced by the same `nostr_handler_poll()` call in the main loop — no changes needed to the poll loop itself, since all subscriptions share the relay pool.
+
+---
+
+## File Changes Summary
+
+| File | Change |
+|---|---|
+| `src/trigger_manager.c` | **NEW** — trigger manager, template engine, event callbacks |
+| `src/trigger_manager.h` | **NEW** — trigger manager API |
+| `src/main.c` | Add trigger_manager_init, trigger_manager_load_from_skills after agent_init |
+| `src/agent.c` | Add agent_on_trigger entry point for LLM-mediated trigger actions |
+| `src/agent.h` | Declare agent_on_trigger |
+| `src/tools.c` | Extend skill_create/skill_remove to register/unregister triggers; add trigger_list tool |
+| `src/config.h` | Add triggers_config_t struct |
+| `src/config.c` | Parse triggers config section |
+| `docs/TOOLS_AND_SKILLS.md` | Already written — full architecture reference |
+
+---
+
+## Implementation Order
+
+1. `trigger_manager.h` / `trigger_manager.c` — core module with data structures and API stubs
+2. Template engine — interpolation and action prefix parsing
+3. Trigger event callback — on_trigger_event with cooldown
+4. Startup loading — query adoption list, find triggered skills, create subscriptions
+5. agent_on_trigger — LLM-mediated trigger execution path
+6. Live registration — extend skill_create/skill_remove for immediate trigger management
+7. trigger_list tool — LLM visibility into active triggers
+8. Config parsing — triggers section with limits
+9. Rate limiting — enforce LLM and template rate limits
+10. Testing — manual trigger creation and verification
+
+---
+
+## Dependencies
+
+- Existing `nostr_handler_query_json()` for loading skills
+- Existing `nostr_relay_pool_subscribe()` for creating trigger subscriptions
+- Existing `agent_on_message()` pattern for the LLM-mediated path
+- Existing `skill_create` / `skill_remove` tools for lifecycle hooks

plans/unified_prompt_context.md

@@ -0,0 +1,158 @@
+# Plan: Unified Prompt Context for HTTP API and Nostr Paths
+
+## Problem
+
+The agent produces completely different LLM context depending on whether a message arrives via **Nostr DM** or the **HTTP API CLI chat app**.
+
+### Nostr Path (working correctly)
+- `agent_on_message()` → `agent_build_admin_messages_json()` → tool loop
+- Builds **18 sections, ~8224 bytes** of context including:
+  - System prompt / personality (from soul template)
+  - Agent identity (pubkey)
+  - Sender verification (admin tier)
+  - Admin context (kind 0 profile, relay list, recent posts)
+  - Startup events memory
+  - Adopted skills
+  - DM history (decrypted from Nostr relays)
+  - Current user message
+
+### HTTP API Path (broken)
+- CLI sends `{messages: [{role: "user", content: "Hello"}]}` to `/api/prompt/run`
+- `run_prompt_with_tools()` passes these raw messages directly to the LLM
+- Result: **1 section, ~35 bytes** — just the bare user message, zero agent context
+
+## Solution: New `POST /api/prompt/agent` Endpoint
+
+Add a new endpoint that mirrors the Nostr path's context assembly, so the CLI gets the same full agent context.
+
+### Architecture
+
+```mermaid
+flowchart TD
+    A[Nostr DM arrives] --> B[agent_on_message]
+    B --> C[agent_build_admin_messages_json]
+    C --> D[Append user message]
+    D --> E[Tool loop with llm_chat_with_tools_messages]
+    E --> F[Send DM reply]
+
+    G[CLI sends POST /api/prompt/agent] --> H[handle_prompt_agent]
+    H --> C
+    C --> I[Append user message]
+    I --> J[Tool loop - same as run_prompt_with_tools but with context]
+    J --> K[Return JSON response]
+
+    style C fill:#4a9,stroke:#333,color:#fff
+```
+
+Both paths share `agent_build_admin_messages_json()` as the single source of truth for context assembly.
+
+### Request Format
+
+```json
+{
+  "message": "What is the capital of France?",
+  "model": "claude-haiku-4.5",
+  "max_turns": 4
+}
+```
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `message` | string | yes | The user message to send to the agent |
+| `model` | string | no | Override the configured LLM model for this request |
+| `max_turns` | int | no | Max tool-use turns, default 4, max 16 |
+
+### Response Format
+
+Same as existing `/api/prompt/run`:
+
+```json
+{
+  "success": true,
+  "final_response": "The capital of France is Paris.",
+  "turns": [...],
+  "model_used": "claude-haiku-4.5",
+  "total_input_tokens_estimate": 1973,
+  "total_output_tokens_estimate": 12
+}
+```
+
+## Implementation Steps
+
+### 1. Add `handle_prompt_agent()` in `src/http_api.c`
+
+New function that:
+1. Parses the JSON body to extract `message`, optional `model`, optional `max_turns`
+2. Applies model override if present via `maybe_model_override_begin()`
+3. Calls `agent_build_admin_messages_json(message, DIDACTYL_SENDER_ADMIN, &base_messages_json)` — same call the Nostr path uses
+4. Parses the result into a cJSON array
+5. Appends `{role: "user", content: message}` to the array — same as `agent_on_message()` does at line 1916
+6. Builds tool schema via `tools_build_openai_schema_json()`
+7. Runs the same tool loop as `run_prompt_with_tools()` but using the context-enriched messages
+8. Logs context via `agent_append_context_log("http_api_agent", "llm_chat_with_tools_messages", messages_json)`
+9. Returns the same response format as `/api/prompt/run`
+
+Key reference points in existing code:
+- Context building: `agent_build_admin_messages_json()` at `src/agent.c:1737`
+- User message append: `append_simple_message()` pattern at `src/agent.c:1916`
+- Tool loop: reuse the loop logic from `run_prompt_with_tools()` at `src/http_api.c:278-345`
+- Context logging: `agent_append_context_log()` at `src/agent.c:1932`
+
+### 2. Register the Route in `http_handler()`
+
+Add before the existing `/api/prompt/run` route at `src/http_api.c:648`:
+
+```c
+if (method_is(hm, "POST") && mg_match(hm->uri, mg_str("/api/prompt/agent"), NULL)) {
+    handle_prompt_agent(c, hm);
+    return;
+}
+```
+
+### 3. Update `chat-didactyl-cli.js`
+
+Change the CLI to call the new endpoint:
+
+- Change `callDidactyl()` to POST to `/api/prompt/agent` instead of `/api/prompt/run`
+- Send `{message: "user text", max_turns: N}` instead of `{messages: [...], max_turns: N}`
+- The CLI no longer needs to maintain a `transcript` array for context — the server handles DM history from Nostr relays
+- Keep the transcript for local display purposes only
+
+### 4. Context Logging Parity
+
+Use a distinct but parallel phase label:
+- Nostr path: `llm_chat_with_tools_messages` (existing)
+- HTTP API agent path: `llm_chat_with_tools_messages_agent_api` (new)
+- HTTP API raw path: `llm_chat_with_tools_messages_http_api` (existing, unchanged)
+
+This lets you distinguish the source in `context.log.md` while confirming the context structure is identical.
+
+### 5. Update `docs/API.md`
+
+Add documentation for the new `POST /api/prompt/agent` endpoint following the existing documentation style.
+
+## Files to Modify
+
+| File | Change |
+|---|---|
+| `src/http_api.c` | Add `handle_prompt_agent()` function and route registration |
+| `chat-didactyl-cli.js` | Switch to `/api/prompt/agent`, simplify payload |
+| `docs/API.md` | Document new endpoint |
+
+## What Stays the Same
+
+- `/api/prompt/run` — unchanged, still accepts raw message arrays for custom/advanced use
+- `/api/prompt/run-simple` — unchanged
+- `/api/context/current` and `/api/context/parts` — unchanged
+- `agent_build_admin_messages_json()` — unchanged, already does exactly what we need
+- Nostr message handling — unchanged
+
+## Remaining Consideration: Conversation History
+
+The Nostr path gets DM history by querying encrypted kind-4 events from relays. The new `/api/prompt/agent` endpoint will include this same history since it calls `agent_build_admin_messages_json()`. This means:
+
+- Messages sent via the CLI will NOT appear in the Nostr DM history (they are not published as Nostr events)
+- Messages sent via Nostr WILL appear in the context when using the CLI
+- This is acceptable — the CLI is a development/admin tool that piggybacks on the agent's full context
+
+If in the future you want CLI messages to also appear in history, that would require either publishing them as Nostr DMs or maintaining a separate local history store — but that is out of scope for this change.

src/agent.h

@@ -2,9 +2,28 @@
 #define OPEN_WING_AGENT_H
 
 #include "config.h"
+#include "nostr_handler.h"
+#include "cjson/cJSON.h"
+#include "tools.h"
+
+struct trigger_manager;
 
 int agent_init(didactyl_config_t* config, const char* system_context);
-void agent_on_message(const char* sender_pubkey_hex, const char* message, void* user_data);
+void agent_set_trigger_manager(struct trigger_manager* trigger_manager);
+void agent_on_trigger(const char* skill_d_tag,
+                      const char* skill_content,
+                      cJSON* triggering_event,
+                      const char* relay_url);
+void agent_on_message(const char* sender_pubkey_hex,
+                      const char* message,
+                      didactyl_sender_tier_t tier,
+                      void* user_data);
+int agent_build_admin_messages_json(const char* current_user_message,
+                                    didactyl_sender_tier_t sender_tier,
+                                    char** out_messages_json);
+tools_context_t* agent_tools_context(void);
+const char* agent_classify_message_part(cJSON* msg, int idx);
+void agent_append_context_log(const char* sender_pubkey_hex, const char* phase, const char* context_payload);
 void agent_cleanup(void);
 
 #endif

src/config.c

@@ -3,6 +3,8 @@
 #include "config.h"
 
 #include <ctype.h>
+#include <errno.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -10,6 +12,101 @@
 #include "cjson/cJSON.h"
 #include "../../nostr_core_lib/nostr_core/nostr_core.h"
 
+/* ---------------------------------------------------------------------------
+ * jsonc_strip_comments  –  strip JSONC comments from a buffer
+ *
+ * Returns a newly malloc'd string containing valid JSON (caller must free).
+ * The function is careful to skip over JSON string literals so that comment
+ * characters inside strings are preserved.  Handles:
+ *   - single-line comments   //  (to end of line)
+ *   - block comments         (slash-star ... star-slash, may span lines)
+ *   - escaped quotes inside strings  \"
+ *   - trailing commas before ] or } are NOT removed (cJSON tolerates them)
+ *
+ * Returns NULL on allocation failure.
+ * ------------------------------------------------------------------------ */
+char* jsonc_strip_comments(const char* src, size_t src_len) {
+    if (!src || src_len == 0) {
+        char* empty = (char*)malloc(1);
+        if (empty) empty[0] = '\0';
+        return empty;
+    }
+
+    char* out = (char*)malloc(src_len + 1);
+    if (!out) return NULL;
+
+    size_t o = 0;
+    size_t i = 0;
+
+    while (i < src_len) {
+        /* Inside a JSON string literal — copy verbatim until closing quote */
+        if (src[i] == '"') {
+            out[o++] = src[i++];                       /* opening quote */
+            while (i < src_len) {
+                if (src[i] == '\\' && i + 1 < src_len) {
+                    out[o++] = src[i++];               /* backslash */
+                    out[o++] = src[i++];               /* escaped char */
+                } else if (src[i] == '"') {
+                    out[o++] = src[i++];               /* closing quote */
+                    break;
+                } else {
+                    out[o++] = src[i++];
+                }
+            }
+            continue;
+        }
+
+        /* Single-line comment  //  */
+        if (src[i] == '/' && i + 1 < src_len && src[i + 1] == '/') {
+            /* skip to end of line */
+            i += 2;
+            while (i < src_len && src[i] != '\n') {
+                i++;
+            }
+            /* preserve the newline so line numbers stay meaningful */
+            if (i < src_len) {
+                out[o++] = src[i++];                   /* the \n */
+            }
+            continue;
+        }
+
+        /* Block comment (slash-star ... star-slash) */
+        if (src[i] == '/' && i + 1 < src_len && src[i + 1] == '*') {
+            i += 2;
+            while (i + 1 < src_len && !(src[i] == '*' && src[i + 1] == '/')) {
+                /* preserve newlines inside block comments */
+                if (src[i] == '\n') {
+                    out[o++] = '\n';
+                }
+                i++;
+            }
+            if (i + 1 < src_len) {
+                i += 2;                                /* skip closing */
+            }
+            continue;
+        }
+
+        /* Normal character — copy through */
+        out[o++] = src[i++];
+    }
+
+    out[o] = '\0';
+    return out;
+}
+
+static char g_config_last_error[512] = {0};
+
+static void config_set_error(const char* fmt, ...) {
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(g_config_last_error, sizeof(g_config_last_error), fmt ? fmt : "unknown configuration error", ap);
+    va_end(ap);
+}
+
+const char* config_last_error(void) {
+    return g_config_last_error[0] != '\0' ? g_config_last_error : "unknown configuration error";
+}
+
 static int read_file_to_buffer(const char* path, char** out_buf, size_t* out_len) {
     FILE* fp = fopen(path, "rb");
     if (!fp) {
@@ -125,12 +222,36 @@ static int parse_tools_config(cJSON* root, didactyl_config_t* config) {
 
     cJSON* enabled = cJSON_GetObjectItemCaseSensitive(tools, "enabled");
     cJSON* max_turns = cJSON_GetObjectItemCaseSensitive(tools, "max_turns");
+    cJSON* trigger_max_turns = cJSON_GetObjectItemCaseSensitive(tools, "trigger_max_turns");
+    cJSON* api_default_max_turns = cJSON_GetObjectItemCaseSensitive(tools, "api_default_max_turns");
+    cJSON* api_max_turns_ceiling = cJSON_GetObjectItemCaseSensitive(tools, "api_max_turns_ceiling");
+    cJSON* local_http_fetch_default_timeout_seconds =
+        cJSON_GetObjectItemCaseSensitive(tools, "local_http_fetch_default_timeout_seconds");
+    cJSON* local_http_fetch_max_timeout_seconds =
+        cJSON_GetObjectItemCaseSensitive(tools, "local_http_fetch_max_timeout_seconds");
     if (enabled && cJSON_IsBool(enabled)) {
         config->tools.enabled = cJSON_IsTrue(enabled) ? 1 : 0;
     }
     if (max_turns && cJSON_IsNumber(max_turns)) {
         config->tools.max_turns = (int)max_turns->valuedouble;
     }
+    if (trigger_max_turns && cJSON_IsNumber(trigger_max_turns)) {
+        config->tools.trigger_max_turns = (int)trigger_max_turns->valuedouble;
+    }
+    if (api_default_max_turns && cJSON_IsNumber(api_default_max_turns)) {
+        config->tools.api_default_max_turns = (int)api_default_max_turns->valuedouble;
+    }
+    if (api_max_turns_ceiling && cJSON_IsNumber(api_max_turns_ceiling)) {
+        config->tools.api_max_turns_ceiling = (int)api_max_turns_ceiling->valuedouble;
+    }
+    if (local_http_fetch_default_timeout_seconds && cJSON_IsNumber(local_http_fetch_default_timeout_seconds)) {
+        config->tools.local_http_fetch_default_timeout_seconds =
+            (int)local_http_fetch_default_timeout_seconds->valuedouble;
+    }
+    if (local_http_fetch_max_timeout_seconds && cJSON_IsNumber(local_http_fetch_max_timeout_seconds)) {
+        config->tools.local_http_fetch_max_timeout_seconds =
+            (int)local_http_fetch_max_timeout_seconds->valuedouble;
+    }
 
     cJSON* shell = cJSON_GetObjectItemCaseSensitive(tools, "shell");
     if (!shell || !cJSON_IsObject(shell)) {
@@ -158,42 +279,485 @@ static int parse_tools_config(cJSON* root, didactyl_config_t* config) {
         return -1;
     }
 
+    if (config->tools.max_turns < 1) {
+        config->tools.max_turns = 8;
+    }
+    if (config->tools.trigger_max_turns < 1) {
+        config->tools.trigger_max_turns = config->tools.max_turns;
+    }
+    if (config->tools.api_default_max_turns < 1) {
+        config->tools.api_default_max_turns = config->tools.max_turns;
+    }
+    if (config->tools.api_max_turns_ceiling < 1) {
+        config->tools.api_max_turns_ceiling = 16;
+    }
+    if (config->tools.api_default_max_turns > config->tools.api_max_turns_ceiling) {
+        config->tools.api_default_max_turns = config->tools.api_max_turns_ceiling;
+    }
+    if (config->tools.local_http_fetch_default_timeout_seconds < 1) {
+        config->tools.local_http_fetch_default_timeout_seconds = 20;
+    }
+    if (config->tools.local_http_fetch_max_timeout_seconds < 1) {
+        config->tools.local_http_fetch_max_timeout_seconds = 120;
+    }
+    if (config->tools.local_http_fetch_default_timeout_seconds > config->tools.local_http_fetch_max_timeout_seconds) {
+        config->tools.local_http_fetch_default_timeout_seconds = config->tools.local_http_fetch_max_timeout_seconds;
+    }
+
     return 0;
 }
 
-static int parse_relays(cJSON* root, didactyl_config_t* config) {
-    cJSON* relays = cJSON_GetObjectItemCaseSensitive(root, "relays");
-    if (!relays || !cJSON_IsArray(relays)) {
+static int parse_security_config(cJSON* root, didactyl_config_t* config) {
+    cJSON* security = cJSON_GetObjectItemCaseSensitive(root, "security");
+    if (!security || !cJSON_IsObject(security)) {
+        return 0;
+    }
+
+    cJSON* verify_signatures = cJSON_GetObjectItemCaseSensitive(security, "verify_signatures");
+    if (verify_signatures && cJSON_IsBool(verify_signatures)) {
+        config->security.verify_signatures = cJSON_IsTrue(verify_signatures) ? 1 : 0;
+    }
+
+    if (copy_json_string(security,
+                         "stranger_response",
+                         config->security.stranger_response,
+                         sizeof(config->security.stranger_response),
+                         0) != 0) {
         return -1;
     }
 
-    int count = cJSON_GetArraySize(relays);
-    if (count <= 0) {
-        return -1;
+    cJSON* tiers = cJSON_GetObjectItemCaseSensitive(security, "tiers");
+    if (!tiers || !cJSON_IsObject(tiers)) {
+        return 0;
     }
 
-    config->relays = (char**)calloc((size_t)count, sizeof(char*));
-    if (!config->relays) {
-        return -1;
-    }
-
-    config->relay_count = count;
-
-    for (int i = 0; i < count; i++) {
-        cJSON* relay = cJSON_GetArrayItem(relays, i);
-        if (!relay || !cJSON_IsString(relay) || !relay->valuestring || relay->valuestring[0] == '\0') {
-            return -1;
+    cJSON* admin_tier = cJSON_GetObjectItemCaseSensitive(tiers, "admin");
+    if (admin_tier && cJSON_IsObject(admin_tier)) {
+        cJSON* tools_enabled = cJSON_GetObjectItemCaseSensitive(admin_tier, "tools_enabled");
+        if (tools_enabled && cJSON_IsBool(tools_enabled)) {
+            config->security.admin.tools_enabled = cJSON_IsTrue(tools_enabled) ? 1 : 0;
         }
+    }
 
-        config->relays[i] = strdup(relay->valuestring);
-        if (!config->relays[i]) {
-            return -1;
+    cJSON* wot_tier = cJSON_GetObjectItemCaseSensitive(tiers, "wot");
+    if (wot_tier && cJSON_IsObject(wot_tier)) {
+        cJSON* enabled = cJSON_GetObjectItemCaseSensitive(wot_tier, "enabled");
+        cJSON* tools_enabled = cJSON_GetObjectItemCaseSensitive(wot_tier, "tools_enabled");
+        if (enabled && cJSON_IsBool(enabled)) {
+            config->security.wot.enabled = cJSON_IsTrue(enabled) ? 1 : 0;
+        }
+        if (tools_enabled && cJSON_IsBool(tools_enabled)) {
+            config->security.wot.tools_enabled = cJSON_IsTrue(tools_enabled) ? 1 : 0;
+        }
+    }
+
+    cJSON* stranger_tier = cJSON_GetObjectItemCaseSensitive(tiers, "stranger");
+    if (stranger_tier && cJSON_IsObject(stranger_tier)) {
+        cJSON* enabled = cJSON_GetObjectItemCaseSensitive(stranger_tier, "enabled");
+        if (enabled && cJSON_IsBool(enabled)) {
+            config->security.stranger.enabled = cJSON_IsTrue(enabled) ? 1 : 0;
         }
     }
 
     return 0;
 }
 
+static int parse_admin_context_config(cJSON* root, didactyl_config_t* config) {
+    cJSON* admin_context = cJSON_GetObjectItemCaseSensitive(root, "admin_context");
+    if (!admin_context || !cJSON_IsObject(admin_context)) {
+        return 0;
+    }
+
+    cJSON* enabled = cJSON_GetObjectItemCaseSensitive(admin_context, "enabled");
+    if (enabled && cJSON_IsBool(enabled)) {
+        config->admin_context.enabled = cJSON_IsTrue(enabled) ? 1 : 0;
+    }
+
+    cJSON* kind_1_limit = cJSON_GetObjectItemCaseSensitive(admin_context, "kind_1_limit");
+    if (kind_1_limit && cJSON_IsNumber(kind_1_limit)) {
+        config->admin_context.kind_1_limit = (int)kind_1_limit->valuedouble;
+    }
+
+    cJSON* subscribe_kinds = cJSON_GetObjectItemCaseSensitive(admin_context, "subscribe_kinds");
+    if (subscribe_kinds && cJSON_IsArray(subscribe_kinds)) {
+        config->admin_context.track_kind_0 = 0;
+        config->admin_context.track_kind_3 = 0;
+        config->admin_context.track_kind_10002 = 0;
+        config->admin_context.track_kind_1 = 0;
+
+        int n = cJSON_GetArraySize(subscribe_kinds);
+        for (int i = 0; i < n; i++) {
+            cJSON* k = cJSON_GetArrayItem(subscribe_kinds, i);
+            if (!k || !cJSON_IsNumber(k)) {
+                continue;
+            }
+            int kind = (int)k->valuedouble;
+            if (kind == 0) config->admin_context.track_kind_0 = 1;
+            else if (kind == 3) config->admin_context.track_kind_3 = 1;
+            else if (kind == 10002) config->admin_context.track_kind_10002 = 1;
+            else if (kind == 1) config->admin_context.track_kind_1 = 1;
+        }
+    }
+
+    return 0;
+}
+
+static int parse_triggers_config(cJSON* root, didactyl_config_t* config) {
+    cJSON* triggers = cJSON_GetObjectItemCaseSensitive(root, "triggers");
+    if (!triggers || !cJSON_IsObject(triggers)) {
+        return 0;
+    }
+
+    cJSON* enabled = cJSON_GetObjectItemCaseSensitive(triggers, "enabled");
+    cJSON* max_active = cJSON_GetObjectItemCaseSensitive(triggers, "max_active");
+    cJSON* cooldown_seconds = cJSON_GetObjectItemCaseSensitive(triggers, "cooldown_seconds");
+    cJSON* llm_rate_limit = cJSON_GetObjectItemCaseSensitive(triggers, "llm_rate_limit_per_minute");
+    cJSON* template_rate_limit = cJSON_GetObjectItemCaseSensitive(triggers, "template_rate_limit_per_minute");
+
+    if (enabled && cJSON_IsBool(enabled)) {
+        config->triggers.enabled = cJSON_IsTrue(enabled) ? 1 : 0;
+    }
+    if (max_active && cJSON_IsNumber(max_active)) {
+        config->triggers.max_active = (int)max_active->valuedouble;
+    }
+    if (cooldown_seconds && cJSON_IsNumber(cooldown_seconds)) {
+        config->triggers.cooldown_seconds = (int)cooldown_seconds->valuedouble;
+    }
+    if (llm_rate_limit && cJSON_IsNumber(llm_rate_limit)) {
+        config->triggers.llm_rate_limit_per_minute = (int)llm_rate_limit->valuedouble;
+    }
+    if (template_rate_limit && cJSON_IsNumber(template_rate_limit)) {
+        config->triggers.template_rate_limit_per_minute = (int)template_rate_limit->valuedouble;
+    }
+
+    if (config->triggers.max_active < 1) {
+        config->triggers.max_active = 1;
+    }
+    if (config->triggers.cooldown_seconds < 0) {
+        config->triggers.cooldown_seconds = 0;
+    }
+    if (config->triggers.llm_rate_limit_per_minute < 1) {
+        config->triggers.llm_rate_limit_per_minute = 1;
+    }
+    if (config->triggers.template_rate_limit_per_minute < 1) {
+        config->triggers.template_rate_limit_per_minute = 1;
+    }
+
+    return 0;
+}
+
+static int parse_dm_protocol_config(cJSON* root, didactyl_config_t* config) {
+    if (!root || !config) {
+        return -1;
+    }
+
+    cJSON* dm_protocol = cJSON_GetObjectItemCaseSensitive(root, "dm_protocol");
+    if (!dm_protocol) {
+        return 0;
+    }
+
+    if (!cJSON_IsString(dm_protocol) || !dm_protocol->valuestring) {
+        return -1;
+    }
+
+    if (strcmp(dm_protocol->valuestring, "nip04") == 0) {
+        config->dm_protocol = DM_PROTOCOL_NIP04;
+    } else if (strcmp(dm_protocol->valuestring, "nip17") == 0) {
+        config->dm_protocol = DM_PROTOCOL_NIP17;
+    } else if (strcmp(dm_protocol->valuestring, "both") == 0) {
+        config->dm_protocol = DM_PROTOCOL_BOTH;
+    } else {
+        return -1;
+    }
+
+    return 0;
+}
+
+static int parse_api_config(cJSON* root, didactyl_config_t* config) {
+    cJSON* api = cJSON_GetObjectItemCaseSensitive(root, "api");
+    if (!api || !cJSON_IsObject(api)) {
+        return 0;
+    }
+
+    cJSON* enabled = cJSON_GetObjectItemCaseSensitive(api, "enabled");
+    cJSON* port = cJSON_GetObjectItemCaseSensitive(api, "port");
+
+    if (enabled && cJSON_IsBool(enabled)) {
+        config->api.enabled = cJSON_IsTrue(enabled) ? 1 : 0;
+    }
+    if (port && cJSON_IsNumber(port)) {
+        config->api.port = (int)port->valuedouble;
+    }
+
+    if (copy_json_string(api,
+                         "bind_address",
+                         config->api.bind_address,
+                         sizeof(config->api.bind_address),
+                         0) != 0) {
+        return -1;
+    }
+
+    if (config->api.port < 1 || config->api.port > 65535) {
+        config->api.port = 8484;
+    }
+    if (config->api.bind_address[0] == '\0') {
+        snprintf(config->api.bind_address, sizeof(config->api.bind_address), "%s", "127.0.0.1");
+    }
+
+    return 0;
+}
+
+static cJSON* find_tag_value_string(cJSON* tags, const char* tag_key) {
+    if (!tags || !cJSON_IsArray(tags) || !tag_key) {
+        return NULL;
+    }
+
+    int n = cJSON_GetArraySize(tags);
+    for (int i = 0; i < n; i++) {
+        cJSON* tag = cJSON_GetArrayItem(tags, i);
+        if (!tag || !cJSON_IsArray(tag) || cJSON_GetArraySize(tag) < 2) {
+            continue;
+        }
+
+        cJSON* key = cJSON_GetArrayItem(tag, 0);
+        cJSON* val = cJSON_GetArrayItem(tag, 1);
+        if (!key || !val || !cJSON_IsString(key) || !cJSON_IsString(val) || !key->valuestring || !val->valuestring) {
+            continue;
+        }
+
+        if (strcmp(key->valuestring, tag_key) == 0) {
+            return val;
+        }
+    }
+
+    return NULL;
+}
+
+static int set_tag_value_string(cJSON* tags, const char* tag_key, const char* tag_value) {
+    if (!tags || !cJSON_IsArray(tags) || !tag_key || !tag_value || tag_value[0] == '\0') {
+        return -1;
+    }
+
+    int n = cJSON_GetArraySize(tags);
+    for (int i = 0; i < n; i++) {
+        cJSON* tag = cJSON_GetArrayItem(tags, i);
+        if (!tag || !cJSON_IsArray(tag) || cJSON_GetArraySize(tag) < 2) {
+            continue;
+        }
+
+        cJSON* key = cJSON_GetArrayItem(tag, 0);
+        cJSON* val = cJSON_GetArrayItem(tag, 1);
+        if (!key || !val || !cJSON_IsString(key) || !key->valuestring) {
+            continue;
+        }
+
+        if (strcmp(key->valuestring, tag_key) == 0) {
+            if (cJSON_IsString(val)) {
+                if (!cJSON_SetValuestring(val, tag_value)) {
+                    return -1;
+                }
+                return 0;
+            }
+
+            cJSON* new_val = cJSON_CreateString(tag_value);
+            if (!new_val) {
+                return -1;
+            }
+            cJSON_ReplaceItemInArray(tag, 1, new_val);
+            return 0;
+        }
+    }
+
+    cJSON* new_tag = cJSON_CreateArray();
+    if (!new_tag) {
+        return -1;
+    }
+    cJSON_AddItemToArray(new_tag, cJSON_CreateString(tag_key));
+    cJSON_AddItemToArray(new_tag, cJSON_CreateString(tag_value));
+    cJSON_AddItemToArray(tags, new_tag);
+    return 0;
+}
+
+static int normalize_skill_d_tag(int event_kind, cJSON* item, cJSON* tags) {
+    if (!item || !tags || !cJSON_IsArray(tags)) {
+        return 0;
+    }
+    if (event_kind != 31123 && event_kind != 31124) {
+        return 0;
+    }
+
+    cJSON* d_val = find_tag_value_string(tags, "d");
+    if (!d_val || !cJSON_IsString(d_val) || !d_val->valuestring) {
+        return 0;
+    }
+
+    int needs_normalize =
+        (strcmp(d_val->valuestring, "skill") == 0 || strcmp(d_val->valuestring, "private_skill") == 0);
+    if (!needs_normalize) {
+        return 0;
+    }
+
+    const char* d_tag = NULL;
+
+    if (!d_tag) {
+        cJSON* content_fields = cJSON_GetObjectItemCaseSensitive(item, "content_fields");
+        if (content_fields && cJSON_IsObject(content_fields)) {
+            cJSON* name = cJSON_GetObjectItemCaseSensitive(content_fields, "name");
+            if (name && cJSON_IsString(name) && name->valuestring && name->valuestring[0] != '\0') {
+                d_tag = name->valuestring;
+            }
+        }
+    }
+
+    if (!d_tag) {
+        return 0;
+    }
+
+    return set_tag_value_string(tags, "d", d_tag);
+}
+
+static int parse_startup_events(cJSON* root, didactyl_config_t* config) {
+    cJSON* arr = cJSON_GetObjectItemCaseSensitive(root, "startup_events");
+    if (!arr || !cJSON_IsArray(arr)) {
+        return 0;
+    }
+
+    int count = cJSON_GetArraySize(arr);
+    if (count <= 0) return 0;
+
+    config->startup_events = (startup_event_t*)calloc((size_t)count, sizeof(startup_event_t));
+    if (!config->startup_events) return -1;
+    config->startup_event_count = count;
+
+    for (int i = 0; i < count; i++) {
+        cJSON* item = cJSON_GetArrayItem(arr, i);
+        if (!item || !cJSON_IsObject(item)) return -1;
+
+        cJSON* kind = cJSON_GetObjectItemCaseSensitive(item, "kind");
+        cJSON* content = cJSON_GetObjectItemCaseSensitive(item, "content");
+        cJSON* content_fields = cJSON_GetObjectItemCaseSensitive(item, "content_fields");
+        cJSON* tags = cJSON_GetObjectItemCaseSensitive(item, "tags");
+
+        if (!kind || !cJSON_IsNumber(kind)) {
+            return -1;
+        }
+
+        config->startup_events[i].kind = (int)kind->valuedouble;
+
+        if (content_fields) {
+            if (!cJSON_IsObject(content_fields)) {
+                return -1;
+            }
+            config->startup_events[i].content = cJSON_PrintUnformatted(content_fields);
+            if (!config->startup_events[i].content) {
+                return -1;
+            }
+        } else {
+            if (!content || !cJSON_IsString(content) || !content->valuestring) {
+                return -1;
+            }
+            config->startup_events[i].content = strdup(content->valuestring);
+            if (!config->startup_events[i].content) {
+                return -1;
+            }
+        }
+
+        if (tags) {
+            if (!cJSON_IsArray(tags)) return -1;
+            if (normalize_skill_d_tag(config->startup_events[i].kind, item, tags) != 0) {
+                return -1;
+            }
+            config->startup_events[i].tags_json = cJSON_PrintUnformatted(tags);
+            if (!config->startup_events[i].tags_json) return -1;
+        }
+    }
+
+    return 0;
+}
+
+static int parse_relays_from_startup_kind10002(didactyl_config_t* config) {
+    if (!config || !config->startup_events || config->startup_event_count <= 0) {
+        return -1;
+    }
+
+    for (int i = 0; i < config->startup_event_count; i++) {
+        startup_event_t* se = &config->startup_events[i];
+        if (se->kind != 10002 || !se->tags_json) {
+            continue;
+        }
+
+        cJSON* tags = cJSON_Parse(se->tags_json);
+        if (!tags || !cJSON_IsArray(tags)) {
+            cJSON_Delete(tags);
+            continue;
+        }
+
+        int tag_count = cJSON_GetArraySize(tags);
+        int relay_count = 0;
+        for (int j = 0; j < tag_count; j++) {
+            cJSON* tag = cJSON_GetArrayItem(tags, j);
+            if (!tag || !cJSON_IsArray(tag) || cJSON_GetArraySize(tag) < 2) {
+                continue;
+            }
+
+            cJSON* key = cJSON_GetArrayItem(tag, 0);
+            cJSON* val = cJSON_GetArrayItem(tag, 1);
+            if (!key || !val || !cJSON_IsString(key) || !cJSON_IsString(val) || !key->valuestring || !val->valuestring) {
+                continue;
+            }
+
+            if (strcmp(key->valuestring, "r") == 0 && val->valuestring[0] != '\0') {
+                relay_count++;
+            }
+        }
+
+        if (relay_count <= 0) {
+            cJSON_Delete(tags);
+            continue;
+        }
+
+        config->relays = (char**)calloc((size_t)relay_count, sizeof(char*));
+        if (!config->relays) {
+            cJSON_Delete(tags);
+            return -1;
+        }
+
+        config->relay_count = relay_count;
+        int out_i = 0;
+        for (int j = 0; j < tag_count && out_i < relay_count; j++) {
+            cJSON* tag = cJSON_GetArrayItem(tags, j);
+            if (!tag || !cJSON_IsArray(tag) || cJSON_GetArraySize(tag) < 2) {
+                continue;
+            }
+
+            cJSON* key = cJSON_GetArrayItem(tag, 0);
+            cJSON* val = cJSON_GetArrayItem(tag, 1);
+            if (!key || !val || !cJSON_IsString(key) || !cJSON_IsString(val) || !key->valuestring || !val->valuestring) {
+                continue;
+            }
+
+            if (strcmp(key->valuestring, "r") == 0 && val->valuestring[0] != '\0') {
+                config->relays[out_i] = strdup(val->valuestring);
+                if (!config->relays[out_i]) {
+                    cJSON_Delete(tags);
+                    return -1;
+                }
+                out_i++;
+            }
+        }
+
+        cJSON_Delete(tags);
+        return 0;
+    }
+
+    return -1;
+}
+
+static int parse_relays(cJSON* root, didactyl_config_t* config) {
+    (void)root;
+    return parse_relays_from_startup_kind10002(config);
+}
+
 void config_free(didactyl_config_t* config) {
     if (!config) {
         return;
@@ -206,82 +770,135 @@ void config_free(didactyl_config_t* config) {
         free(config->relays);
     }
 
+    if (config->startup_events) {
+        for (int i = 0; i < config->startup_event_count; i++) {
+            free(config->startup_events[i].content);
+            free(config->startup_events[i].tags_json);
+        }
+        free(config->startup_events);
+    }
+
     memset(config, 0, sizeof(*config));
 }
 
 int config_load(const char* path, didactyl_config_t* config) {
     if (!path || !config) {
+        config_set_error("config_load called with invalid arguments");
         return -1;
     }
 
+    config_set_error("unknown configuration error");
+
     memset(config, 0, sizeof(*config));
+    snprintf(config->config_path, sizeof(config->config_path), "%s", path);
+    config->dm_protocol = DM_PROTOCOL_NIP04;
+
     config->tools.enabled = 1;
     config->tools.max_turns = 8;
+    config->tools.trigger_max_turns = 6;
+    config->tools.api_default_max_turns = 4;
+    config->tools.api_max_turns_ceiling = 16;
+    config->tools.local_http_fetch_default_timeout_seconds = 20;
+    config->tools.local_http_fetch_max_timeout_seconds = 120;
     config->tools.shell.enabled = 1;
     config->tools.shell.timeout_seconds = 30;
     config->tools.shell.max_output_bytes = 65536;
     strcpy(config->tools.shell.working_directory, ".");
 
-    char* json_buf = NULL;
-    size_t json_len = 0;
-    if (read_file_to_buffer(path, &json_buf, &json_len) != 0) {
+    config->security.verify_signatures = 1;
+    config->security.admin.enabled = 1;
+    config->security.admin.tools_enabled = 1;
+    config->security.wot.enabled = 1;
+    config->security.wot.tools_enabled = 0;
+    config->security.stranger.enabled = 1;
+    config->security.stranger.tools_enabled = 0;
+    config->security.stranger_response[0] = '\0';
+
+    config->admin_context.enabled = 1;
+    config->admin_context.track_kind_0 = 1;
+    config->admin_context.track_kind_3 = 1;
+    config->admin_context.track_kind_10002 = 1;
+    config->admin_context.track_kind_1 = 1;
+    config->admin_context.kind_1_limit = 10;
+
+    config->triggers.enabled = 1;
+    config->triggers.max_active = 16;
+    config->triggers.cooldown_seconds = 60;
+    config->triggers.llm_rate_limit_per_minute = 10;
+    config->triggers.template_rate_limit_per_minute = 60;
+
+    config->api.enabled = 0;
+    config->api.port = 8484;
+    snprintf(config->api.bind_address, sizeof(config->api.bind_address), "%s", "127.0.0.1");
+
+    char* raw_buf = NULL;
+    size_t raw_len = 0;
+    if (read_file_to_buffer(path, &raw_buf, &raw_len) != 0) {
+        config_set_error("failed to read config file '%s': %s", path, strerror(errno));
         return -1;
     }
 
+    /* Strip JSONC comments before parsing */
+    char* json_buf = jsonc_strip_comments(raw_buf, raw_len);
+    free(raw_buf);
+    if (!json_buf) {
+        config_set_error("failed to allocate memory for JSONC comment stripping");
+        return -1;
+    }
+    size_t json_len = strlen(json_buf);
+
     cJSON* root = cJSON_ParseWithLength(json_buf, json_len);
     free(json_buf);
 
     if (!root) {
+        const char* err = cJSON_GetErrorPtr();
+        config_set_error("invalid JSON in config '%s'%s%s",
+                         path,
+                         err ? " near: " : "",
+                         err ? err : "");
         return -1;
     }
 
     int rc = -1;
 
-    cJSON* agent = cJSON_GetObjectItemCaseSensitive(root, "agent");
     cJSON* keys = cJSON_GetObjectItemCaseSensitive(root, "keys");
     cJSON* admin = cJSON_GetObjectItemCaseSensitive(root, "admin");
     cJSON* llm = cJSON_GetObjectItemCaseSensitive(root, "llm");
 
-    if (!agent || !cJSON_IsObject(agent) ||
-        !keys || !cJSON_IsObject(keys) ||
+    if (!keys || !cJSON_IsObject(keys) ||
         !admin || !cJSON_IsObject(admin) ||
         !llm || !cJSON_IsObject(llm)) {
-        goto cleanup;
-    }
-
-    if (copy_json_string(agent, "name", config->profile.name, sizeof(config->profile.name), 1) != 0) {
-        goto cleanup;
-    }
-    if (copy_json_string(agent, "display_name", config->profile.display_name, sizeof(config->profile.display_name), 1) != 0) {
-        goto cleanup;
-    }
-    if (copy_json_string(agent, "about", config->profile.about, sizeof(config->profile.about), 1) != 0) {
-        goto cleanup;
-    }
-    if (copy_json_string(agent, "picture", config->profile.picture, sizeof(config->profile.picture), 0) != 0) {
-        goto cleanup;
-    }
-    if (copy_json_string(agent, "nip05", config->profile.nip05, sizeof(config->profile.nip05), 0) != 0) {
+        config_set_error("config must include object sections: keys, admin, llm");
         goto cleanup;
     }
 
     if (copy_json_string(keys, "nsec", config->keys.nsec, sizeof(config->keys.nsec), 1) != 0) {
+        config_set_error("keys.nsec is required and must be a non-empty string");
         goto cleanup;
     }
 
     char admin_key_raw[OW_MAX_KEY_LEN] = {0};
     if (copy_json_string(admin, "pubkey", admin_key_raw, sizeof(admin_key_raw), 1) != 0) {
+        config_set_error("admin.pubkey is required and must be a non-empty string");
         goto cleanup;
     }
     if (decode_pubkey_hex_or_npub(admin_key_raw, config->admin.pubkey) != 0) {
+        config_set_error("admin.pubkey must be npub1... or 64-char hex");
+        goto cleanup;
+    }
+
+    if (parse_startup_events(root, config) != 0) {
+        config_set_error("invalid startup_events configuration");
         goto cleanup;
     }
 
     if (parse_relays(root, config) != 0) {
+        config_set_error("relay configuration is invalid: startup_events must include kind 10002 with non-empty r tags");
         goto cleanup;
     }
 
     if (copy_json_string(llm, "provider", config->llm.provider, sizeof(config->llm.provider), 0) != 0) {
+        config_set_error("llm.provider must be a string if provided");
         goto cleanup;
     }
     if (config->llm.provider[0] == '\0') {
@@ -289,12 +906,15 @@ int config_load(const char* path, didactyl_config_t* config) {
     }
 
     if (copy_json_string(llm, "api_key", config->llm.api_key, sizeof(config->llm.api_key), 1) != 0) {
+        config_set_error("llm.api_key is required and must be a string");
         goto cleanup;
     }
     if (copy_json_string(llm, "model", config->llm.model, sizeof(config->llm.model), 1) != 0) {
+        config_set_error("llm.model is required and must be a string");
         goto cleanup;
     }
     if (copy_json_string(llm, "base_url", config->llm.base_url, sizeof(config->llm.base_url), 1) != 0) {
+        config_set_error("llm.base_url is required and must be a string");
         goto cleanup;
     }
 
@@ -304,15 +924,43 @@ int config_load(const char* path, didactyl_config_t* config) {
     config->llm.max_tokens = (max_tokens && cJSON_IsNumber(max_tokens)) ? (int)max_tokens->valuedouble : 512;
     config->llm.temperature = (temperature && cJSON_IsNumber(temperature)) ? temperature->valuedouble : 0.7;
 
+    if (parse_dm_protocol_config(root, config) != 0) {
+        config_set_error("invalid dm_protocol configuration (expected 'nip04', 'nip17', or 'both')");
+        goto cleanup;
+    }
+
     if (parse_tools_config(root, config) != 0) {
+        config_set_error("invalid tools configuration");
+        goto cleanup;
+    }
+
+    if (parse_security_config(root, config) != 0) {
+        config_set_error("invalid security configuration");
+        goto cleanup;
+    }
+
+    if (parse_admin_context_config(root, config) != 0) {
+        config_set_error("invalid admin_context configuration");
+        goto cleanup;
+    }
+
+    if (parse_triggers_config(root, config) != 0) {
+        config_set_error("invalid triggers configuration");
+        goto cleanup;
+    }
+
+    if (parse_api_config(root, config) != 0) {
+        config_set_error("invalid api configuration");
         goto cleanup;
     }
 
     if (decode_private_key(config->keys.nsec, config->keys.private_key) != 0) {
+        config_set_error("keys.nsec must be valid nsec1... or 64-char hex private key");
         goto cleanup;
     }
 
     if (nostr_ec_public_key_from_private_key(config->keys.private_key, config->keys.public_key) != 0) {
+        config_set_error("failed to derive public key from keys.nsec");
         goto cleanup;
     }
 

src/config.h

@@ -9,13 +9,7 @@
 #define OW_MAX_KEY_LEN 256
 #define OW_MAX_MODEL_LEN 128
 
-typedef struct {
-    char name[OW_MAX_NAME_LEN];
-    char display_name[OW_MAX_NAME_LEN];
-    char about[OW_MAX_ABOUT_LEN];
-    char picture[OW_MAX_URL_LEN];
-    char nip05[OW_MAX_URL_LEN];
-} agent_profile_t;
+#define OW_MAX_STRANGER_RESPONSE_LEN 512
 
 typedef struct {
     char nsec[OW_MAX_KEY_LEN];
@@ -24,6 +18,12 @@ typedef struct {
     char public_key_hex[65];
 } agent_keys_t;
 
+typedef enum {
+    DM_PROTOCOL_NIP04 = 0,
+    DM_PROTOCOL_NIP17 = 1,
+    DM_PROTOCOL_BOTH = 2
+} dm_protocol_t;
+
 typedef struct {
     char pubkey[65];
 } admin_config_t;
@@ -47,20 +47,78 @@ typedef struct {
 typedef struct {
     int enabled;
     int max_turns;
+    int trigger_max_turns;
+    int api_default_max_turns;
+    int api_max_turns_ceiling;
+    int local_http_fetch_default_timeout_seconds;
+    int local_http_fetch_max_timeout_seconds;
     shell_tools_config_t shell;
 } tools_config_t;
 
 typedef struct {
-    agent_profile_t profile;
+    int kind;
+    char* content;
+    char* tags_json;  // JSON array string for tags, optional
+} startup_event_t;
+
+typedef struct {
+    int enabled;
+    int tools_enabled;
+} security_tier_config_t;
+
+typedef struct {
+    int verify_signatures;
+    char stranger_response[OW_MAX_STRANGER_RESPONSE_LEN];
+    security_tier_config_t admin;
+    security_tier_config_t wot;
+    security_tier_config_t stranger;
+} security_config_t;
+
+typedef struct {
+    int enabled;
+    int track_kind_0;
+    int track_kind_3;
+    int track_kind_10002;
+    int track_kind_1;
+    int kind_1_limit;
+} admin_context_config_t;
+
+typedef struct {
+    int enabled;
+    int max_active;
+    int cooldown_seconds;
+    int llm_rate_limit_per_minute;
+    int template_rate_limit_per_minute;
+} triggers_config_t;
+
+typedef struct {
+    int enabled;
+    int port;
+    char bind_address[OW_MAX_URL_LEN];
+} api_config_t;
+
+typedef struct {
     agent_keys_t keys;
     admin_config_t admin;
+    dm_protocol_t dm_protocol;
     char** relays;
     int relay_count;
     llm_config_t llm;
     tools_config_t tools;
+    security_config_t security;
+    admin_context_config_t admin_context;
+    triggers_config_t triggers;
+    api_config_t api;
+    startup_event_t* startup_events;
+    int startup_event_count;
+    char config_path[OW_MAX_URL_LEN];
 } didactyl_config_t;
 
 int config_load(const char* path, didactyl_config_t* config);
+const char* config_last_error(void);
 void config_free(didactyl_config_t* config);
 
+/* Strip JSONC single-line and block comments, returning malloc'd pure JSON. */
+char* jsonc_strip_comments(const char* src, size_t src_len);
+
 #endif

src/http_api.h

@@ -0,0 +1,19 @@
+#ifndef DIDACTYL_HTTP_API_H
+#define DIDACTYL_HTTP_API_H
+
+#include "config.h"
+#include "tools.h"
+
+struct trigger_manager;
+
+typedef struct {
+    didactyl_config_t* cfg;
+    tools_context_t* tools_ctx;
+    struct trigger_manager* trigger_manager;
+} http_api_context_t;
+
+int http_api_init(const http_api_context_t* ctx);
+int http_api_poll(int timeout_ms);
+void http_api_cleanup(void);
+
+#endif

src/llm.c

@@ -3,6 +3,7 @@
 #include "llm.h"
 
 #include <curl/curl.h>
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -64,15 +65,42 @@ static const char* detect_ca_bundle_path(void) {
     return NULL;
 }
 
-static char* perform_chat_request(const char* body) {
+static int url_looks_like_websocket(const char* url) {
+    if (!url) return 0;
+    return (strncmp(url, "ws://", 5) == 0) || (strncmp(url, "wss://", 6) == 0);
+}
+
+static int json_string_is_blank(const cJSON* item) {
+    if (!item || !cJSON_IsString(item) || !item->valuestring) {
+        return 0;
+    }
+    const unsigned char* p = (const unsigned char*)item->valuestring;
+    while (*p) {
+        if (!isspace(*p)) {
+            return 0;
+        }
+        p++;
+    }
+    return 1;
+}
+
+static char* perform_http_request(const char* url, const char* body, int is_post) {
     CURL* curl = curl_easy_init();
-    if (!curl || !body) {
+    if (!curl || !url) {
         if (curl) curl_easy_cleanup(curl);
         return NULL;
     }
 
-    char url[OW_MAX_URL_LEN + 64];
-    snprintf(url, sizeof(url), "%s/chat/completions", g_cfg.base_url);
+    if (url_looks_like_websocket(url)) {
+        fprintf(stderr,
+                "[didactyl] llm config error: base_url must be HTTP(S), got WebSocket URL: %s\n",
+                url);
+        fprintf(stderr,
+                "[didactyl] llm hint: set llm.base_url to an OpenAI-compatible HTTPS endpoint, e.g. https://api.example.com/v1\n");
+        curl_easy_cleanup(curl);
+        return NULL;
+    }
+
 
     response_buffer_t rb = {0};
     struct curl_slist* headers = NULL;
@@ -83,8 +111,11 @@ static char* perform_chat_request(const char* body) {
     headers = curl_slist_append(headers, auth_header);
 
     curl_easy_setopt(curl, CURLOPT_URL, url);
-    curl_easy_setopt(curl, CURLOPT_POST, 1L);
-    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body);
+    curl_easy_setopt(curl, CURLOPT_HTTPGET, is_post ? 0L : 1L);
+    if (is_post) {
+        curl_easy_setopt(curl, CURLOPT_POST, 1L);
+        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body ? body : "{}");
+    }
     curl_easy_setopt(curl, CURLOPT_TIMEOUT, 60L);
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, &rb);
@@ -95,6 +126,19 @@ static char* perform_chat_request(const char* body) {
         curl_easy_setopt(curl, CURLOPT_CAINFO, ca_bundle);
     }
 
+    if (is_post) {
+        size_t body_len = body ? strlen(body) : 0U;
+        size_t body_preview_len = body_len > 4000U ? 4000U : body_len;
+        fprintf(stderr,
+                "[didactyl] llm request: method=POST url=%s body_bytes=%zu body_preview=%.4000s%s\n",
+                url,
+                body_len,
+                body ? body : "",
+                body_len > body_preview_len ? "..." : "");
+    } else {
+        fprintf(stderr, "[didactyl] llm request: method=GET url=%s\n", url);
+    }
+
     CURLcode res = curl_easy_perform(curl);
     long status = 0;
     curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &status);
@@ -115,6 +159,10 @@ static char* perform_chat_request(const char* body) {
 
     if (status < 200 || status >= 300) {
         fprintf(stderr, "[didactyl] llm http request failed: status=%ld\n", status);
+        if (status == 101) {
+            fprintf(stderr,
+                    "[didactyl] llm hint: received HTTP 101 (Switching Protocols), which usually means llm.base_url points to a WebSocket server instead of an HTTP LLM API\n");
+        }
         if (rb.data && rb.len > 0) {
             fprintf(stderr, "[didactyl] llm error response: %.1200s%s\n",
                     rb.data,
@@ -132,6 +180,12 @@ static char* perform_chat_request(const char* body) {
     return rb.data;
 }
 
+static char* perform_chat_request(const char* body) {
+    char url[OW_MAX_URL_LEN + 64];
+    snprintf(url, sizeof(url), "%s/chat/completions", g_cfg.base_url);
+    return perform_http_request(url, body, 1);
+}
+
 static char* build_request_json(const char* system_prompt, const char* user_message) {
     cJSON* root = cJSON_CreateObject();
     cJSON* messages = cJSON_CreateArray();
@@ -314,6 +368,36 @@ int llm_chat_with_tools_messages(const char* messages_json,
         cJSON_Delete(root);
         return -1;
     }
+
+    int filtered_count = 0;
+    for (int i = cJSON_GetArraySize(messages) - 1; i >= 0; i--) {
+        cJSON* msg = cJSON_GetArrayItem(messages, i);
+        if (!msg || !cJSON_IsObject(msg)) {
+            continue;
+        }
+
+        cJSON* role = cJSON_GetObjectItemCaseSensitive(msg, "role");
+        cJSON* content = cJSON_GetObjectItemCaseSensitive(msg, "content");
+        cJSON* tool_calls = cJSON_GetObjectItemCaseSensitive(msg, "tool_calls");
+
+        int role_is_textual = (role && cJSON_IsString(role) && role->valuestring &&
+                               (strcmp(role->valuestring, "system") == 0 ||
+                                strcmp(role->valuestring, "user") == 0 ||
+                                strcmp(role->valuestring, "assistant") == 0));
+        int has_tool_calls = (tool_calls && cJSON_IsArray(tool_calls) && cJSON_GetArraySize(tool_calls) > 0);
+
+        if (role_is_textual && !has_tool_calls && json_string_is_blank(content)) {
+            cJSON_DeleteItemFromArray(messages, i);
+            filtered_count++;
+        }
+    }
+
+    if (filtered_count > 0) {
+        fprintf(stderr,
+                "[didactyl] llm request sanitizer: removed %d empty text message(s) before provider request\n",
+                filtered_count);
+    }
+
     cJSON_AddItemToObject(root, "messages", messages);
 
     if (tools_json) {
@@ -388,6 +472,36 @@ void llm_response_free(llm_response_t* response) {
     memset(response, 0, sizeof(*response));
 }
 
+int llm_get_config(llm_config_t* out_config) {
+    if (!g_initialized || !out_config) {
+        return -1;
+    }
+    *out_config = g_cfg;
+    return 0;
+}
+
+int llm_set_config(const llm_config_t* config) {
+    if (!g_initialized || !config) {
+        return -1;
+    }
+    g_cfg = *config;
+    return 0;
+}
+
+char* llm_list_models_json(const char* base_url_override) {
+    if (!g_initialized) {
+        return NULL;
+    }
+
+    const char* base_url = (base_url_override && base_url_override[0] != '\0')
+                               ? base_url_override
+                               : g_cfg.base_url;
+
+    char url[OW_MAX_URL_LEN + 32];
+    snprintf(url, sizeof(url), "%s/models", base_url);
+    return perform_http_request(url, NULL, 0);
+}
+
 void llm_cleanup(void) {
     if (!g_initialized) {
         return;

src/llm.h

@@ -26,6 +26,9 @@ int llm_chat_with_tools_messages(const char* messages_json,
                                  const char* tool_choice,
                                  llm_response_t* out_response);
 void llm_response_free(llm_response_t* response);
+int llm_get_config(llm_config_t* out_config);
+int llm_set_config(const llm_config_t* config);
+char* llm_list_models_json(const char* base_url_override);
 void llm_cleanup(void);
 
 #endif

src/main.c

@@ -4,38 +4,126 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
 #include "../../nostr_core_lib/nostr_core/nostr_core.h"
 #include "main.h"
 #include "agent.h"
 #include "config.h"
-#include "context.h"
 #include "llm.h"
 #include "nostr_handler.h"
 #include "debug.h"
+#include "trigger_manager.h"
+#include "tools/tools.h"
+#include "cjson/cJSON.h"
+#include "http_api.h"
 
 static volatile sig_atomic_t g_running = 1;
 
+typedef struct {
+    trigger_manager_t* trigger_manager;
+    int loaded_once;
+} deferred_trigger_load_ctx_t;
+
+static void on_self_skill_eose_load_triggers(int event_count, void* user_data) {
+    deferred_trigger_load_ctx_t* ctx = (deferred_trigger_load_ctx_t*)user_data;
+    if (!ctx || !ctx->trigger_manager) {
+        return;
+    }
+
+    if (ctx->loaded_once) {
+        DEBUG_TRACE("[didactyl] deferred trigger load skipped (already loaded once) event_count=%d", event_count);
+        return;
+    }
+
+    DEBUG_INFO("[didactyl] deferred trigger load begin after self-skill EOSE (event_count=%d)", event_count);
+    if (trigger_manager_load_from_skills(ctx->trigger_manager) != 0) {
+        DEBUG_WARN("[didactyl] deferred trigger load failed after self-skill EOSE");
+        return;
+    }
+
+    ctx->loaded_once = 1;
+
+    char* status = trigger_manager_status_json(ctx->trigger_manager);
+    if (status) {
+        DEBUG_INFO("[didactyl] deferred trigger load status: %s", status);
+        free(status);
+    }
+}
+
 static void signal_handler(int signum) {
     (void)signum;
     g_running = 0;
 }
 
-int main(int argc, char** argv) {
-    const char* config_path = "./config.json";
-    const char* context_path = "./SYSTEM.md";
+static void print_usage(const char* prog) {
+    fprintf(stderr,
+            "Usage: %s [-h|--help] [-v|--version] [--config <path>] [--debug <0-5>] [--dump-schemas] [--test-tool <name> <args_json>]\n",
+            prog ? prog : "didactyl");
+}
 
+static int tool_result_success(const char* json) {
+    if (!json) {
+        return 0;
+    }
+
+    cJSON* root = cJSON_Parse(json);
+    if (!root || !cJSON_IsObject(root)) {
+        cJSON_Delete(root);
+        return 0;
+    }
+
+    cJSON* success = cJSON_GetObjectItemCaseSensitive(root, "success");
+    int ok = (success && cJSON_IsBool(success) && cJSON_IsTrue(success)) ? 1 : 0;
+    cJSON_Delete(root);
+    return ok;
+}
+
+static int wait_for_connected_relays(int timeout_ms) {
+    if (timeout_ms <= 0) {
+        return nostr_handler_connected_relay_count() > 0 ? 1 : 0;
+    }
+
+    const int step_ms = 100;
+    int elapsed_ms = 0;
+
+    while (elapsed_ms < timeout_ms) {
+        if (nostr_handler_connected_relay_count() > 0) {
+            return 1;
+        }
+
+        (void)nostr_handler_poll(step_ms);
+        elapsed_ms += step_ms;
+    }
+
+    return nostr_handler_connected_relay_count() > 0 ? 1 : 0;
+}
+
+int main(int argc, char** argv) {
+    const char* config_path = "./config.jsonc";
     int debug_level = DEBUG_LEVEL_TRACE;
+    int dump_schemas = 0;
+    const char* test_tool_name = NULL;
+    const char* test_tool_args = "{}";
 
     for (int i = 1; i < argc; i++) {
-        if (strcmp(argv[i], "--config") == 0 && i + 1 < argc) {
+        if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
+            print_usage(argv[0]);
+            return 0;
+        } else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0) {
+            printf("%s %s\n", DIDACTYL_NAME, DIDACTYL_VERSION);
+            return 0;
+        } else if (strcmp(argv[i], "--config") == 0 && i + 1 < argc) {
             config_path = argv[++i];
-        } else if (strcmp(argv[i], "--context") == 0 && i + 1 < argc) {
-            context_path = argv[++i];
         } else if (strcmp(argv[i], "--debug") == 0 && i + 1 < argc) {
             debug_level = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "--dump-schemas") == 0) {
+            dump_schemas = 1;
+        } else if (strcmp(argv[i], "--test-tool") == 0 && i + 2 < argc) {
+            test_tool_name = argv[++i];
+            test_tool_args = argv[++i];
         } else {
-            fprintf(stderr, "Usage: %s [--config <path>] [--context <path>] [--debug <0-5>]\n", argv[0]);
+            print_usage(argv[0]);
             return 1;
         }
     }
@@ -52,21 +140,86 @@ int main(int argc, char** argv) {
     didactyl_config_t cfg;
     if (config_load(config_path, &cfg) != 0) {
         fprintf(stderr, "Failed to load config: %s\n", config_path);
+        fprintf(stderr, "Config error: %s\n", config_last_error());
         nostr_cleanup();
         return 1;
     }
 
-    char* system_context = context_load(context_path);
-    if (!system_context) {
-        fprintf(stderr, "Failed to load context file: %s\n", context_path);
+    if (dump_schemas || test_tool_name) {
+        if (llm_init(&cfg.llm) != 0) {
+            fprintf(stderr, "Failed to initialize llm client\n");
+            config_free(&cfg);
+            nostr_cleanup();
+            return 1;
+        }
+
+        if (nostr_handler_init(&cfg) != 0) {
+            fprintf(stderr, "Failed to initialize nostr handler\n");
+            config_free(&cfg);
+            llm_cleanup();
+            nostr_cleanup();
+            return 1;
+        }
+
+        tools_context_t tools_ctx;
+        if (tools_init(&tools_ctx, &cfg) != 0) {
+            fprintf(stderr, "Failed to initialize tools context\n");
+            nostr_handler_cleanup();
+            config_free(&cfg);
+            llm_cleanup();
+            nostr_cleanup();
+            return 1;
+        }
+
+        int exit_code = 0;
+
+        if (test_tool_name) {
+            const int timeout_ms = 15000;
+            if (!wait_for_connected_relays(timeout_ms)) {
+                fprintf(stderr,
+                        "No relay connection established within %d ms; refusing to run --test-tool '%s'\n",
+                        timeout_ms,
+                        test_tool_name);
+                tools_cleanup(&tools_ctx);
+                nostr_handler_cleanup();
+                config_free(&cfg);
+                llm_cleanup();
+                nostr_cleanup();
+                return 1;
+            }
+        }
+
+        if (dump_schemas) {
+            char* schemas = tools_build_openai_schema_json(&tools_ctx);
+            if (!schemas) {
+                fprintf(stderr, "Failed to build tool schemas\n");
+                exit_code = 1;
+            } else {
+                printf("%s\n", schemas);
+                free(schemas);
+            }
+        } else {
+            char* result = tools_execute(&tools_ctx, test_tool_name, test_tool_args);
+            if (!result) {
+                fprintf(stderr, "Failed to execute tool\n");
+                exit_code = 1;
+            } else {
+                printf("%s\n", result);
+                exit_code = tool_result_success(result) ? 0 : 1;
+                free(result);
+            }
+        }
+
+        tools_cleanup(&tools_ctx);
+        nostr_handler_cleanup();
         config_free(&cfg);
+        llm_cleanup();
         nostr_cleanup();
-        return 1;
+        return exit_code;
     }
 
     if (llm_init(&cfg.llm) != 0) {
         fprintf(stderr, "Failed to initialize llm client\n");
-        context_free(system_context);
         config_free(&cfg);
         nostr_cleanup();
         return 1;
@@ -75,27 +228,96 @@ int main(int argc, char** argv) {
     if (nostr_handler_init(&cfg) != 0) {
         fprintf(stderr, "Failed to initialize nostr handler\n");
         llm_cleanup();
-        context_free(system_context);
         config_free(&cfg);
         nostr_cleanup();
         return 1;
     }
 
+    if (nostr_handler_reconcile_startup_events() != 0) {
+        DEBUG_WARN("[didactyl] startup phase: reconcile startup events failed (continuing)");
+    }
+
+    const char* system_context = nostr_handler_get_system_context();
+    if (!system_context || system_context[0] == '\0') {
+        system_context = "You are Didactyl, a sovereign AI agent living on Nostr.";
+    }
+
     if (agent_init(&cfg, system_context) != 0) {
         fprintf(stderr, "Failed to initialize agent\n");
         nostr_handler_cleanup();
         llm_cleanup();
-        context_free(system_context);
         config_free(&cfg);
         nostr_cleanup();
         return 1;
     }
 
-    DEBUG_INFO("[didactyl] startup phase: publish profile begin");
-    if (nostr_handler_publish_profile() != 0) {
-        DEBUG_WARN("[didactyl] publish profile deferred/failed (will continue startup)");
+    trigger_manager_t trigger_manager;
+    if (trigger_manager_init(&trigger_manager, &cfg) != 0) {
+        fprintf(stderr, "Failed to initialize trigger manager\n");
+        agent_cleanup();
+        nostr_handler_cleanup();
+        llm_cleanup();
+        config_free(&cfg);
+        nostr_cleanup();
+        return 1;
+    }
+    agent_set_trigger_manager(&trigger_manager);
+    nostr_handler_set_trigger_manager(&trigger_manager);
+
+    deferred_trigger_load_ctx_t deferred_trigger_ctx = {
+        .trigger_manager = &trigger_manager,
+        .loaded_once = 0
+    };
+    nostr_handler_set_self_skill_eose_callback(on_self_skill_eose_load_triggers, &deferred_trigger_ctx);
+
+    DEBUG_INFO("[didactyl] startup phase: deferred trigger load will run after self-skill EOSE");
+
+    DEBUG_INFO("[didactyl] startup phase: startup-config trigger load begin");
+    if (trigger_manager_load_from_startup_events(&trigger_manager) != 0) {
+        DEBUG_WARN("[didactyl] startup phase: startup-config trigger load failed (continuing)");
+    }
+    DEBUG_INFO("[didactyl] startup phase: startup-config trigger load end");
+
+    DEBUG_INFO("[didactyl] startup phase: subscribe admin context begin");
+    if (nostr_handler_subscribe_admin_context() != 0) {
+        DEBUG_WARN("[didactyl] startup phase: subscribe admin context failed (continuing)");
+    }
+    DEBUG_INFO("[didactyl] startup phase: subscribe admin context end");
+
+    DEBUG_INFO("[didactyl] startup phase: subscribe agent self context begin");
+    if (nostr_handler_subscribe_agent_context() != 0) {
+        DEBUG_WARN("[didactyl] startup phase: subscribe agent self context failed (continuing)");
+    }
+    DEBUG_INFO("[didactyl] startup phase: subscribe agent self context end");
+
+    DEBUG_INFO("[didactyl] startup phase: subscribe self skill cache begin");
+    if (nostr_handler_subscribe_self_skills() != 0) {
+        DEBUG_WARN("[didactyl] startup phase: subscribe self skill cache failed (continuing)");
+    }
+    DEBUG_INFO("[didactyl] startup phase: subscribe self skill cache end");
+
+    char startup_dm[768];
+    const char* startup_name = nostr_handler_get_startup_display_name();
+    int connected_relays = nostr_handler_connected_relay_count();
+    time_t startup_now = time(NULL);
+    struct tm startup_tm;
+    char startup_time_str[32] = {0};
+    if (localtime_r(&startup_now, &startup_tm)) {
+        (void)strftime(startup_time_str, sizeof(startup_time_str), "%Y-%m-%d %H:%M:%S", &startup_tm);
+    } else {
+        snprintf(startup_time_str, sizeof(startup_time_str), "%ld", (long)startup_now);
+    }
+    snprintf(startup_dm,
+             sizeof(startup_dm),
+             "%s has started up and is online at %s (version %s, connected relays: %d/%d).",
+             (startup_name && startup_name[0] != '\0') ? startup_name : "Didactyl",
+             startup_time_str,
+             DIDACTYL_VERSION,
+             connected_relays,
+             cfg.relay_count);
+    if (nostr_handler_send_dm_auto(cfg.admin.pubkey, startup_dm) != 0) {
+        DEBUG_WARN("[didactyl] startup phase: failed to send startup status DM to admin");
     }
-    DEBUG_INFO("[didactyl] startup phase: publish profile end");
 
     DEBUG_INFO("[didactyl] startup phase: subscribe DMs begin");
     if (nostr_handler_subscribe_dms(agent_on_message, NULL) != 0) {
@@ -104,7 +326,7 @@ int main(int argc, char** argv) {
         agent_cleanup();
         nostr_handler_cleanup();
         llm_cleanup();
-        context_free(system_context);
+        trigger_manager_cleanup(&trigger_manager);
         config_free(&cfg);
         nostr_cleanup();
         return 1;
@@ -114,22 +336,67 @@ int main(int argc, char** argv) {
 
     signal(SIGINT, signal_handler);
     signal(SIGTERM, signal_handler);
+    signal(SIGPIPE, SIG_IGN);
+
+    int http_api_started = 0;
+    if (cfg.api.enabled) {
+        http_api_context_t http_ctx;
+        memset(&http_ctx, 0, sizeof(http_ctx));
+        http_ctx.cfg = &cfg;
+        http_ctx.tools_ctx = agent_tools_context();
+        http_ctx.trigger_manager = &trigger_manager;
+
+        if (http_api_init(&http_ctx) != 0) {
+            fprintf(stderr,
+                    "Failed to initialize HTTP API on %s:%d\n",
+                    cfg.api.bind_address,
+                    cfg.api.port);
+            agent_cleanup();
+            nostr_handler_cleanup();
+            llm_cleanup();
+            trigger_manager_cleanup(&trigger_manager);
+            config_free(&cfg);
+            nostr_cleanup();
+            return 1;
+        }
+        http_api_started = 1;
+        DEBUG_INFO("[didactyl] HTTP API listening at http://%s:%d",
+                   cfg.api.bind_address[0] ? cfg.api.bind_address : "127.0.0.1",
+                   cfg.api.port > 0 ? cfg.api.port : 8484);
+        DEBUG_INFO("[didactyl] HTTP API endpoints: http://%s:%d/api/context/current  http://%s:%d/api/context/parts",
+                   cfg.api.bind_address[0] ? cfg.api.bind_address : "127.0.0.1",
+                   cfg.api.port > 0 ? cfg.api.port : 8484,
+                   cfg.api.bind_address[0] ? cfg.api.bind_address : "127.0.0.1",
+                   cfg.api.port > 0 ? cfg.api.port : 8484);
+    } else {
+        DEBUG_INFO("[didactyl] HTTP API disabled (set api.enabled=true in config to enable)");
+    }
+
+    nostr_handler_refresh_relay_statuses();
 
     DEBUG_INFO("[didactyl] entering main poll loop");
     DEBUG_INFO("[didactyl] running with pubkey %s", cfg.keys.public_key_hex);
 
     while (g_running) {
         (void)nostr_handler_poll(100);
+        (void)trigger_manager_poll(&trigger_manager);
+        if (http_api_started) {
+            (void)http_api_poll(0);
+        }
         struct timespec ts = {0, 10 * 1000 * 1000};
         nanosleep(&ts, NULL);
     }
 
     DEBUG_INFO("[didactyl] shutting down");
 
+    if (http_api_started) {
+        http_api_cleanup();
+    }
+
     agent_cleanup();
     nostr_handler_cleanup();
     llm_cleanup();
-    context_free(system_context);
+    trigger_manager_cleanup(&trigger_manager);
     config_free(&cfg);
     nostr_cleanup();
 

src/main.h

@@ -12,8 +12,8 @@
 // Using DIDACTYL_ prefix to avoid conflicts with nostr_core_lib VERSION macros
 #define DIDACTYL_VERSION_MAJOR 0
 #define DIDACTYL_VERSION_MINOR 0
-#define DIDACTYL_VERSION_PATCH 2
-#define DIDACTYL_VERSION "v0.0.2"
+#define DIDACTYL_VERSION_PATCH 70
+#define DIDACTYL_VERSION "v0.0.70"
 
 // Agent metadata
 #define DIDACTYL_NAME "Didactyl"

src/nostr_handler.h

@@ -3,16 +3,79 @@
 
 #include "config.h"
 #include "cjson/cJSON.h"
+#include "../nostr_core_lib/nostr_core/nostr_core.h"
 
-typedef void (*dm_callback_t)(const char* sender_pubkey_hex, const char* message, void* user_data);
+struct trigger_manager;
+
+typedef enum {
+    DIDACTYL_SENDER_ADMIN = 1,
+    DIDACTYL_SENDER_WOT = 2,
+    DIDACTYL_SENDER_STRANGER = 3
+} didactyl_sender_tier_t;
+
+typedef void (*dm_callback_t)(const char* sender_pubkey_hex,
+                              const char* message,
+                              didactyl_sender_tier_t tier,
+                              void* user_data);
+
+typedef struct {
+    int success;
+    int kind;
+    int relay_count;
+    int accepted_by_pool_count;
+    char event_id[65];
+    char note_uri[256];
+    char naddr_uri[1024];
+    char d_tag[128];
+    char** relays;
+} nostr_publish_result_t;
+
+typedef void (*nostr_self_skill_eose_cb_t)(int event_count, void* user_data);
 
 int nostr_handler_init(didactyl_config_t* config);
-int nostr_handler_publish_profile(void);
+void nostr_handler_set_trigger_manager(struct trigger_manager* trigger_manager);
+int nostr_handler_subscribe_admin_context(void);
+int nostr_handler_subscribe_agent_context(void);
+int nostr_handler_subscribe_self_skills(void);
+char* nostr_handler_get_self_events_by_kind_json(int kind);
+void nostr_handler_set_self_skill_eose_callback(nostr_self_skill_eose_cb_t callback, void* user_data);
 int nostr_handler_subscribe_dms(dm_callback_t callback, void* user_data);
 int nostr_handler_send_dm(const char* recipient_pubkey_hex, const char* message);
-int nostr_handler_publish_kind_event(int kind, const char* content, cJSON* tags);
+int nostr_handler_send_dm_auto(const char* recipient_pubkey_hex, const char* message);
+int nostr_handler_publish_kind_event(int kind, const char* content, cJSON* tags, nostr_publish_result_t* out_result);
+void nostr_handler_publish_result_free(nostr_publish_result_t* result);
 char* nostr_handler_query_json(cJSON* filter, int timeout_ms);
+nostr_pool_subscription_t* nostr_handler_subscribe_with_filter(
+    cJSON* filter,
+    void (*on_event)(cJSON* event, const char* relay_url, void* user_data),
+    void (*on_eose)(cJSON** events, int event_count, void* user_data),
+    void* user_data,
+    int close_on_eose,
+    int enable_deduplication,
+    nostr_pool_eose_result_mode_t result_mode,
+    int relay_timeout_seconds,
+    int eose_timeout_seconds);
+int nostr_handler_close_subscription(nostr_pool_subscription_t* subscription);
 int nostr_handler_poll(int timeout_ms);
+int nostr_handler_reconcile_startup_events(void);
+void nostr_handler_refresh_relay_statuses(void);
+const char* nostr_handler_get_system_context(void);
+char* nostr_handler_get_self_skill_events_json(void);
+const char* nostr_handler_get_startup_display_name(void);
+int nostr_handler_connected_relay_count(void);
+char* nostr_handler_get_admin_kind0_context(void);
+char* nostr_handler_get_admin_kind3_context(void);
+char* nostr_handler_get_admin_kind10002_context(void);
+char* nostr_handler_get_admin_kind1_notes_context(void);
+char* nostr_handler_get_agent_kind0_context(void);
+char* nostr_handler_get_agent_kind3_context(void);
+char* nostr_handler_get_agent_kind10002_context(void);
+char* nostr_handler_get_agent_kind1_notes_context(void);
+int nostr_handler_is_wot_contact(const char* pubkey_hex);
+char* nostr_handler_relay_status_json(void);
+char* nostr_handler_relay_info_json(const char* relay_url);
+int nostr_handler_send_dm_nip17(const char* recipient_pubkey_hex, const char* message, const char* subject);
+char* nostr_handler_get_dm_history_json(const char* peer_pubkey_hex, int limit);
 void nostr_handler_cleanup(void);
 
 #endif

src/prompt_template.c

@@ -0,0 +1,557 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "prompt_template.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static char* dup_range(const char* s, size_t n) {
+    char* out = (char*)malloc(n + 1U);
+    if (!out) return NULL;
+    if (n > 0) {
+        memcpy(out, s, n);
+    }
+    out[n] = '\0';
+    return out;
+}
+
+static char* ltrim_inplace(char* s) {
+    if (!s) return s;
+    while (*s && isspace((unsigned char)*s)) s++;
+    return s;
+}
+
+static void rtrim_inplace(char* s) {
+    if (!s) return;
+    size_t n = strlen(s);
+    while (n > 0 && isspace((unsigned char)s[n - 1])) {
+        s[n - 1] = '\0';
+        n--;
+    }
+}
+
+static int starts_with(const char* s, const char* prefix) {
+    if (!s || !prefix) return 0;
+    size_t n = strlen(prefix);
+    return strncmp(s, prefix, n) == 0;
+}
+
+static int add_line(char*** lines, int* count, int* cap, char* line) {
+    if (!lines || !count || !cap) return -1;
+    if (*count >= *cap) {
+        int next = (*cap == 0) ? 64 : (*cap * 2);
+        char** grown = (char**)realloc(*lines, (size_t)next * sizeof(char*));
+        if (!grown) return -1;
+        *lines = grown;
+        *cap = next;
+    }
+    (*lines)[*count] = line;
+    (*count)++;
+    return 0;
+}
+
+static int split_lines_inplace(char* s, char*** out_lines, int* out_count) {
+    if (!s || !out_lines || !out_count) return -1;
+
+    char** lines = NULL;
+    int count = 0;
+    int cap = 0;
+
+    char* p = s;
+    while (*p) {
+        char* start = p;
+        while (*p && *p != '\n') p++;
+        if (*p == '\n') {
+            *p = '\0';
+            p++;
+        }
+        if (add_line(&lines, &count, &cap, start) != 0) {
+            free(lines);
+            return -1;
+        }
+    }
+
+    *out_lines = lines;
+    *out_count = count;
+    return 0;
+}
+
+static int append_text(char** buf, size_t* cap, size_t* used, const char* s) {
+    if (!buf || !cap || !used || !s) return -1;
+    size_t n = strlen(s);
+    if (*used + n + 1U > *cap) {
+        size_t next = *cap;
+        while (*used + n + 1U > next) {
+            next = (next == 0U) ? 256U : (next * 2U);
+        }
+        char* grown = (char*)realloc(*buf, next);
+        if (!grown) return -1;
+        *buf = grown;
+        *cap = next;
+    }
+    memcpy(*buf + *used, s, n);
+    *used += n;
+    (*buf)[*used] = '\0';
+    return 0;
+}
+
+static void init_section_defaults(prompt_template_section_t* sec) {
+    if (!sec) return;
+    memset(sec->name, 0, sizeof(sec->name));
+    memset(sec->role, 0, sizeof(sec->role));
+    snprintf(sec->role, sizeof(sec->role), "system");
+    sec->content_template = NULL;
+    sec->tool_name = NULL;
+    sec->tool_args = NULL;
+    sec->result_field = NULL;
+    sec->limit = 0;
+    sec->skip_if_empty = 0;
+    sec->provider_name = NULL;
+    sec->provider_content_template = NULL;
+}
+
+static int parse_int_or_zero(const char* s) {
+    if (!s) return 0;
+    while (*s && isspace((unsigned char)*s)) s++;
+    return atoi(s);
+}
+
+int prompt_template_parse(const char* soul_content, prompt_template_t* out_template) {
+    if (!soul_content || !out_template) {
+        return -1;
+    }
+
+    memset(out_template, 0, sizeof(*out_template));
+
+    const char* marker = strstr(soul_content, PROMPT_TEMPLATE_MARKER);
+    if (!marker) {
+        return -1;
+    }
+
+    size_t personality_len = (size_t)(marker - soul_content);
+    out_template->personality = dup_range(soul_content, personality_len);
+    if (!out_template->personality) {
+        return -1;
+    }
+    rtrim_inplace(out_template->personality);
+
+    const char* after = marker + strlen(PROMPT_TEMPLATE_MARKER);
+    while (*after == '\r' || *after == '\n') after++;
+
+    char* tpl = strdup(after);
+    if (!tpl) {
+        prompt_template_free(out_template);
+        return -1;
+    }
+
+    char** lines = NULL;
+    int line_count = 0;
+    if (split_lines_inplace(tpl, &lines, &line_count) != 0) {
+        free(tpl);
+        prompt_template_free(out_template);
+        return -1;
+    }
+
+    int current = -1;
+    int i = 0;
+    while (i < line_count) {
+        char* raw = lines[i];
+        rtrim_inplace(raw);
+        char* line = ltrim_inplace(raw);
+
+        if (*line == '\0') {
+            i++;
+            continue;
+        }
+
+        if (starts_with(line, "- section:")) {
+            if (out_template->section_count >= PROMPT_TEMPLATE_MAX_SECTIONS) {
+                break;
+            }
+
+            current = out_template->section_count;
+            init_section_defaults(&out_template->sections[current]);
+            out_template->section_count++;
+
+            char* name = line + strlen("- section:");
+            name = ltrim_inplace(name);
+            rtrim_inplace(name);
+            snprintf(out_template->sections[current].name,
+                     sizeof(out_template->sections[current].name),
+                     "%s",
+                     name);
+            i++;
+            continue;
+        }
+
+        if (current < 0) {
+            i++;
+            continue;
+        }
+
+        if (starts_with(line, "role:")) {
+            char* role = line + strlen("role:");
+            role = ltrim_inplace(role);
+            rtrim_inplace(role);
+            snprintf(out_template->sections[current].role,
+                     sizeof(out_template->sections[current].role),
+                     "%s",
+                     (*role) ? role : "system");
+            i++;
+            continue;
+        }
+
+        if (starts_with(line, "limit:")) {
+            char* lim = line + strlen("limit:");
+            out_template->sections[current].limit = parse_int_or_zero(lim);
+            i++;
+            continue;
+        }
+
+        if (starts_with(line, "skip_if_empty:")) {
+            char* flag = line + strlen("skip_if_empty:");
+            flag = ltrim_inplace(flag);
+            rtrim_inplace(flag);
+            out_template->sections[current].skip_if_empty =
+                (strcmp(flag, "true") == 0 || strcmp(flag, "1") == 0) ? 1 : 0;
+            i++;
+            continue;
+        }
+
+        if (starts_with(line, "tool:")) {
+            char* val = line + strlen("tool:");
+            val = ltrim_inplace(val);
+            rtrim_inplace(val);
+            free(out_template->sections[current].tool_name);
+            out_template->sections[current].tool_name = strdup(val);
+            i++;
+            continue;
+        }
+
+        if (starts_with(line, "args:")) {
+            char* val = line + strlen("args:");
+            val = ltrim_inplace(val);
+            rtrim_inplace(val);
+            free(out_template->sections[current].tool_args);
+            out_template->sections[current].tool_args = strdup((*val) ? val : "{}");
+            i++;
+            continue;
+        }
+
+        if (starts_with(line, "result_field:")) {
+            char* val = line + strlen("result_field:");
+            val = ltrim_inplace(val);
+            rtrim_inplace(val);
+            free(out_template->sections[current].result_field);
+            out_template->sections[current].result_field = strdup(val);
+            i++;
+            continue;
+        }
+
+        if (starts_with(line, "content:")) {
+            char* val = line + strlen("content:");
+            val = ltrim_inplace(val);
+
+            free(out_template->sections[current].content_template);
+            out_template->sections[current].content_template = NULL;
+
+            if (strcmp(val, "|") == 0) {
+                char* acc = strdup("");
+                size_t cap = acc ? 1U : 0U;
+                size_t used = 0U;
+                if (!acc) {
+                    free(lines);
+                    free(tpl);
+                    prompt_template_free(out_template);
+                    return -1;
+                }
+
+                i++;
+                while (i < line_count) {
+                    char* next_raw = lines[i];
+                    char* next_ltrim = ltrim_inplace(next_raw);
+
+                    if (starts_with(next_ltrim, "- section:") ||
+                        starts_with(next_ltrim, "role:") ||
+                        starts_with(next_ltrim, "limit:") ||
+                        starts_with(next_ltrim, "skip_if_empty:") ||
+                        starts_with(next_ltrim, "tool:") ||
+                        starts_with(next_ltrim, "args:") ||
+                        starts_with(next_ltrim, "result_field:") ||
+                        starts_with(next_ltrim, "content:") ||
+                        starts_with(next_ltrim, "provider:")) {
+                        break;
+                    }
+
+                    char* piece = next_raw;
+                    if (strncmp(piece, "    ", 4) == 0) piece += 4;
+                    else if (strncmp(piece, "  ", 2) == 0) piece += 2;
+                    rtrim_inplace(piece);
+
+                    if (append_text(&acc, &cap, &used, piece) != 0 ||
+                        append_text(&acc, &cap, &used, "\n") != 0) {
+                        free(acc);
+                        free(lines);
+                        free(tpl);
+                        prompt_template_free(out_template);
+                        return -1;
+                    }
+                    i++;
+                }
+
+                rtrim_inplace(acc);
+                out_template->sections[current].content_template = acc;
+                continue;
+            }
+
+            rtrim_inplace(val);
+            out_template->sections[current].content_template = strdup(val);
+            i++;
+            continue;
+        }
+
+        if (starts_with(line, "provider:")) {
+            i++;
+            if (i >= line_count) continue;
+
+            char* provider_line = ltrim_inplace(lines[i]);
+            rtrim_inplace(provider_line);
+            char* colon = strchr(provider_line, ':');
+            if (!colon) {
+                continue;
+            }
+
+            *colon = '\0';
+            char* provider_name = ltrim_inplace(provider_line);
+            rtrim_inplace(provider_name);
+            char* provider_val = ltrim_inplace(colon + 1);
+            rtrim_inplace(provider_val);
+
+            free(out_template->sections[current].provider_name);
+            out_template->sections[current].provider_name = strdup(provider_name);
+            free(out_template->sections[current].provider_content_template);
+            out_template->sections[current].provider_content_template = NULL;
+
+            if (strcmp(provider_val, "|") == 0) {
+                char* acc = strdup("");
+                size_t cap = acc ? 1U : 0U;
+                size_t used = 0U;
+                if (!acc) {
+                    free(lines);
+                    free(tpl);
+                    prompt_template_free(out_template);
+                    return -1;
+                }
+
+                i++;
+                while (i < line_count) {
+                    char* next = ltrim_inplace(lines[i]);
+                    if (starts_with(next, "- section:") ||
+                        starts_with(next, "role:") ||
+                        starts_with(next, "limit:") ||
+                        starts_with(next, "skip_if_empty:") ||
+                        starts_with(next, "tool:") ||
+                        starts_with(next, "args:") ||
+                        starts_with(next, "result_field:") ||
+                        starts_with(next, "content:") ||
+                        starts_with(next, "provider:")) {
+                        break;
+                    }
+                    char* piece = lines[i];
+                    if (strncmp(piece, "    ", 4) == 0) piece += 4;
+                    else if (strncmp(piece, "  ", 2) == 0) piece += 2;
+                    rtrim_inplace(piece);
+                    if (append_text(&acc, &cap, &used, piece) != 0 ||
+                        append_text(&acc, &cap, &used, "\n") != 0) {
+                        free(acc);
+                        free(lines);
+                        free(tpl);
+                        prompt_template_free(out_template);
+                        return -1;
+                    }
+                    i++;
+                }
+                rtrim_inplace(acc);
+                out_template->sections[current].provider_content_template = acc;
+                continue;
+            }
+
+            out_template->sections[current].provider_content_template = strdup(provider_val);
+            i++;
+            continue;
+        }
+
+        i++;
+    }
+
+    free(lines);
+    free(tpl);
+    return 0;
+}
+
+static int append_message_object(cJSON* messages, const char* role, const char* content) {
+    if (!messages || !role) return -1;
+    cJSON* msg = cJSON_CreateObject();
+    if (!msg) return -1;
+    cJSON_AddStringToObject(msg, "role", role);
+    cJSON_AddStringToObject(msg, "content", content ? content : "");
+    cJSON_AddItemToArray(messages, msg);
+    return 0;
+}
+
+static char* extract_tool_result_content(const prompt_template_section_t* sec, const char* tool_result_json) {
+    if (!tool_result_json) return strdup("");
+
+    cJSON* root = cJSON_Parse(tool_result_json);
+    if (!root || !cJSON_IsObject(root)) {
+        cJSON_Delete(root);
+        return strdup(tool_result_json);
+    }
+
+    cJSON* success = cJSON_GetObjectItemCaseSensitive(root, "success");
+    if (success && cJSON_IsBool(success) && !cJSON_IsTrue(success)) {
+        cJSON_Delete(root);
+        return strdup("");
+    }
+
+    const char* field_name = (sec && sec->result_field && sec->result_field[0] != '\0')
+                                 ? sec->result_field
+                                 : "content";
+
+    cJSON* field = cJSON_GetObjectItemCaseSensitive(root, field_name);
+    if (!field) {
+        field = cJSON_GetObjectItemCaseSensitive(root, "content");
+    }
+
+    char* out = NULL;
+    if (field && cJSON_IsString(field) && field->valuestring) {
+        out = strdup(field->valuestring);
+    } else if (field) {
+        out = cJSON_PrintUnformatted(field);
+    } else {
+        out = cJSON_PrintUnformatted(root);
+    }
+
+    cJSON_Delete(root);
+    return out ? out : strdup("");
+}
+
+cJSON* prompt_template_build_messages(const prompt_template_t* tmpl,
+                                      const char* provider_name,
+                                      tools_context_t* tools_ctx,
+                                      cJSON* dm_history_messages,
+                                      int dm_history_default_limit,
+                                      prompt_template_emit_hook_fn emit_hook,
+                                      void* emit_hook_user_data) {
+    if (!tmpl) return NULL;
+
+    cJSON* out = cJSON_CreateArray();
+    if (!out) return NULL;
+
+    int out_idx = 0;
+    if (tmpl->personality && tmpl->personality[0] != '\0') {
+        if (append_message_object(out, "system", tmpl->personality) != 0) {
+            cJSON_Delete(out);
+            return NULL;
+        }
+        if (emit_hook) emit_hook("system_prompt", out_idx, emit_hook_user_data);
+        out_idx++;
+    }
+
+    for (int i = 0; i < tmpl->section_count; i++) {
+        const prompt_template_section_t* sec = &tmpl->sections[i];
+        const char* role = sec->role[0] ? sec->role : "system";
+
+        if (strcmp(role, "expand") == 0) {
+            if (!dm_history_messages || !cJSON_IsArray(dm_history_messages)) {
+                continue;
+            }
+            int total = cJSON_GetArraySize(dm_history_messages);
+            int lim = sec->limit > 0 ? sec->limit : dm_history_default_limit;
+            int start = (lim > 0 && total > lim) ? (total - lim) : 0;
+
+            for (int j = start; j < total; j++) {
+                cJSON* item = cJSON_GetArrayItem(dm_history_messages, j);
+                if (!item || !cJSON_IsObject(item)) continue;
+                cJSON* dup = cJSON_Duplicate(item, 1);
+                if (!dup) {
+                    cJSON_Delete(out);
+                    return NULL;
+                }
+                cJSON_AddItemToArray(out, dup);
+                if (emit_hook) emit_hook(sec->name[0] ? sec->name : "context_part", out_idx, emit_hook_user_data);
+                out_idx++;
+            }
+            continue;
+        }
+
+        char* resolved = NULL;
+
+        if (sec->tool_name && sec->tool_name[0] != '\0' && tools_ctx) {
+            const char* args_json = (sec->tool_args && sec->tool_args[0] != '\0') ? sec->tool_args : "{}";
+            char* tool_result = tools_execute(tools_ctx, sec->tool_name, args_json);
+            resolved = extract_tool_result_content(sec, tool_result);
+            free(tool_result);
+        } else {
+            const char* tpl = sec->content_template;
+            if (provider_name && sec->provider_name && sec->provider_content_template &&
+                strcmp(provider_name, sec->provider_name) == 0) {
+                tpl = sec->provider_content_template;
+            }
+            resolved = strdup(tpl ? tpl : "");
+        }
+        if (!resolved) {
+            cJSON_Delete(out);
+            return NULL;
+        }
+
+        if (sec->skip_if_empty) {
+            char* chk = ltrim_inplace(resolved);
+            if (chk && *chk == '\0') {
+                free(resolved);
+                continue;
+            }
+        }
+
+        if (append_message_object(out, role, resolved) != 0) {
+            free(resolved);
+            cJSON_Delete(out);
+            return NULL;
+        }
+        if (emit_hook) emit_hook(sec->name[0] ? sec->name : "context_part", out_idx, emit_hook_user_data);
+        out_idx++;
+        free(resolved);
+    }
+
+    return out;
+}
+
+void prompt_template_free(prompt_template_t* tmpl) {
+    if (!tmpl) return;
+
+    free(tmpl->personality);
+    tmpl->personality = NULL;
+
+    for (int i = 0; i < tmpl->section_count; i++) {
+        free(tmpl->sections[i].content_template);
+        tmpl->sections[i].content_template = NULL;
+        free(tmpl->sections[i].tool_name);
+        tmpl->sections[i].tool_name = NULL;
+        free(tmpl->sections[i].tool_args);
+        tmpl->sections[i].tool_args = NULL;
+        free(tmpl->sections[i].result_field);
+        tmpl->sections[i].result_field = NULL;
+        free(tmpl->sections[i].provider_name);
+        tmpl->sections[i].provider_name = NULL;
+        free(tmpl->sections[i].provider_content_template);
+        tmpl->sections[i].provider_content_template = NULL;
+        tmpl->sections[i].name[0] = '\0';
+        tmpl->sections[i].role[0] = '\0';
+        tmpl->sections[i].limit = 0;
+        tmpl->sections[i].skip_if_empty = 0;
+    }
+
+    tmpl->section_count = 0;
+}

src/prompt_template.h

@@ -0,0 +1,47 @@
+#ifndef DIDACTYL_PROMPT_TEMPLATE_H
+#define DIDACTYL_PROMPT_TEMPLATE_H
+
+#include "cjson/cJSON.h"
+#include "tools.h"
+
+#define PROMPT_TEMPLATE_MAX_SECTIONS 32
+#define PROMPT_TEMPLATE_MAX_NAME_LEN 64
+#define PROMPT_TEMPLATE_MAX_ROLE_LEN 16
+#define PROMPT_TEMPLATE_MARKER "---template---"
+
+typedef struct {
+    char name[PROMPT_TEMPLATE_MAX_NAME_LEN];
+    char role[PROMPT_TEMPLATE_MAX_ROLE_LEN];
+    char* content_template;
+    char* tool_name;
+    char* tool_args;
+    char* result_field;
+    int limit;
+    int skip_if_empty;
+    char* provider_name;
+    char* provider_content_template;
+} prompt_template_section_t;
+
+typedef struct {
+    char* personality;
+    prompt_template_section_t sections[PROMPT_TEMPLATE_MAX_SECTIONS];
+    int section_count;
+} prompt_template_t;
+
+typedef void (*prompt_template_emit_hook_fn)(const char* section_name,
+                                             int message_index,
+                                             void* user_data);
+
+int prompt_template_parse(const char* soul_content, prompt_template_t* out_template);
+
+cJSON* prompt_template_build_messages(const prompt_template_t* tmpl,
+                                      const char* provider_name,
+                                      tools_context_t* tools_ctx,
+                                      cJSON* dm_history_messages,
+                                      int dm_history_default_limit,
+                                      prompt_template_emit_hook_fn emit_hook,
+                                      void* emit_hook_user_data);
+
+void prompt_template_free(prompt_template_t* tmpl);
+
+#endif

src/tools.c

@@ -1,266 +0,0 @@
-#define _POSIX_C_SOURCE 200809L
-
-#include "tools.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "cjson/cJSON.h"
-#include "nostr_handler.h"
-
-static char* json_error(const char* msg) {
-    cJSON* root = cJSON_CreateObject();
-    if (!root) return NULL;
-    cJSON_AddBoolToObject(root, "success", 0);
-    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
-    char* out = cJSON_PrintUnformatted(root);
-    cJSON_Delete(root);
-    return out;
-}
-
-static char* json_success_with_message(const char* msg) {
-    cJSON* root = cJSON_CreateObject();
-    if (!root) return NULL;
-    cJSON_AddBoolToObject(root, "success", 1);
-    cJSON_AddStringToObject(root, "message", msg ? msg : "ok");
-    char* out = cJSON_PrintUnformatted(root);
-    cJSON_Delete(root);
-    return out;
-}
-
-int tools_init(tools_context_t* ctx, didactyl_config_t* cfg) {
-    if (!ctx || !cfg) return -1;
-    memset(ctx, 0, sizeof(*ctx));
-    ctx->cfg = cfg;
-    return 0;
-}
-
-void tools_cleanup(tools_context_t* ctx) {
-    if (!ctx) return;
-    memset(ctx, 0, sizeof(*ctx));
-}
-
-char* tools_build_openai_schema_json(const tools_context_t* ctx) {
-    (void)ctx;
-
-    cJSON* tools = cJSON_CreateArray();
-    if (!tools) return NULL;
-
-    cJSON* t1 = cJSON_CreateObject();
-    cJSON* t1_fn = cJSON_CreateObject();
-    cJSON* t1_params = cJSON_CreateObject();
-    cJSON* t1_props = cJSON_CreateObject();
-    cJSON* t1_required = cJSON_CreateArray();
-
-    cJSON_AddStringToObject(t1, "type", "function");
-    cJSON_AddStringToObject(t1_fn, "name", "nostr_post");
-    cJSON_AddStringToObject(t1_fn, "description", "Publish a Nostr event to connected relays");
-    cJSON_AddStringToObject(t1_params, "type", "object");
-    cJSON_AddItemToObject(t1_params, "properties", t1_props);
-    cJSON_AddItemToObject(t1_params, "required", t1_required);
-
-    cJSON* p_kind = cJSON_CreateObject();
-    cJSON_AddStringToObject(p_kind, "type", "integer");
-    cJSON_AddItemToObject(t1_props, "kind", p_kind);
-    cJSON* p_content = cJSON_CreateObject();
-    cJSON_AddStringToObject(p_content, "type", "string");
-    cJSON_AddItemToObject(t1_props, "content", p_content);
-    cJSON_AddItemToArray(t1_required, cJSON_CreateString("kind"));
-    cJSON_AddItemToArray(t1_required, cJSON_CreateString("content"));
-
-    cJSON_AddItemToObject(t1_fn, "parameters", t1_params);
-    cJSON_AddItemToObject(t1, "function", t1_fn);
-    cJSON_AddItemToArray(tools, t1);
-
-    cJSON* t2 = cJSON_CreateObject();
-    cJSON* t2_fn = cJSON_CreateObject();
-    cJSON* t2_params = cJSON_CreateObject();
-    cJSON* t2_props = cJSON_CreateObject();
-    cJSON* t2_required = cJSON_CreateArray();
-
-    cJSON_AddStringToObject(t2, "type", "function");
-    cJSON_AddStringToObject(t2_fn, "name", "nostr_query");
-    cJSON_AddStringToObject(t2_fn, "description", "Query events from relays using a Nostr filter");
-    cJSON_AddStringToObject(t2_params, "type", "object");
-    cJSON_AddItemToObject(t2_params, "properties", t2_props);
-    cJSON_AddItemToObject(t2_params, "required", t2_required);
-
-    cJSON* p_filter = cJSON_CreateObject();
-    cJSON_AddStringToObject(p_filter, "type", "object");
-    cJSON_AddItemToObject(t2_props, "filter", p_filter);
-    cJSON* p_timeout = cJSON_CreateObject();
-    cJSON_AddStringToObject(p_timeout, "type", "integer");
-    cJSON_AddItemToObject(t2_props, "timeout_ms", p_timeout);
-    cJSON_AddItemToArray(t2_required, cJSON_CreateString("filter"));
-
-    cJSON_AddItemToObject(t2_fn, "parameters", t2_params);
-    cJSON_AddItemToObject(t2, "function", t2_fn);
-    cJSON_AddItemToArray(tools, t2);
-
-    cJSON* t3 = cJSON_CreateObject();
-    cJSON* t3_fn = cJSON_CreateObject();
-    cJSON* t3_params = cJSON_CreateObject();
-    cJSON* t3_props = cJSON_CreateObject();
-    cJSON* t3_required = cJSON_CreateArray();
-
-    cJSON_AddStringToObject(t3, "type", "function");
-    cJSON_AddStringToObject(t3_fn, "name", "shell_exec");
-    cJSON_AddStringToObject(t3_fn, "description", "Execute a shell command and return stdout/stderr");
-    cJSON_AddStringToObject(t3_params, "type", "object");
-    cJSON_AddItemToObject(t3_params, "properties", t3_props);
-    cJSON_AddItemToObject(t3_params, "required", t3_required);
-
-    cJSON* p_cmd = cJSON_CreateObject();
-    cJSON_AddStringToObject(p_cmd, "type", "string");
-    cJSON_AddItemToObject(t3_props, "command", p_cmd);
-    cJSON_AddItemToArray(t3_required, cJSON_CreateString("command"));
-
-    cJSON_AddItemToObject(t3_fn, "parameters", t3_params);
-    cJSON_AddItemToObject(t3, "function", t3_fn);
-    cJSON_AddItemToArray(tools, t3);
-
-    char* out = cJSON_PrintUnformatted(tools);
-    cJSON_Delete(tools);
-    return out;
-}
-
-static char* execute_nostr_post(const char* args_json) {
-    cJSON* args = cJSON_Parse(args_json ? args_json : "{}");
-    if (!args) return json_error("invalid arguments JSON");
-
-    cJSON* kind = cJSON_GetObjectItemCaseSensitive(args, "kind");
-    cJSON* content = cJSON_GetObjectItemCaseSensitive(args, "content");
-    if (!kind || !cJSON_IsNumber(kind) || !content || !cJSON_IsString(content) || !content->valuestring) {
-        cJSON_Delete(args);
-        return json_error("nostr_post requires integer kind and string content");
-    }
-
-    int rc = nostr_handler_publish_kind_event((int)kind->valuedouble, content->valuestring, NULL);
-    cJSON_Delete(args);
-    if (rc != 0) return json_error("nostr_post failed");
-
-    return json_success_with_message("nostr_post published");
-}
-
-static char* execute_nostr_query(const char* args_json) {
-    cJSON* args = cJSON_Parse(args_json ? args_json : "{}");
-    if (!args) return json_error("invalid arguments JSON");
-
-    cJSON* filter = cJSON_GetObjectItemCaseSensitive(args, "filter");
-    cJSON* timeout = cJSON_GetObjectItemCaseSensitive(args, "timeout_ms");
-    if (!filter || !cJSON_IsObject(filter)) {
-        cJSON_Delete(args);
-        return json_error("nostr_query requires object filter");
-    }
-
-    cJSON* filter_dup = cJSON_Duplicate(filter, 1);
-    if (!filter_dup) {
-        cJSON_Delete(args);
-        return json_error("failed to duplicate filter");
-    }
-
-    int timeout_ms = (timeout && cJSON_IsNumber(timeout)) ? (int)timeout->valuedouble : 8000;
-    char* events_json = nostr_handler_query_json(filter_dup, timeout_ms);
-    cJSON_Delete(filter_dup);
-    cJSON_Delete(args);
-
-    if (!events_json) return json_error("nostr_query failed");
-
-    cJSON* out = cJSON_CreateObject();
-    if (!out) {
-        free(events_json);
-        return NULL;
-    }
-
-    cJSON* events = cJSON_Parse(events_json);
-    free(events_json);
-    if (!events) {
-        cJSON_Delete(out);
-        return json_error("nostr_query returned invalid JSON");
-    }
-
-    cJSON_AddBoolToObject(out, "success", 1);
-    cJSON_AddItemToObject(out, "events", events);
-    char* json = cJSON_PrintUnformatted(out);
-    cJSON_Delete(out);
-    return json;
-}
-
-static char* execute_shell_exec(tools_context_t* ctx, const char* args_json) {
-    if (!ctx || !ctx->cfg) return json_error("tool context unavailable");
-    if (!ctx->cfg->tools.shell.enabled) return json_error("shell tool disabled");
-
-    cJSON* args = cJSON_Parse(args_json ? args_json : "{}");
-    if (!args) return json_error("invalid arguments JSON");
-
-    cJSON* command = cJSON_GetObjectItemCaseSensitive(args, "command");
-    if (!command || !cJSON_IsString(command) || !command->valuestring) {
-        cJSON_Delete(args);
-        return json_error("shell_exec requires string command");
-    }
-
-    const char* cwd = ctx->cfg->tools.shell.working_directory[0] != '\0'
-                          ? ctx->cfg->tools.shell.working_directory
-                          : ".";
-    int timeout_s = ctx->cfg->tools.shell.timeout_seconds > 0 ? ctx->cfg->tools.shell.timeout_seconds : 30;
-
-    char cmd[4096];
-    snprintf(cmd,
-             sizeof(cmd),
-             "cd %s && timeout %ds sh -lc %s 2>&1",
-             cwd,
-             timeout_s,
-             command->valuestring);
-
-    FILE* fp = popen(cmd, "r");
-    cJSON_Delete(args);
-    if (!fp) return json_error("failed to execute command");
-
-    int max_bytes = ctx->cfg->tools.shell.max_output_bytes > 0 ? ctx->cfg->tools.shell.max_output_bytes : 65536;
-    char* output = (char*)calloc((size_t)max_bytes + 1U, 1U);
-    if (!output) {
-        pclose(fp);
-        return json_error("allocation failure");
-    }
-
-    size_t used = 0;
-    while (!feof(fp) && used < (size_t)max_bytes) {
-        size_t n = fread(output + used, 1, (size_t)max_bytes - used, fp);
-        used += n;
-        if (n == 0) break;
-    }
-
-    int status = pclose(fp);
-
-    cJSON* out = cJSON_CreateObject();
-    if (!out) {
-        free(output);
-        return NULL;
-    }
-
-    cJSON_AddBoolToObject(out, "success", status == 0 ? 1 : 0);
-    cJSON_AddNumberToObject(out, "exit_status", status);
-    cJSON_AddStringToObject(out, "output", output);
-    free(output);
-
-    char* json = cJSON_PrintUnformatted(out);
-    cJSON_Delete(out);
-    return json;
-}
-
-char* tools_execute(tools_context_t* ctx, const char* tool_name, const char* args_json) {
-    if (!tool_name) return json_error("missing tool name");
-
-    if (strcmp(tool_name, "nostr_post") == 0) {
-        return execute_nostr_post(args_json);
-    }
-    if (strcmp(tool_name, "nostr_query") == 0) {
-        return execute_nostr_query(args_json);
-    }
-    if (strcmp(tool_name, "shell_exec") == 0) {
-        return execute_shell_exec(ctx, args_json);
-    }
-
-    return json_error("unknown tool");
-}

src/tools/tool_admin.c

@@ -0,0 +1,222 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cjson/cJSON.h"
+#include "../nostr_handler.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+char* execute_admin_identity(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+
+    const char* tier_text = "Sender tier unknown.";
+    if (ctx->template_sender_tier == 1) {
+        tier_text = "This message has been cryptographically verified as coming from your administrator.";
+    } else if (ctx->template_sender_tier == 2) {
+        tier_text = "This message is from a web-of-trust contact (not the administrator).";
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "admin_pubkey", ctx->cfg->admin.pubkey[0] ? ctx->cfg->admin.pubkey : "unknown");
+    cJSON_AddStringToObject(out, "sender_verification", tier_text);
+
+    char content[768];
+    snprintf(content,
+             sizeof(content),
+             "## Administrator Identity (source: config.admin.pubkey)\n\n"
+             "This is your administrator! Admin pubkey (hex): %s\n\n"
+             "%s",
+             ctx->cfg->admin.pubkey[0] ? ctx->cfg->admin.pubkey : "unknown",
+             tier_text);
+    cJSON_AddStringToObject(out, "content", content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_admin_profile(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char* kind0 = nostr_handler_get_admin_kind0_context();
+    const char* profile_json = (kind0 && kind0[0]) ? kind0 : "{}";
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(kind0);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "admin_kind0_json", profile_json);
+
+    size_t content_len = strlen("## Administrator Kind 0 Profile (source: nostr kind 0)\n\nAdministrator kind 0 profile content (JSON): ") + strlen(profile_json) + 1U;
+    char* content = (char*)malloc(content_len);
+    if (!content) {
+        cJSON_Delete(out);
+        free(kind0);
+        return NULL;
+    }
+    snprintf(content,
+             content_len,
+             "## Administrator Kind 0 Profile (source: nostr kind 0)\n\nAdministrator kind 0 profile content (JSON): %s",
+             profile_json);
+    cJSON_AddStringToObject(out, "content", content);
+    free(content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(kind0);
+    return json;
+}
+
+char* execute_nostr_admin_contacts(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char* kind3 = nostr_handler_get_admin_kind3_context();
+    const char* contacts_json = (kind3 && kind3[0]) ? kind3 : "[]";
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(kind3);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "admin_kind3_json", contacts_json);
+
+    size_t content_len = strlen("## Administrator Kind 3 Contacts (source: nostr kind 3)\n\nAdministrator contacts (JSON): ") + strlen(contacts_json) + 1U;
+    char* content = (char*)malloc(content_len);
+    if (!content) {
+        cJSON_Delete(out);
+        free(kind3);
+        return NULL;
+    }
+    snprintf(content,
+             content_len,
+             "## Administrator Kind 3 Contacts (source: nostr kind 3)\n\nAdministrator contacts (JSON): %s",
+             contacts_json);
+    cJSON_AddStringToObject(out, "content", content);
+    free(content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(kind3);
+    return json;
+}
+
+char* execute_nostr_admin_relays(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char* kind10002 = nostr_handler_get_admin_kind10002_context();
+    const char* relays_json = (kind10002 && kind10002[0]) ? kind10002 : "[]";
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(kind10002);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "admin_kind10002_json", relays_json);
+
+    size_t content_len = strlen("## Administrator Kind 10002 Relays (source: nostr kind 10002)\n\nAdministrator relay list (JSON): ") + strlen(relays_json) + 1U;
+    char* content = (char*)malloc(content_len);
+    if (!content) {
+        cJSON_Delete(out);
+        free(kind10002);
+        return NULL;
+    }
+    snprintf(content,
+             content_len,
+             "## Administrator Kind 10002 Relays (source: nostr kind 10002)\n\nAdministrator relay list (JSON): %s",
+             relays_json);
+    cJSON_AddStringToObject(out, "content", content);
+    free(content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(kind10002);
+    return json;
+}
+
+char* execute_nostr_admin_notes(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char* notes = nostr_handler_get_admin_kind1_notes_context();
+    const char* notes_text = (notes && notes[0]) ? notes : "";
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(notes);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "admin_notes_content", notes_text);
+
+    size_t content_len = strlen("## Administrator Recent Kind 1 Notes\n\n") + strlen(notes_text) + 1U;
+    char* content = (char*)malloc(content_len);
+    if (!content) {
+        cJSON_Delete(out);
+        free(notes);
+        return NULL;
+    }
+    snprintf(content,
+             content_len,
+             "## Administrator Recent Kind 1 Notes\n\n%s",
+             notes_text);
+    cJSON_AddStringToObject(out, "content", content);
+    free(content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(notes);
+    return json;
+}

src/tools/tool_agent.c

@@ -0,0 +1,257 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cjson/cJSON.h"
+#include "../main.h"
+#include "../nostr_handler.h"
+#include "../../nostr_core_lib/nostr_core/nostr_core.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+char* execute_message_current(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "content", ctx->template_current_user_message ? ctx->template_current_user_message : "");
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_agent_identity(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char npub[128] = {0};
+    if (nostr_key_to_bech32(ctx->cfg->keys.public_key, "npub", npub) != NOSTR_SUCCESS) {
+        strcpy(npub, "unknown");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "agent_pubkey", ctx->cfg->keys.public_key_hex[0] ? ctx->cfg->keys.public_key_hex : "unknown");
+    cJSON_AddStringToObject(out, "agent_npub", npub);
+
+    char content[384];
+    snprintf(content,
+             sizeof(content),
+             "## Agent Identity\n\nYour pubkey (hex): %s\nYour npub: %s",
+             ctx->cfg->keys.public_key_hex[0] ? ctx->cfg->keys.public_key_hex : "unknown",
+             npub);
+    cJSON_AddStringToObject(out, "content", content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_agent_profile(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char* kind0 = nostr_handler_get_agent_kind0_context();
+    const char* profile_json = (kind0 && kind0[0]) ? kind0 : "{}";
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(kind0);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "agent_kind0_json", profile_json);
+
+    size_t content_len = strlen("## Agent Kind 0 Profile (source: nostr kind 0)\n\nAgent kind 0 profile content (JSON): ") + strlen(profile_json) + 1U;
+    char* content = (char*)malloc(content_len);
+    if (!content) {
+        cJSON_Delete(out);
+        free(kind0);
+        return NULL;
+    }
+    snprintf(content,
+             content_len,
+             "## Agent Kind 0 Profile (source: nostr kind 0)\n\nAgent kind 0 profile content (JSON): %s",
+             profile_json);
+    cJSON_AddStringToObject(out, "content", content);
+    free(content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(kind0);
+    return json;
+}
+
+char* execute_nostr_agent_contacts(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char* kind3 = nostr_handler_get_agent_kind3_context();
+    const char* contacts_json = (kind3 && kind3[0]) ? kind3 : "[]";
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(kind3);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "agent_kind3_json", contacts_json);
+
+    size_t content_len = strlen("## Agent Kind 3 Contacts (source: nostr kind 3)\n\nAgent contacts (JSON): ") + strlen(contacts_json) + 1U;
+    char* content = (char*)malloc(content_len);
+    if (!content) {
+        cJSON_Delete(out);
+        free(kind3);
+        return NULL;
+    }
+    snprintf(content,
+             content_len,
+             "## Agent Kind 3 Contacts (source: nostr kind 3)\n\nAgent contacts (JSON): %s",
+             contacts_json);
+    cJSON_AddStringToObject(out, "content", content);
+    free(content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(kind3);
+    return json;
+}
+
+char* execute_nostr_agent_relays(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char* kind10002 = nostr_handler_get_agent_kind10002_context();
+    const char* relays_json = (kind10002 && kind10002[0]) ? kind10002 : "[]";
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(kind10002);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "agent_kind10002_json", relays_json);
+
+    size_t content_len = strlen("## Agent Kind 10002 Relays (source: nostr kind 10002)\n\nAgent relay list (JSON): ") + strlen(relays_json) + 1U;
+    char* content = (char*)malloc(content_len);
+    if (!content) {
+        cJSON_Delete(out);
+        free(kind10002);
+        return NULL;
+    }
+    snprintf(content,
+             content_len,
+             "## Agent Kind 10002 Relays (source: nostr kind 10002)\n\nAgent relay list (JSON): %s",
+             relays_json);
+    cJSON_AddStringToObject(out, "content", content);
+    free(content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(kind10002);
+    return json;
+}
+
+char* execute_nostr_agent_notes(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char* notes = nostr_handler_get_agent_kind1_notes_context();
+    const char* notes_text = (notes && notes[0]) ? notes : "";
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(notes);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "agent_notes_content", notes_text);
+
+    size_t content_len = strlen("## Agent Recent Kind 1 Notes\n\n") + strlen(notes_text) + 1U;
+    char* content = (char*)malloc(content_len);
+    if (!content) {
+        cJSON_Delete(out);
+        free(notes);
+        return NULL;
+    }
+    snprintf(content,
+             content_len,
+             "## Agent Recent Kind 1 Notes\n\n%s",
+             notes_text);
+    cJSON_AddStringToObject(out, "content", content);
+    free(content);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(notes);
+    return json;
+}
+
+char* execute_agent_version(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "name", DIDACTYL_NAME);
+    cJSON_AddStringToObject(out, "description", DIDACTYL_DESCRIPTION);
+    cJSON_AddStringToObject(out, "software", DIDACTYL_SOFTWARE);
+    cJSON_AddStringToObject(out, "version", DIDACTYL_VERSION);
+    cJSON_AddNumberToObject(out, "version_major", DIDACTYL_VERSION_MAJOR);
+    cJSON_AddNumberToObject(out, "version_minor", DIDACTYL_VERSION_MINOR);
+    cJSON_AddNumberToObject(out, "version_patch", DIDACTYL_VERSION_PATCH);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}

src/tools/tool_local.c

@@ -0,0 +1,515 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <curl/curl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "cjson/cJSON.h"
+
+typedef struct {
+    char* data;
+    size_t len;
+    size_t cap;
+    size_t max_bytes;
+    int truncated;
+} local_http_fetch_buffer_t;
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+static int is_safe_relative_path_local(const char* path) {
+    if (!path || path[0] == '\0') return 0;
+    if (path[0] == '/') return 0;
+    if (strstr(path, "..") != NULL) return 0;
+    if (strchr(path, '\\') != NULL) return 0;
+    return 1;
+}
+
+static int build_tool_path_local(tools_context_t* ctx, const char* rel_path, char* out, size_t out_size) {
+    if (!ctx || !ctx->cfg || !rel_path || !out || out_size == 0) return -1;
+    if (!is_safe_relative_path_local(rel_path)) return -1;
+
+    const char* cwd = ctx->cfg->tools.shell.working_directory[0] != '\0'
+                          ? ctx->cfg->tools.shell.working_directory
+                          : ".";
+
+    int n = 0;
+    if (strcmp(cwd, ".") == 0) {
+        n = snprintf(out, out_size, "%s", rel_path);
+    } else {
+        n = snprintf(out, out_size, "%s/%s", cwd, rel_path);
+    }
+
+    if (n < 0 || (size_t)n >= out_size) return -1;
+    return 0;
+}
+
+static char* shell_quote_single_local(const char* in) {
+    if (!in) return NULL;
+
+    size_t len = strlen(in);
+    size_t extra = 2U;
+    for (size_t i = 0; i < len; i++) {
+        if (in[i] == '\'') {
+            extra += 4U;
+        } else {
+            extra += 1U;
+        }
+    }
+
+    char* out = (char*)malloc(extra + 1U);
+    if (!out) return NULL;
+
+    size_t j = 0;
+    out[j++] = '\'';
+    for (size_t i = 0; i < len; i++) {
+        if (in[i] == '\'') {
+            out[j++] = '\'';
+            out[j++] = '\\';
+            out[j++] = '\'';
+            out[j++] = '\'';
+        } else {
+            out[j++] = in[i];
+        }
+    }
+    out[j++] = '\'';
+    out[j] = '\0';
+
+    return out;
+}
+
+static size_t local_http_fetch_write_cb_local(void* contents, size_t size, size_t nmemb, void* userp) {
+    local_http_fetch_buffer_t* rb = (local_http_fetch_buffer_t*)userp;
+    size_t total = size * nmemb;
+    if (!rb || total == 0) return total;
+
+    if (rb->len >= rb->max_bytes) {
+        rb->truncated = 1;
+        return total;
+    }
+
+    size_t allowed = rb->max_bytes - rb->len;
+    size_t to_copy = total <= allowed ? total : allowed;
+
+    if (rb->len + to_copy + 1U > rb->cap) {
+        size_t new_cap = rb->cap == 0 ? 1024U : rb->cap;
+        while (new_cap < rb->len + to_copy + 1U) {
+            new_cap *= 2U;
+        }
+        char* bigger = (char*)realloc(rb->data, new_cap);
+        if (!bigger) return 0;
+        rb->data = bigger;
+        rb->cap = new_cap;
+    }
+
+    memcpy(rb->data + rb->len, contents, to_copy);
+    rb->len += to_copy;
+    rb->data[rb->len] = '\0';
+
+    if (to_copy < total) {
+        rb->truncated = 1;
+    }
+
+    return total;
+}
+
+static const char* detect_ca_bundle_path_for_tools_local(void) {
+    const char* env = getenv("SSL_CERT_FILE");
+    if (env && env[0] != '\0' && access(env, R_OK) == 0) {
+        return env;
+    }
+
+    static const char* candidates[] = {
+        "/etc/ssl/certs/ca-certificates.crt",
+        "/etc/ssl/cert.pem",
+        "/etc/pki/tls/certs/ca-bundle.crt",
+        "/etc/ssl/ca-bundle.pem"
+    };
+
+    for (size_t i = 0; i < sizeof(candidates) / sizeof(candidates[0]); i++) {
+        if (access(candidates[i], R_OK) == 0) {
+            return candidates[i];
+        }
+    }
+
+    return NULL;
+}
+
+char* execute_local_http_fetch(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* url = cJSON_GetObjectItemCaseSensitive(args, "url");
+    cJSON* method = cJSON_GetObjectItemCaseSensitive(args, "method");
+    cJSON* headers = cJSON_GetObjectItemCaseSensitive(args, "headers");
+    cJSON* body = cJSON_GetObjectItemCaseSensitive(args, "body");
+    cJSON* timeout = cJSON_GetObjectItemCaseSensitive(args, "timeout_seconds");
+    cJSON* maxb = cJSON_GetObjectItemCaseSensitive(args, "max_bytes");
+
+    if (!url || !cJSON_IsString(url) || !url->valuestring || url->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("local_http_fetch requires string url");
+    }
+    if (headers && !cJSON_IsArray(headers)) {
+        cJSON_Delete(args);
+        return json_error_local("local_http_fetch headers must be an array when provided");
+    }
+    if (body && !cJSON_IsString(body)) {
+        cJSON_Delete(args);
+        return json_error_local("local_http_fetch body must be a string when provided");
+    }
+
+    const char* method_str = (method && cJSON_IsString(method) && method->valuestring && method->valuestring[0] != '\0')
+                                 ? method->valuestring
+                                 : "GET";
+
+    if (body && cJSON_IsString(body) && body->valuestring && strcasecmp(method_str, "GET") == 0) {
+        cJSON_Delete(args);
+        return json_error_local("local_http_fetch GET requests cannot include body");
+    }
+
+    int default_timeout = ctx->cfg->tools.local_http_fetch_default_timeout_seconds > 0
+                              ? ctx->cfg->tools.local_http_fetch_default_timeout_seconds
+                              : 20;
+    int max_timeout = ctx->cfg->tools.local_http_fetch_max_timeout_seconds > 0
+                          ? ctx->cfg->tools.local_http_fetch_max_timeout_seconds
+                          : 120;
+    if (default_timeout > max_timeout) {
+        default_timeout = max_timeout;
+    }
+
+    int timeout_seconds = (timeout && cJSON_IsNumber(timeout)) ? (int)timeout->valuedouble : default_timeout;
+    if (timeout_seconds <= 0) timeout_seconds = default_timeout;
+    if (timeout_seconds > max_timeout) timeout_seconds = max_timeout;
+
+    int hard_max = ctx->cfg->tools.shell.max_output_bytes > 0 ? ctx->cfg->tools.shell.max_output_bytes : 65536;
+    int max_bytes = (maxb && cJSON_IsNumber(maxb)) ? (int)maxb->valuedouble : hard_max;
+    if (max_bytes <= 0 || max_bytes > hard_max) max_bytes = hard_max;
+
+    CURL* curl = curl_easy_init();
+    if (!curl) {
+        cJSON_Delete(args);
+        return json_error_local("local_http_fetch failed to initialize curl");
+    }
+
+    local_http_fetch_buffer_t rb;
+    memset(&rb, 0, sizeof(rb));
+    rb.max_bytes = (size_t)max_bytes;
+
+    struct curl_slist* req_headers = NULL;
+    req_headers = curl_slist_append(req_headers, "Accept: */*");
+
+    if (headers && cJSON_IsArray(headers)) {
+        int n = cJSON_GetArraySize(headers);
+        for (int i = 0; i < n; i++) {
+            cJSON* h = cJSON_GetArrayItem(headers, i);
+            if (h && cJSON_IsString(h) && h->valuestring && h->valuestring[0] != '\0') {
+                req_headers = curl_slist_append(req_headers, h->valuestring);
+            }
+        }
+    }
+
+    curl_easy_setopt(curl, CURLOPT_URL, url->valuestring);
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, (long)timeout_seconds);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, local_http_fetch_write_cb_local);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &rb);
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, req_headers);
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "didactyl/local_http_fetch");
+
+    const char* ca_bundle = detect_ca_bundle_path_for_tools_local();
+    if (ca_bundle) {
+        curl_easy_setopt(curl, CURLOPT_CAINFO, ca_bundle);
+    }
+
+    if (strcasecmp(method_str, "GET") == 0) {
+        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
+    } else if (strcasecmp(method_str, "POST") == 0) {
+        curl_easy_setopt(curl, CURLOPT_POST, 1L);
+        if (body && cJSON_IsString(body) && body->valuestring) {
+            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body->valuestring);
+            curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)strlen(body->valuestring));
+        }
+    } else {
+        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, method_str);
+        if (body && cJSON_IsString(body) && body->valuestring) {
+            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body->valuestring);
+            curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)strlen(body->valuestring));
+        }
+    }
+
+    CURLcode res = curl_easy_perform(curl);
+    long status_code = 0;
+    char* content_type = NULL;
+    char* content_type_copy = NULL;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &status_code);
+    curl_easy_getinfo(curl, CURLINFO_CONTENT_TYPE, &content_type);
+    if (content_type && content_type[0] != '\0') {
+        content_type_copy = strdup(content_type);
+    }
+
+    curl_slist_free_all(req_headers);
+    curl_easy_cleanup(curl);
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(rb.data);
+        return NULL;
+    }
+
+    int http_ok = (status_code >= 200 && status_code < 300) ? 1 : 0;
+    int success = (res == CURLE_OK && http_ok) ? 1 : 0;
+
+    cJSON_AddBoolToObject(out, "success", success);
+    cJSON_AddStringToObject(out, "url", url->valuestring);
+    cJSON_AddStringToObject(out, "method", method_str);
+    cJSON_AddNumberToObject(out, "status_code", status_code);
+    cJSON_AddBoolToObject(out, "http_ok", http_ok);
+    cJSON_AddBoolToObject(out, "truncated", rb.truncated ? 1 : 0);
+    cJSON_AddNumberToObject(out, "bytes_received", (double)rb.len);
+
+    if (content_type_copy && content_type_copy[0] != '\0') {
+        cJSON_AddStringToObject(out, "content_type", content_type_copy);
+    }
+
+    if (res != CURLE_OK) {
+        cJSON_AddStringToObject(out, "curl_error", curl_easy_strerror(res));
+    }
+
+    cJSON_AddStringToObject(out, "body", rb.data ? rb.data : "");
+
+    free(rb.data);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    cJSON_Delete(args);
+    free(content_type_copy);
+    return json;
+}
+
+char* execute_local_shell_exec(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+    if (!ctx->cfg->tools.shell.enabled) return json_error_local("shell tool disabled");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* command = cJSON_GetObjectItemCaseSensitive(args, "command");
+    if (!command || !cJSON_IsString(command) || !command->valuestring || command->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("local_shell_exec requires string command");
+    }
+
+    const char* cwd = ctx->cfg->tools.shell.working_directory[0] != '\0'
+                          ? ctx->cfg->tools.shell.working_directory
+                          : ".";
+    int timeout_s = ctx->cfg->tools.shell.timeout_seconds > 0 ? ctx->cfg->tools.shell.timeout_seconds : 30;
+
+    char* quoted_cwd = shell_quote_single_local(cwd);
+    char* quoted_cmd = shell_quote_single_local(command->valuestring);
+    cJSON_Delete(args);
+
+    if (!quoted_cwd || !quoted_cmd) {
+        free(quoted_cwd);
+        free(quoted_cmd);
+        return json_error_local("allocation failure");
+    }
+
+    int needed = snprintf(NULL,
+                          0,
+                          "cd %s && timeout %ds sh -lc %s 2>&1",
+                          quoted_cwd,
+                          timeout_s,
+                          quoted_cmd);
+    if (needed <= 0) {
+        free(quoted_cwd);
+        free(quoted_cmd);
+        return json_error_local("failed to build shell command");
+    }
+
+    char* cmd = (char*)malloc((size_t)needed + 1U);
+    if (!cmd) {
+        free(quoted_cwd);
+        free(quoted_cmd);
+        return json_error_local("allocation failure");
+    }
+
+    snprintf(cmd,
+             (size_t)needed + 1U,
+             "cd %s && timeout %ds sh -lc %s 2>&1",
+             quoted_cwd,
+             timeout_s,
+             quoted_cmd);
+
+    free(quoted_cwd);
+    free(quoted_cmd);
+
+    FILE* fp = popen(cmd, "r");
+    free(cmd);
+    if (!fp) return json_error_local("failed to execute command");
+
+    int max_bytes = ctx->cfg->tools.shell.max_output_bytes > 0 ? ctx->cfg->tools.shell.max_output_bytes : 65536;
+    char* output = (char*)calloc((size_t)max_bytes + 1U, 1U);
+    if (!output) {
+        pclose(fp);
+        return json_error_local("allocation failure");
+    }
+
+    size_t used = 0;
+    while (!feof(fp) && used < (size_t)max_bytes) {
+        size_t n = fread(output + used, 1, (size_t)max_bytes - used, fp);
+        used += n;
+        if (n == 0) break;
+    }
+
+    int raw_status = pclose(fp);
+    int exit_status = raw_status;
+    if (raw_status != -1) {
+        if (WIFEXITED(raw_status)) {
+            exit_status = WEXITSTATUS(raw_status);
+        } else if (WIFSIGNALED(raw_status)) {
+            exit_status = 128 + WTERMSIG(raw_status);
+        }
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(output);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", exit_status == 0 ? 1 : 0);
+    cJSON_AddNumberToObject(out, "exit_status", exit_status);
+    cJSON_AddStringToObject(out, "output", output);
+    free(output);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_local_file_read(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* path = cJSON_GetObjectItemCaseSensitive(args, "path");
+    cJSON* maxb = cJSON_GetObjectItemCaseSensitive(args, "max_bytes");
+    if (!path || !cJSON_IsString(path) || !path->valuestring) {
+        cJSON_Delete(args);
+        return json_error_local("local_file_read requires string path");
+    }
+
+    int hard_max = ctx->cfg->tools.shell.max_output_bytes > 0 ? ctx->cfg->tools.shell.max_output_bytes : 65536;
+    int max_bytes = (maxb && cJSON_IsNumber(maxb)) ? (int)maxb->valuedouble : hard_max;
+    if (max_bytes <= 0 || max_bytes > hard_max) max_bytes = hard_max;
+
+    char file_path[PATH_MAX];
+    if (build_tool_path_local(ctx, path->valuestring, file_path, sizeof(file_path)) != 0) {
+        cJSON_Delete(args);
+        return json_error_local("local_file_read path is not allowed");
+    }
+
+    FILE* fp = fopen(file_path, "rb");
+    cJSON_Delete(args);
+    if (!fp) return json_error_local("local_file_read failed to open file");
+
+    char* buf = (char*)calloc((size_t)max_bytes + 1U, 1U);
+    if (!buf) {
+        fclose(fp);
+        return json_error_local("allocation failure");
+    }
+
+    size_t n = fread(buf, 1, (size_t)max_bytes, fp);
+    int truncated = !feof(fp) ? 1 : 0;
+    fclose(fp);
+    buf[n] = '\0';
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(buf);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "path", file_path);
+    cJSON_AddNumberToObject(out, "bytes_read", (double)n);
+    cJSON_AddBoolToObject(out, "truncated", truncated);
+    cJSON_AddStringToObject(out, "content", buf);
+    free(buf);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_local_file_write(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* path = cJSON_GetObjectItemCaseSensitive(args, "path");
+    cJSON* content = cJSON_GetObjectItemCaseSensitive(args, "content");
+    cJSON* append = cJSON_GetObjectItemCaseSensitive(args, "append");
+    if (!path || !cJSON_IsString(path) || !path->valuestring ||
+        !content || !cJSON_IsString(content) || !content->valuestring) {
+        cJSON_Delete(args);
+        return json_error_local("local_file_write requires string path and content");
+    }
+
+    char file_path[PATH_MAX];
+    if (build_tool_path_local(ctx, path->valuestring, file_path, sizeof(file_path)) != 0) {
+        cJSON_Delete(args);
+        return json_error_local("local_file_write path is not allowed");
+    }
+
+    const char* content_str = content->valuestring;
+    size_t len = strlen(content_str);
+    int do_append = (append && cJSON_IsBool(append) && cJSON_IsTrue(append)) ? 1 : 0;
+
+    FILE* fp = fopen(file_path, do_append ? "ab" : "wb");
+    cJSON_Delete(args);
+    if (!fp) return json_error_local("local_file_write failed to open file");
+
+    size_t n = fwrite(content_str, 1, len, fp);
+    fclose(fp);
+    if (n != len) return json_error_local("local_file_write failed to write all bytes");
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "path", file_path);
+    cJSON_AddNumberToObject(out, "bytes_written", (double)n);
+    cJSON_AddBoolToObject(out, "append", do_append);
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}

src/tools/tool_meta.c

@@ -0,0 +1,103 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdlib.h>
+
+#include "cjson/cJSON.h"
+#include "../trigger_manager.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+char* execute_tool_list(tools_context_t* ctx, const char* args_json) {
+    (void)args_json;
+    if (!ctx) {
+        return json_error_local("tool context unavailable");
+    }
+
+    char* schema_json = tools_build_openai_schema_json(ctx);
+    if (!schema_json) {
+        return json_error_local("failed to build tool schemas");
+    }
+
+    cJSON* schema_arr = cJSON_Parse(schema_json);
+    free(schema_json);
+    if (!schema_arr || !cJSON_IsArray(schema_arr)) {
+        cJSON_Delete(schema_arr);
+        return json_error_local("failed to parse tool schemas");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    cJSON* tools = cJSON_CreateArray();
+    if (!out || !tools) {
+        cJSON_Delete(schema_arr);
+        cJSON_Delete(out);
+        cJSON_Delete(tools);
+        return json_error_local("out of memory");
+    }
+
+    cJSON* item = NULL;
+    cJSON_ArrayForEach(item, schema_arr) {
+        cJSON* fn = cJSON_GetObjectItemCaseSensitive(item, "function");
+        if (!fn || !cJSON_IsObject(fn)) {
+            continue;
+        }
+
+        cJSON* name = cJSON_GetObjectItemCaseSensitive(fn, "name");
+        if (!name || !cJSON_IsString(name) || !name->valuestring) {
+            continue;
+        }
+
+        cJSON* row = cJSON_CreateObject();
+        if (!row) {
+            continue;
+        }
+
+        cJSON_AddStringToObject(row, "name", name->valuestring);
+
+        cJSON* description = cJSON_GetObjectItemCaseSensitive(fn, "description");
+        if (description && cJSON_IsString(description) && description->valuestring) {
+            cJSON_AddStringToObject(row, "description", description->valuestring);
+        } else {
+            cJSON_AddStringToObject(row, "description", "");
+        }
+
+        cJSON* parameters = cJSON_GetObjectItemCaseSensitive(fn, "parameters");
+        if (parameters) {
+            cJSON_AddItemToObject(row, "parameters", cJSON_Duplicate(parameters, 1));
+        } else {
+            cJSON_AddItemToObject(row, "parameters", cJSON_CreateObject());
+        }
+
+        cJSON_AddItemToArray(tools, row);
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddNumberToObject(out, "count", (double)cJSON_GetArraySize(tools));
+    cJSON_AddItemToObject(out, "tools", tools);
+
+    char* result = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    cJSON_Delete(schema_arr);
+    return result;
+}
+
+char* execute_trigger_list(tools_context_t* ctx, const char* args_json) {
+    (void)args_json;
+    if (!ctx || !ctx->trigger_manager) {
+        return json_error_local("trigger manager unavailable");
+    }
+    char* status = trigger_manager_status_json(ctx->trigger_manager);
+    if (!status) {
+        return json_error_local("failed to build trigger status");
+    }
+    return status;
+}

src/tools/tool_model.c

@@ -0,0 +1,325 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cjson/cJSON.h"
+#include "../config.h"
+#include "../llm.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+static int json_object_set_string(cJSON* obj, const char* key, const char* value) {
+    if (!obj || !key || !value) return -1;
+    cJSON_DeleteItemFromObjectCaseSensitive(obj, key);
+    cJSON* v = cJSON_CreateString(value);
+    if (!v) return -1;
+    cJSON_AddItemToObject(obj, key, v);
+    return 0;
+}
+
+static char* read_entire_file_local(const char* file_path, size_t* out_bytes) {
+    if (!file_path) return NULL;
+
+    FILE* fp = fopen(file_path, "rb");
+    if (!fp) return NULL;
+
+    if (fseek(fp, 0, SEEK_END) != 0) {
+        fclose(fp);
+        return NULL;
+    }
+
+    long len = ftell(fp);
+    if (len < 0) {
+        fclose(fp);
+        return NULL;
+    }
+
+    if (fseek(fp, 0, SEEK_SET) != 0) {
+        fclose(fp);
+        return NULL;
+    }
+
+    char* buf = (char*)malloc((size_t)len + 1U);
+    if (!buf) {
+        fclose(fp);
+        return NULL;
+    }
+
+    size_t n = fread(buf, 1, (size_t)len, fp);
+    fclose(fp);
+    if (n != (size_t)len) {
+        free(buf);
+        return NULL;
+    }
+
+    buf[len] = '\0';
+    if (out_bytes) *out_bytes = (size_t)len;
+    return buf;
+}
+
+static int persist_llm_config(tools_context_t* ctx, const llm_config_t* cfg) {
+    if (!ctx || !ctx->cfg || !cfg) return -1;
+    if (ctx->cfg->config_path[0] == '\0') return -1;
+
+    size_t src_len = 0;
+    char* raw = read_entire_file_local(ctx->cfg->config_path, &src_len);
+    if (!raw) return -1;
+
+    char* src = jsonc_strip_comments(raw, src_len);
+    free(raw);
+    if (!src) return -1;
+
+    cJSON* root = cJSON_ParseWithLength(src, strlen(src));
+    free(src);
+    if (!root || !cJSON_IsObject(root)) {
+        cJSON_Delete(root);
+        return -1;
+    }
+
+    cJSON* llm = cJSON_GetObjectItemCaseSensitive(root, "llm");
+    if (!llm || !cJSON_IsObject(llm)) {
+        cJSON_DeleteItemFromObjectCaseSensitive(root, "llm");
+        llm = cJSON_CreateObject();
+        if (!llm) {
+            cJSON_Delete(root);
+            return -1;
+        }
+        cJSON_AddItemToObject(root, "llm", llm);
+    }
+
+    if (json_object_set_string(llm, "provider", cfg->provider) != 0 ||
+        json_object_set_string(llm, "api_key", cfg->api_key) != 0 ||
+        json_object_set_string(llm, "model", cfg->model) != 0 ||
+        json_object_set_string(llm, "base_url", cfg->base_url) != 0) {
+        cJSON_Delete(root);
+        return -1;
+    }
+
+    cJSON_DeleteItemFromObjectCaseSensitive(llm, "max_tokens");
+    cJSON_AddNumberToObject(llm, "max_tokens", cfg->max_tokens);
+    cJSON_DeleteItemFromObjectCaseSensitive(llm, "temperature");
+    cJSON_AddNumberToObject(llm, "temperature", cfg->temperature);
+
+    char* out = cJSON_Print(root);
+    cJSON_Delete(root);
+    if (!out) return -1;
+
+    FILE* fp = fopen(ctx->cfg->config_path, "wb");
+    if (!fp) {
+        free(out);
+        return -1;
+    }
+
+    size_t out_len = strlen(out);
+    size_t n = fwrite(out, 1, out_len, fp);
+    fclose(fp);
+    free(out);
+    return n == out_len ? 0 : -1;
+}
+
+static int assign_string_field(cJSON* item, char* dst, size_t dst_size, int* changed) {
+    if (!item) return 0;
+    if (!cJSON_IsString(item) || !item->valuestring) return -1;
+    size_t n = strlen(item->valuestring);
+    if (n >= dst_size) return -1;
+    memcpy(dst, item->valuestring, n + 1U);
+    if (changed) *changed = 1;
+    return 0;
+}
+
+char* execute_model_get(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    llm_config_t cfg;
+    if (llm_get_config(&cfg) != 0) {
+        return json_error_local("llm runtime unavailable");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "provider", cfg.provider);
+    cJSON_AddStringToObject(out, "model", cfg.model);
+    cJSON_AddStringToObject(out, "base_url", cfg.base_url);
+    cJSON_AddNumberToObject(out, "max_tokens", cfg.max_tokens);
+    cJSON_AddNumberToObject(out, "temperature", cfg.temperature);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_model_set(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    llm_config_t cfg;
+    if (llm_get_config(&cfg) != 0) {
+        cJSON_Delete(args);
+        return json_error_local("llm runtime unavailable");
+    }
+
+    int changed = 0;
+
+    cJSON* provider = cJSON_GetObjectItemCaseSensitive(args, "provider");
+    cJSON* api_key = cJSON_GetObjectItemCaseSensitive(args, "api_key");
+    cJSON* model = cJSON_GetObjectItemCaseSensitive(args, "model");
+    cJSON* base_url = cJSON_GetObjectItemCaseSensitive(args, "base_url");
+    cJSON* max_tokens = cJSON_GetObjectItemCaseSensitive(args, "max_tokens");
+    cJSON* temperature = cJSON_GetObjectItemCaseSensitive(args, "temperature");
+
+    if (assign_string_field(provider, cfg.provider, sizeof(cfg.provider), &changed) != 0 ||
+        assign_string_field(api_key, cfg.api_key, sizeof(cfg.api_key), &changed) != 0 ||
+        assign_string_field(model, cfg.model, sizeof(cfg.model), &changed) != 0 ||
+        assign_string_field(base_url, cfg.base_url, sizeof(cfg.base_url), &changed) != 0) {
+        cJSON_Delete(args);
+        return json_error_local("model_set string field invalid or too long");
+    }
+
+    if (max_tokens) {
+        if (!cJSON_IsNumber(max_tokens)) {
+            cJSON_Delete(args);
+            return json_error_local("model_set max_tokens must be a number");
+        }
+        cfg.max_tokens = (int)max_tokens->valuedouble;
+        changed = 1;
+    }
+
+    if (temperature) {
+        if (!cJSON_IsNumber(temperature)) {
+            cJSON_Delete(args);
+            return json_error_local("model_set temperature must be a number");
+        }
+        cfg.temperature = temperature->valuedouble;
+        changed = 1;
+    }
+
+    cJSON_Delete(args);
+
+    if (!changed) {
+        return json_error_local("model_set requires at least one field to update");
+    }
+
+    if (llm_set_config(&cfg) != 0) {
+        return json_error_local("failed to update runtime llm config");
+    }
+
+    ctx->cfg->llm = cfg;
+    if (persist_llm_config(ctx, &cfg) != 0) {
+        return json_error_local("failed to persist llm config to config file");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "provider", cfg.provider);
+    cJSON_AddStringToObject(out, "model", cfg.model);
+    cJSON_AddStringToObject(out, "base_url", cfg.base_url);
+    cJSON_AddNumberToObject(out, "max_tokens", cfg.max_tokens);
+    cJSON_AddNumberToObject(out, "temperature", cfg.temperature);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+static void append_model_id(cJSON* ids, cJSON* item) {
+    if (!ids || !item) return;
+    if (cJSON_IsString(item) && item->valuestring) {
+        cJSON_AddItemToArray(ids, cJSON_CreateString(item->valuestring));
+        return;
+    }
+    if (cJSON_IsObject(item)) {
+        cJSON* id = cJSON_GetObjectItemCaseSensitive(item, "id");
+        if (id && cJSON_IsString(id) && id->valuestring) {
+            cJSON_AddItemToArray(ids, cJSON_CreateString(id->valuestring));
+        }
+    }
+}
+
+char* execute_model_list(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* base_url = cJSON_GetObjectItemCaseSensitive(args, "base_url");
+    if (base_url && (!cJSON_IsString(base_url) || !base_url->valuestring)) {
+        cJSON_Delete(args);
+        return json_error_local("model_list base_url must be a string");
+    }
+
+    const char* base_url_override = (base_url && base_url->valuestring && base_url->valuestring[0] != '\0')
+                                        ? base_url->valuestring
+                                        : NULL;
+
+    char* raw = llm_list_models_json(base_url_override);
+    cJSON_Delete(args);
+    if (!raw) {
+        return json_error_local("model_list request failed");
+    }
+
+    cJSON* root = cJSON_Parse(raw);
+    free(raw);
+    if (!root) {
+        cJSON_Delete(root);
+        return json_error_local("model_list returned invalid JSON");
+    }
+
+    cJSON* ids = cJSON_CreateArray();
+    cJSON* out = cJSON_CreateObject();
+    if (!ids || !out) {
+        cJSON_Delete(ids);
+        cJSON_Delete(out);
+        cJSON_Delete(root);
+        return NULL;
+    }
+
+    if (cJSON_IsArray(root)) {
+        int n = cJSON_GetArraySize(root);
+        for (int i = 0; i < n; i++) {
+            append_model_id(ids, cJSON_GetArrayItem(root, i));
+        }
+    } else if (cJSON_IsObject(root)) {
+        cJSON* data = cJSON_GetObjectItemCaseSensitive(root, "data");
+        if (data && cJSON_IsArray(data)) {
+            int n = cJSON_GetArraySize(data);
+            for (int i = 0; i < n; i++) {
+                append_model_id(ids, cJSON_GetArrayItem(data, i));
+            }
+        }
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddNumberToObject(out, "count", cJSON_GetArraySize(ids));
+    cJSON_AddItemToObject(out, "models", ids);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    cJSON_Delete(root);
+    return json;
+}

src/tools/tool_nostr_dm.c

@@ -0,0 +1,218 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "cjson/cJSON.h"
+#include "../nostr_handler.h"
+#include "../../nostr_core_lib/nostr_core/nostr_core.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+static int is_hex_string_len_local(const char* s, size_t expected_len) {
+    if (!s) return 0;
+    if (strlen(s) != expected_len) return 0;
+    for (size_t i = 0; i < expected_len; i++) {
+        if (!((s[i] >= '0' && s[i] <= '9') ||
+              (s[i] >= 'a' && s[i] <= 'f') ||
+              (s[i] >= 'A' && s[i] <= 'F'))) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+char* execute_nostr_dm_send(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* recipient = cJSON_GetObjectItemCaseSensitive(args, "recipient_pubkey");
+    cJSON* message = cJSON_GetObjectItemCaseSensitive(args, "message");
+    if (!recipient || !cJSON_IsString(recipient) || !recipient->valuestring || !is_hex_string_len_local(recipient->valuestring, 64U) ||
+        !message || !cJSON_IsString(message) || !message->valuestring || message->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("nostr_dm_send requires recipient_pubkey hex and non-empty message");
+    }
+
+    int rc = nostr_handler_send_dm(recipient->valuestring, message->valuestring);
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    cJSON_AddBoolToObject(out, "success", rc == 0 ? 1 : 0);
+    cJSON_AddStringToObject(out, "recipient_pubkey", recipient->valuestring);
+    cJSON_AddNumberToObject(out, "message_length", (double)strlen(message->valuestring));
+    cJSON_Delete(args);
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_encrypt(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* recipient = cJSON_GetObjectItemCaseSensitive(args, "recipient_pubkey");
+    cJSON* plaintext = cJSON_GetObjectItemCaseSensitive(args, "plaintext");
+    if (!recipient || !cJSON_IsString(recipient) || !recipient->valuestring || !is_hex_string_len_local(recipient->valuestring, 64U) ||
+        !plaintext || !cJSON_IsString(plaintext) || !plaintext->valuestring || plaintext->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("nostr_encrypt requires recipient_pubkey hex and plaintext");
+    }
+
+    unsigned char recipient_pubkey[32];
+    if (nostr_hex_to_bytes(recipient->valuestring, recipient_pubkey, sizeof(recipient_pubkey)) != 0) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_encrypt invalid recipient_pubkey");
+    }
+
+    size_t out_cap = (strlen(plaintext->valuestring) * 4U) + 1024U;
+    char* ciphertext = (char*)malloc(out_cap);
+    if (!ciphertext) {
+        cJSON_Delete(args);
+        return json_error_local("allocation failure");
+    }
+
+    int rc = nostr_nip44_encrypt(ctx->cfg->keys.private_key,
+                                 recipient_pubkey,
+                                 plaintext->valuestring,
+                                 ciphertext,
+                                 out_cap);
+    if (rc != NOSTR_SUCCESS) {
+        free(ciphertext);
+        cJSON_Delete(args);
+        return json_error_local("nostr_encrypt failed");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(ciphertext);
+        cJSON_Delete(args);
+        return NULL;
+    }
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "recipient_pubkey", recipient->valuestring);
+    cJSON_AddStringToObject(out, "ciphertext", ciphertext);
+
+    free(ciphertext);
+    cJSON_Delete(args);
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_decrypt(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* sender = cJSON_GetObjectItemCaseSensitive(args, "sender_pubkey");
+    cJSON* ciphertext = cJSON_GetObjectItemCaseSensitive(args, "ciphertext");
+    if (!sender || !cJSON_IsString(sender) || !sender->valuestring || !is_hex_string_len_local(sender->valuestring, 64U) ||
+        !ciphertext || !cJSON_IsString(ciphertext) || !ciphertext->valuestring || ciphertext->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("nostr_decrypt requires sender_pubkey hex and ciphertext");
+    }
+
+    unsigned char sender_pubkey[32];
+    if (nostr_hex_to_bytes(sender->valuestring, sender_pubkey, sizeof(sender_pubkey)) != 0) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_decrypt invalid sender_pubkey");
+    }
+
+    size_t out_cap = strlen(ciphertext->valuestring) + 1024U;
+    char* plaintext = (char*)malloc(out_cap);
+    if (!plaintext) {
+        cJSON_Delete(args);
+        return json_error_local("allocation failure");
+    }
+
+    int rc = nostr_nip44_decrypt(ctx->cfg->keys.private_key,
+                                 sender_pubkey,
+                                 ciphertext->valuestring,
+                                 plaintext,
+                                 out_cap);
+    if (rc != NOSTR_SUCCESS) {
+        free(plaintext);
+        cJSON_Delete(args);
+        return json_error_local("nostr_decrypt failed");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(plaintext);
+        cJSON_Delete(args);
+        return NULL;
+    }
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "sender_pubkey", sender->valuestring);
+    cJSON_AddStringToObject(out, "plaintext", plaintext);
+
+    free(plaintext);
+    cJSON_Delete(args);
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_dm_send_nip17(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* recipient = cJSON_GetObjectItemCaseSensitive(args, "recipient_pubkey");
+    cJSON* message = cJSON_GetObjectItemCaseSensitive(args, "message");
+    cJSON* subject = cJSON_GetObjectItemCaseSensitive(args, "subject");
+
+    if (!recipient || !cJSON_IsString(recipient) || !recipient->valuestring || !is_hex_string_len_local(recipient->valuestring, 64U) ||
+        !message || !cJSON_IsString(message) || !message->valuestring || message->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("nostr_dm_send_nip17 requires recipient_pubkey hex and non-empty message");
+    }
+    if (subject && !cJSON_IsString(subject)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_dm_send_nip17 subject must be a string when provided");
+    }
+
+    int rc = nostr_handler_send_dm_nip17(recipient->valuestring,
+                                         message->valuestring,
+                                         (subject && subject->valuestring) ? subject->valuestring : NULL);
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    cJSON_AddBoolToObject(out, "success", rc == 0 ? 1 : 0);
+    cJSON_AddStringToObject(out, "recipient_pubkey", recipient->valuestring);
+    cJSON_AddStringToObject(out, "protocol", "nip17");
+    cJSON_AddNumberToObject(out, "message_length", (double)strlen(message->valuestring));
+
+    cJSON_Delete(args);
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}

src/tools/tool_nostr_identity.c

@@ -0,0 +1,192 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "cjson/cJSON.h"
+#include "../../nostr_core_lib/nostr_core/nostr_core.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+static int is_hex_string_len_local(const char* s, size_t expected_len) {
+    if (!s) return 0;
+    if (strlen(s) != expected_len) return 0;
+    for (size_t i = 0; i < expected_len; i++) {
+        if (!((s[i] >= '0' && s[i] <= '9') ||
+              (s[i] >= 'a' && s[i] <= 'f') ||
+              (s[i] >= 'A' && s[i] <= 'F'))) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+char* execute_nostr_encode(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* type = cJSON_GetObjectItemCaseSensitive(args, "type");
+    cJSON* hex = cJSON_GetObjectItemCaseSensitive(args, "hex");
+
+    if (!type || !cJSON_IsString(type) || !type->valuestring ||
+        !hex || !cJSON_IsString(hex) || !hex->valuestring || !is_hex_string_len_local(hex->valuestring, 64U)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_encode requires type string and hex 64-char string");
+    }
+
+    char type_name[32];
+    snprintf(type_name, sizeof(type_name), "%s", type->valuestring);
+
+    unsigned char key_bytes[32];
+    if (nostr_hex_to_bytes(hex->valuestring, key_bytes, sizeof(key_bytes)) != 0) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_encode invalid hex");
+    }
+
+    char bech32[256] = {0};
+    int rc = NOSTR_ERROR_INVALID_INPUT;
+
+    if (strcmp(type_name, "npub") == 0) {
+        rc = nostr_key_to_bech32(key_bytes, "npub", bech32);
+    } else if (strcmp(type_name, "nsec") == 0) {
+        rc = nostr_key_to_bech32(key_bytes, "nsec", bech32);
+    } else if (strcmp(type_name, "note") == 0) {
+        rc = nostr_key_to_bech32(key_bytes, "note", bech32);
+    } else {
+        cJSON_Delete(args);
+        return json_error_local("nostr_encode currently supports npub, nsec, note");
+    }
+
+    cJSON_Delete(args);
+    if (rc != NOSTR_SUCCESS) {
+        return json_error_local("nostr_encode failed");
+    }
+
+    char uri[320] = {0};
+    snprintf(uri, sizeof(uri), "nostr:%s", bech32);
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "type", type_name);
+    cJSON_AddStringToObject(out, "uri", uri);
+    cJSON_AddBoolToObject(out, "limited_support", 1);
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_decode(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* uri_in = cJSON_GetObjectItemCaseSensitive(args, "uri");
+    if (!uri_in || !cJSON_IsString(uri_in) || !uri_in->valuestring || uri_in->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("nostr_decode requires uri string");
+    }
+
+    const char* in = uri_in->valuestring;
+    if (strncmp(in, "nostr:", 6) == 0) {
+        in += 6;
+    }
+
+    unsigned char key[32];
+    char key_hex[65] = {0};
+    const char* type = NULL;
+    int rc = NOSTR_ERROR_INVALID_INPUT;
+
+    if (strncmp(in, "npub1", 5) == 0) {
+        type = "npub";
+        rc = nostr_decode_npub(in, key);
+    } else if (strncmp(in, "nsec1", 5) == 0) {
+        type = "nsec";
+        rc = nostr_decode_nsec(in, key);
+    } else {
+        cJSON_Delete(args);
+        return json_error_local("nostr_decode currently supports npub and nsec");
+    }
+
+    cJSON_Delete(args);
+    if (rc != NOSTR_SUCCESS) {
+        return json_error_local("nostr_decode failed");
+    }
+
+    nostr_bytes_to_hex(key, 32, key_hex);
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "type", type);
+    if (strcmp(type, "npub") == 0) {
+        cJSON_AddStringToObject(out, "pubkey", key_hex);
+    } else {
+        cJSON_AddStringToObject(out, "private_key", key_hex);
+    }
+    cJSON_AddBoolToObject(out, "limited_support", 1);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_pubkey(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "pubkey", ctx->cfg->keys.public_key_hex);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_npub(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char npub[256] = {0};
+    if (nostr_key_to_bech32(ctx->cfg->keys.public_key, "npub", npub) != NOSTR_SUCCESS) {
+        return json_error_local("failed to encode npub");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) return NULL;
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "npub", npub);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}

src/tools/tool_nostr_list.c

@@ -0,0 +1,361 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cjson/cJSON.h"
+#include "../nostr_handler.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+static int is_hex_string_len_local(const char* s, size_t expected_len) {
+    if (!s) return 0;
+    if (strlen(s) != expected_len) return 0;
+    for (size_t i = 0; i < expected_len; i++) {
+        if (!((s[i] >= '0' && s[i] <= '9') ||
+              (s[i] >= 'a' && s[i] <= 'f') ||
+              (s[i] >= 'A' && s[i] <= 'F'))) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static int add_string_tag_local(cJSON* tags, const char* key, const char* value) {
+    if (!tags || !cJSON_IsArray(tags) || !key || !value) return -1;
+    cJSON* tuple = cJSON_CreateArray();
+    if (!tuple) return -1;
+    cJSON_AddItemToArray(tuple, cJSON_CreateString(key));
+    cJSON_AddItemToArray(tuple, cJSON_CreateString(value));
+    cJSON_AddItemToArray(tags, tuple);
+    return 0;
+}
+
+static int tag_tuple_equal_local(cJSON* a, cJSON* b) {
+    if (!a || !b || !cJSON_IsArray(a) || !cJSON_IsArray(b)) return 0;
+    int an = cJSON_GetArraySize(a);
+    int bn = cJSON_GetArraySize(b);
+    if (an != bn) return 0;
+    for (int i = 0; i < an; i++) {
+        cJSON* av = cJSON_GetArrayItem(a, i);
+        cJSON* bv = cJSON_GetArrayItem(b, i);
+        if (!av || !bv || !cJSON_IsString(av) || !cJSON_IsString(bv) || !av->valuestring || !bv->valuestring) {
+            return 0;
+        }
+        if (strcmp(av->valuestring, bv->valuestring) != 0) return 0;
+    }
+    return 1;
+}
+
+static int tags_contains_tuple_local(cJSON* tags, cJSON* tuple) {
+    if (!tags || !tuple || !cJSON_IsArray(tags) || !cJSON_IsArray(tuple)) return 0;
+    int n = cJSON_GetArraySize(tags);
+    for (int i = 0; i < n; i++) {
+        cJSON* t = cJSON_GetArrayItem(tags, i);
+        if (tag_tuple_equal_local(t, tuple)) return 1;
+    }
+    return 0;
+}
+
+static int remove_matching_tag_tuples_local(cJSON* tags, cJSON* tuple) {
+    if (!tags || !tuple || !cJSON_IsArray(tags) || !cJSON_IsArray(tuple)) return 0;
+    int removed = 0;
+    for (int i = cJSON_GetArraySize(tags) - 1; i >= 0; i--) {
+        cJSON* t = cJSON_GetArrayItem(tags, i);
+        if (tag_tuple_equal_local(t, tuple)) {
+            cJSON_DeleteItemFromArray(tags, i);
+            removed++;
+        }
+    }
+    return removed;
+}
+
+char* execute_nostr_delete(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* event_ids = cJSON_GetObjectItemCaseSensitive(args, "event_ids");
+    cJSON* kinds = cJSON_GetObjectItemCaseSensitive(args, "kinds");
+    cJSON* reason = cJSON_GetObjectItemCaseSensitive(args, "reason");
+
+    if (!event_ids || !cJSON_IsArray(event_ids) || cJSON_GetArraySize(event_ids) <= 0) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_delete requires non-empty event_ids array");
+    }
+    if (kinds && !cJSON_IsArray(kinds)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_delete kinds must be an array when provided");
+    }
+    if (reason && !cJSON_IsString(reason)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_delete reason must be a string when provided");
+    }
+
+    cJSON* tags = cJSON_CreateArray();
+    if (!tags) {
+        cJSON_Delete(args);
+        return json_error_local("failed to create tags");
+    }
+
+    int event_id_count = cJSON_GetArraySize(event_ids);
+    for (int i = 0; i < event_id_count; i++) {
+        cJSON* id = cJSON_GetArrayItem(event_ids, i);
+        if (!id || !cJSON_IsString(id) || !id->valuestring || !is_hex_string_len_local(id->valuestring, 64U)) {
+            cJSON_Delete(tags);
+            cJSON_Delete(args);
+            return json_error_local("nostr_delete event_ids must contain 64-char hex strings");
+        }
+        if (add_string_tag_local(tags, "e", id->valuestring) != 0) {
+            cJSON_Delete(tags);
+            cJSON_Delete(args);
+            return json_error_local("failed to add e tag");
+        }
+    }
+
+    if (kinds) {
+        int kind_count = cJSON_GetArraySize(kinds);
+        for (int i = 0; i < kind_count; i++) {
+            cJSON* k = cJSON_GetArrayItem(kinds, i);
+            if (!k || !cJSON_IsNumber(k)) {
+                cJSON_Delete(tags);
+                cJSON_Delete(args);
+                return json_error_local("nostr_delete kinds must contain integers");
+            }
+            char kind_buf[32];
+            snprintf(kind_buf, sizeof(kind_buf), "%d", (int)k->valuedouble);
+            if (add_string_tag_local(tags, "k", kind_buf) != 0) {
+                cJSON_Delete(tags);
+                cJSON_Delete(args);
+                return json_error_local("failed to add k tag");
+            }
+        }
+    }
+
+    nostr_publish_result_t publish_result;
+    memset(&publish_result, 0, sizeof(publish_result));
+
+    const char* reason_content = (reason && reason->valuestring) ? reason->valuestring : "";
+    int rc = nostr_handler_publish_kind_event(5, reason_content, tags, &publish_result);
+    cJSON_Delete(tags);
+    cJSON_Delete(args);
+    if (rc != 0) {
+        nostr_handler_publish_result_free(&publish_result);
+        return json_error_local("nostr_delete failed");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        nostr_handler_publish_result_free(&publish_result);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", publish_result.success ? 1 : 0);
+    cJSON_AddStringToObject(out, "message", "nostr_delete published");
+    cJSON_AddNumberToObject(out, "kind", publish_result.kind);
+    cJSON_AddStringToObject(out, "event_id", publish_result.event_id);
+    cJSON_AddNumberToObject(out, "requested_event_count", event_id_count);
+    cJSON_AddNumberToObject(out, "relay_count", publish_result.relay_count);
+    cJSON_AddNumberToObject(out, "accepted_by_pool_count", publish_result.accepted_by_pool_count);
+
+    cJSON* relays = cJSON_CreateArray();
+    if (!relays) {
+        nostr_handler_publish_result_free(&publish_result);
+        cJSON_Delete(out);
+        return NULL;
+    }
+    for (int i = 0; i < publish_result.relay_count; i++) {
+        cJSON_AddItemToArray(relays, cJSON_CreateString(publish_result.relays[i] ? publish_result.relays[i] : ""));
+    }
+    cJSON_AddItemToObject(out, "relays", relays);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    nostr_handler_publish_result_free(&publish_result);
+    return json;
+}
+
+char* execute_nostr_list_manage(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* list_kind = cJSON_GetObjectItemCaseSensitive(args, "list_kind");
+    cJSON* action = cJSON_GetObjectItemCaseSensitive(args, "action");
+    cJSON* items = cJSON_GetObjectItemCaseSensitive(args, "items");
+
+    if (!list_kind || !cJSON_IsNumber(list_kind) ||
+        !action || !cJSON_IsString(action) || !action->valuestring ||
+        !items || !cJSON_IsArray(items)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_list_manage requires list_kind, action, and items");
+    }
+    if (strcmp(action->valuestring, "add") != 0 && strcmp(action->valuestring, "remove") != 0) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_list_manage action must be add or remove");
+    }
+
+    cJSON* filter = cJSON_CreateObject();
+    cJSON* kinds = cJSON_CreateArray();
+    cJSON* authors = cJSON_CreateArray();
+    if (!filter || !kinds || !authors) {
+        cJSON_Delete(filter);
+        cJSON_Delete(kinds);
+        cJSON_Delete(authors);
+        cJSON_Delete(args);
+        return json_error_local("failed to create list query filter");
+    }
+
+    cJSON_AddItemToArray(kinds, cJSON_CreateNumber((int)list_kind->valuedouble));
+    cJSON_AddItemToObject(filter, "kinds", kinds);
+    cJSON_AddItemToArray(authors, cJSON_CreateString(ctx->cfg->keys.public_key_hex));
+    cJSON_AddItemToObject(filter, "authors", authors);
+    cJSON_AddNumberToObject(filter, "limit", 1);
+
+    char* events_json = nostr_handler_query_json(filter, 8000);
+    cJSON_Delete(filter);
+
+    cJSON* events = events_json ? cJSON_Parse(events_json) : NULL;
+    free(events_json);
+
+    char* list_content = strdup("");
+    if (!list_content) {
+        cJSON_Delete(events);
+        cJSON_Delete(args);
+        return json_error_local("allocation failure");
+    }
+
+    cJSON* updated_tags = cJSON_CreateArray();
+    if (!updated_tags) {
+        free(list_content);
+        cJSON_Delete(events);
+        cJSON_Delete(args);
+        return json_error_local("failed to create list tags");
+    }
+
+    if (events && cJSON_IsArray(events) && cJSON_GetArraySize(events) > 0) {
+        cJSON* ev0 = cJSON_GetArrayItem(events, 0);
+        if (ev0 && cJSON_IsObject(ev0)) {
+            cJSON* content = cJSON_GetObjectItemCaseSensitive(ev0, "content");
+            if (content && cJSON_IsString(content) && content->valuestring) {
+                free(list_content);
+                list_content = strdup(content->valuestring);
+                if (!list_content) {
+                    cJSON_Delete(updated_tags);
+                    cJSON_Delete(events);
+                    cJSON_Delete(args);
+                    return json_error_local("allocation failure");
+                }
+            }
+
+            cJSON* tags = cJSON_GetObjectItemCaseSensitive(ev0, "tags");
+            if (tags && cJSON_IsArray(tags)) {
+                cJSON_Delete(updated_tags);
+                updated_tags = cJSON_Duplicate(tags, 1);
+                if (!updated_tags) {
+                    free(list_content);
+                    cJSON_Delete(events);
+                    cJSON_Delete(args);
+                    return json_error_local("failed to duplicate existing list tags");
+                }
+            }
+        }
+    }
+
+    int items_affected = 0;
+    int item_count = cJSON_GetArraySize(items);
+    for (int i = 0; i < item_count; i++) {
+        cJSON* tuple = cJSON_GetArrayItem(items, i);
+        if (!tuple || !cJSON_IsArray(tuple) || cJSON_GetArraySize(tuple) <= 0) {
+            continue;
+        }
+
+        int tuple_ok = 1;
+        int tuple_size = cJSON_GetArraySize(tuple);
+        for (int j = 0; j < tuple_size; j++) {
+            cJSON* part = cJSON_GetArrayItem(tuple, j);
+            if (!part || !cJSON_IsString(part) || !part->valuestring) {
+                tuple_ok = 0;
+                break;
+            }
+        }
+        if (!tuple_ok) {
+            continue;
+        }
+
+        if (strcmp(action->valuestring, "add") == 0) {
+            if (!tags_contains_tuple_local(updated_tags, tuple)) {
+                cJSON* dup = cJSON_Duplicate(tuple, 1);
+                if (!dup) {
+                    free(list_content);
+                    cJSON_Delete(updated_tags);
+                    cJSON_Delete(events);
+                    cJSON_Delete(args);
+                    return json_error_local("failed to duplicate list item");
+                }
+                cJSON_AddItemToArray(updated_tags, dup);
+                items_affected++;
+            }
+        } else {
+            items_affected += remove_matching_tag_tuples_local(updated_tags, tuple);
+        }
+    }
+
+    nostr_publish_result_t publish_result;
+    memset(&publish_result, 0, sizeof(publish_result));
+
+    int rc = nostr_handler_publish_kind_event((int)list_kind->valuedouble,
+                                              list_content,
+                                              updated_tags,
+                                              &publish_result);
+
+    free(list_content);
+    cJSON_Delete(updated_tags);
+    cJSON_Delete(events);
+
+    if (rc != 0) {
+        cJSON_Delete(args);
+        nostr_handler_publish_result_free(&publish_result);
+        return json_error_local("nostr_list_manage failed");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        cJSON_Delete(args);
+        nostr_handler_publish_result_free(&publish_result);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", publish_result.success ? 1 : 0);
+    cJSON_AddNumberToObject(out, "list_kind", publish_result.kind);
+    cJSON_AddStringToObject(out, "action", action->valuestring);
+    cJSON_Delete(args);
+    cJSON_AddNumberToObject(out, "items_affected", items_affected);
+    cJSON_AddStringToObject(out, "event_id", publish_result.event_id);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    nostr_handler_publish_result_free(&publish_result);
+    return json;
+}

src/tools/tool_nostr_post.c

@@ -0,0 +1,927 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <ctype.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "cjson/cJSON.h"
+#include "../nostr_handler.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static const char* skip_ws_local(const char* p) {
+    while (p && *p && isspace((unsigned char)*p)) p++;
+    return p;
+}
+
+static char* sanitize_json_string_controls_local(const char* in) {
+    if (!in) return NULL;
+
+    size_t len = strlen(in);
+    size_t cap = (len * 2U) + 1U;
+    char* out = (char*)malloc(cap);
+    if (!out) return NULL;
+
+    int in_string = 0;
+    int escaping = 0;
+    size_t j = 0;
+
+    for (size_t i = 0; i < len; i++) {
+        char c = in[i];
+
+        if (escaping) {
+            if (j + 1U >= cap) {
+                free(out);
+                return NULL;
+            }
+            out[j++] = c;
+            escaping = 0;
+            continue;
+        }
+
+        if (c == '\\') {
+            if (j + 1U >= cap) {
+                free(out);
+                return NULL;
+            }
+            out[j++] = c;
+            if (in_string) escaping = 1;
+            continue;
+        }
+
+        if (c == '"') {
+            if (j + 1U >= cap) {
+                free(out);
+                return NULL;
+            }
+            out[j++] = c;
+            in_string = !in_string;
+            continue;
+        }
+
+        if (in_string && (c == '\n' || c == '\r' || c == '\t')) {
+            if (j + 2U >= cap) {
+                free(out);
+                return NULL;
+            }
+            out[j++] = '\\';
+            out[j++] = (c == '\n') ? 'n' : (c == '\r') ? 'r' : 't';
+            continue;
+        }
+
+        if (j + 1U >= cap) {
+            free(out);
+            return NULL;
+        }
+        out[j++] = c;
+    }
+
+    out[j] = '\0';
+    return out;
+}
+
+static cJSON* parse_tool_args_json_local(const char* args_json) {
+    const char* raw_args_json = args_json ? args_json : "{}";
+    raw_args_json = skip_ws_local(raw_args_json);
+    if (!raw_args_json || raw_args_json[0] == '\0') {
+        raw_args_json = "{}";
+    }
+
+    cJSON* args = cJSON_Parse(raw_args_json);
+    char* repaired_args_json = NULL;
+
+    if (args && cJSON_IsString(args) && args->valuestring) {
+        cJSON* nested = cJSON_Parse(args->valuestring);
+        if (nested) {
+            cJSON_Delete(args);
+            args = nested;
+        }
+    }
+
+    if (!args) {
+        repaired_args_json = sanitize_json_string_controls_local(raw_args_json);
+        if (repaired_args_json) {
+            args = cJSON_Parse(repaired_args_json);
+            if (args && cJSON_IsString(args) && args->valuestring) {
+                cJSON* nested = cJSON_Parse(args->valuestring);
+                if (nested) {
+                    cJSON_Delete(args);
+                    args = nested;
+                }
+            }
+        }
+    }
+
+    free(repaired_args_json);
+    return args;
+}
+
+static const char* find_key_start_local(const char* in, const char* key) {
+    if (!in || !key) return NULL;
+
+    char pattern[64];
+    int n = snprintf(pattern, sizeof(pattern), "\"%s\"", key);
+    if (n <= 0 || (size_t)n >= sizeof(pattern)) return NULL;
+
+    return strstr(in, pattern);
+}
+
+static int parse_loose_kind_local(const char* in, int* out_kind) {
+    if (!in || !out_kind) return -1;
+
+    const char* p = find_key_start_local(in, "kind");
+    if (!p) return -1;
+
+    p = strchr(p, ':');
+    if (!p) return -1;
+    p = skip_ws_local(p + 1);
+    if (!p || !*p) return -1;
+
+    char* end = NULL;
+    long v = strtol(p, &end, 10);
+    if (end == p) return -1;
+
+    *out_kind = (int)v;
+    return 0;
+}
+
+static char* parse_loose_json_string_value_local(const char* in, const char* key) {
+    if (!in || !key) return NULL;
+
+    const char* p = find_key_start_local(in, key);
+    if (!p) return NULL;
+
+    p = strchr(p, ':');
+    if (!p) return NULL;
+    p = skip_ws_local(p + 1);
+    if (!p || *p != '"') return NULL;
+    p++;
+
+    size_t max_len = strlen(p);
+    char* out = (char*)malloc(max_len + 1U);
+    if (!out) return NULL;
+
+    size_t j = 0;
+    int escaping = 0;
+    for (size_t i = 0; p[i] != '\0'; i++) {
+        char c = p[i];
+
+        if (escaping) {
+            switch (c) {
+                case 'n': out[j++] = '\n'; break;
+                case 'r': out[j++] = '\r'; break;
+                case 't': out[j++] = '\t'; break;
+                case '"': out[j++] = '"'; break;
+                case '\\': out[j++] = '\\'; break;
+                default: out[j++] = c; break;
+            }
+            escaping = 0;
+            continue;
+        }
+
+        if (c == '\\') {
+            escaping = 1;
+            continue;
+        }
+
+        if (c == '"') {
+            out[j] = '\0';
+            return out;
+        }
+
+        out[j++] = c;
+    }
+
+    out[j] = '\0';
+    return out;
+}
+
+static cJSON* parse_loose_nostr_post_args_local(const char* in) {
+    if (!in) return NULL;
+
+    int kind = 0;
+    if (parse_loose_kind_local(in, &kind) != 0) {
+        return NULL;
+    }
+
+    char* content = parse_loose_json_string_value_local(in, "content");
+    if (!content) {
+        return NULL;
+    }
+
+    cJSON* args = cJSON_CreateObject();
+    if (!args) {
+        free(content);
+        return NULL;
+    }
+
+    cJSON_AddNumberToObject(args, "kind", kind);
+    cJSON_AddStringToObject(args, "content", content);
+    free(content);
+    return args;
+}
+
+static cJSON* ensure_tags_array_local(cJSON** tags_inout) {
+    if (!tags_inout) return NULL;
+
+    if (*tags_inout) {
+        if (cJSON_IsArray(*tags_inout)) {
+            return *tags_inout;
+        }
+        cJSON_Delete(*tags_inout);
+        *tags_inout = NULL;
+    }
+
+    *tags_inout = cJSON_CreateArray();
+    return *tags_inout;
+}
+
+static int has_tag_key_local(cJSON* tags, const char* key) {
+    if (!tags || !cJSON_IsArray(tags) || !key) return 0;
+
+    int n = cJSON_GetArraySize(tags);
+    for (int i = 0; i < n; i++) {
+        cJSON* tag = cJSON_GetArrayItem(tags, i);
+        if (!tag || !cJSON_IsArray(tag)) continue;
+
+        cJSON* k = cJSON_GetArrayItem(tag, 0);
+        if (k && cJSON_IsString(k) && k->valuestring && strcmp(k->valuestring, key) == 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int add_string_tag_local(cJSON* tags, const char* key, const char* value) {
+    if (!tags || !cJSON_IsArray(tags) || !key || !value || value[0] == '\0') return -1;
+
+    cJSON* tag = cJSON_CreateArray();
+    if (!tag) return -1;
+
+    cJSON_AddItemToArray(tag, cJSON_CreateString(key));
+    cJSON_AddItemToArray(tag, cJSON_CreateString(value));
+    cJSON_AddItemToArray(tags, tag);
+    return 0;
+}
+
+static char* trim_copy_local(const char* start, size_t len) {
+    while (len > 0 && isspace((unsigned char)start[0])) {
+        start++;
+        len--;
+    }
+    while (len > 0 && isspace((unsigned char)start[len - 1])) {
+        len--;
+    }
+
+    char* out = (char*)malloc(len + 1U);
+    if (!out) return NULL;
+    memcpy(out, start, len);
+    out[len] = '\0';
+    return out;
+}
+
+static char* first_markdown_h1_local(const char* content) {
+    if (!content) return NULL;
+
+    const char* p = content;
+    while (*p) {
+        const char* line = p;
+        const char* nl = strchr(line, '\n');
+        size_t len = nl ? (size_t)(nl - line) : strlen(line);
+        while (len > 0 && line[len - 1] == '\r') len--;
+
+        size_t i = 0;
+        while (i < len && isspace((unsigned char)line[i])) i++;
+        if (i < len && line[i] == '#') {
+            size_t j = i;
+            while (j < len && line[j] == '#') j++;
+            if (j < len && isspace((unsigned char)line[j])) {
+                while (j < len && isspace((unsigned char)line[j])) j++;
+                if (j < len) return trim_copy_local(line + j, len - j);
+            }
+        }
+
+        if (!nl) break;
+        p = nl + 1;
+    }
+    return NULL;
+}
+
+static int is_paragraph_line_local(const char* line, size_t len) {
+    size_t i = 0;
+    while (i < len && isspace((unsigned char)line[i])) i++;
+    if (i >= len) return 0;
+
+    char c = line[i];
+    if (c == '#' || c == '>' || c == '-' || c == '*' || c == '`' || c == '|') return 0;
+    if (isdigit((unsigned char)c)) {
+        size_t j = i;
+        while (j < len && isdigit((unsigned char)line[j])) j++;
+        if (j < len && line[j] == '.') return 0;
+    }
+    return 1;
+}
+
+static char* first_markdown_paragraph_local(const char* content) {
+    if (!content) return NULL;
+
+    const char* p = content;
+    while (*p) {
+        const char* line = p;
+        const char* nl = strchr(line, '\n');
+        size_t len = nl ? (size_t)(nl - line) : strlen(line);
+        while (len > 0 && line[len - 1] == '\r') len--;
+
+        if (is_paragraph_line_local(line, len)) {
+            size_t cap = 1024;
+            size_t used = 0;
+            char* out = (char*)malloc(cap);
+            if (!out) return NULL;
+
+            const char* q = line;
+            const char* qnl = nl;
+            size_t qlen = len;
+
+            while (1) {
+                if (!is_paragraph_line_local(q, qlen)) break;
+
+                size_t start = 0;
+                while (start < qlen && isspace((unsigned char)q[start])) start++;
+                size_t end = qlen;
+                while (end > start && isspace((unsigned char)q[end - 1])) end--;
+                size_t part_len = end - start;
+
+                if (used + part_len + 2 >= cap) {
+                    cap = (cap * 2U) + part_len + 16U;
+                    char* bigger = (char*)realloc(out, cap);
+                    if (!bigger) {
+                        free(out);
+                        return NULL;
+                    }
+                    out = bigger;
+                }
+
+                if (part_len > 0) {
+                    if (used > 0) out[used++] = ' ';
+                    memcpy(out + used, q + start, part_len);
+                    used += part_len;
+                }
+
+                if (!qnl) break;
+                q = qnl + 1;
+                qnl = strchr(q, '\n');
+                qlen = qnl ? (size_t)(qnl - q) : strlen(q);
+                while (qlen > 0 && q[qlen - 1] == '\r') qlen--;
+            }
+
+            out[used] = '\0';
+            return out;
+        }
+
+        if (!nl) break;
+        p = nl + 1;
+    }
+
+    return NULL;
+}
+
+static char* first_markdown_image_url_local(const char* content) {
+    if (!content) return NULL;
+
+    const char* p = content;
+    while ((p = strstr(p, "![")) != NULL) {
+        const char* close_bracket = strchr(p + 2, ']');
+        if (!close_bracket || close_bracket[1] != '(') {
+            p += 2;
+            continue;
+        }
+
+        const char* url_start = close_bracket + 2;
+        const char* url_end = strchr(url_start, ')');
+        if (!url_end || url_end <= url_start) {
+            p += 2;
+            continue;
+        }
+
+        return trim_copy_local(url_start, (size_t)(url_end - url_start));
+    }
+
+    return NULL;
+}
+
+static char* d_tagify_string_local(const char* in, const char* fallback) {
+    if (!in || in[0] == '\0') {
+        return fallback ? strdup(fallback) : NULL;
+    }
+
+    size_t len = strlen(in);
+    char* out = (char*)malloc(len + 1U);
+    if (!out) return NULL;
+
+    size_t j = 0;
+    int prev_dash = 0;
+    for (size_t i = 0; i < len; i++) {
+        unsigned char c = (unsigned char)in[i];
+        if (isalnum(c)) {
+            out[j++] = (char)tolower(c);
+            prev_dash = 0;
+        } else if (!prev_dash && j > 0) {
+            out[j++] = '-';
+            prev_dash = 1;
+        }
+    }
+
+    while (j > 0 && out[j - 1] == '-') j--;
+    out[j] = '\0';
+
+    if (j == 0) {
+        free(out);
+        return fallback ? strdup(fallback) : NULL;
+    }
+
+    return out;
+}
+
+static void ensure_nip23_metadata_tags_local(int kind, const char* content, cJSON** tags_inout) {
+    if (!content || (kind != 30023 && kind != 30024) || !tags_inout) {
+        return;
+    }
+
+    cJSON* tags = ensure_tags_array_local(tags_inout);
+    if (!tags) return;
+
+    char* title = has_tag_key_local(tags, "title") ? NULL : first_markdown_h1_local(content);
+    char* summary = has_tag_key_local(tags, "summary") ? NULL : first_markdown_paragraph_local(content);
+    char* image = has_tag_key_local(tags, "image") ? NULL : first_markdown_image_url_local(content);
+
+    if (title) (void)add_string_tag_local(tags, "title", title);
+    if (summary) (void)add_string_tag_local(tags, "summary", summary);
+    if (image) (void)add_string_tag_local(tags, "image", image);
+
+    if (!has_tag_key_local(tags, "published_at")) {
+        char published_at[32];
+        snprintf(published_at, sizeof(published_at), "%lld", (long long)time(NULL));
+        (void)add_string_tag_local(tags, "published_at", published_at);
+    }
+
+    if (!has_tag_key_local(tags, "d")) {
+        char* d_tag = NULL;
+        if (title) {
+            d_tag = d_tagify_string_local(title, "long-form-note");
+        } else {
+            char* derived_title = first_markdown_h1_local(content);
+            d_tag = d_tagify_string_local(derived_title, "long-form-note");
+            free(derived_title);
+        }
+        if (d_tag) {
+            (void)add_string_tag_local(tags, "d", d_tag);
+            free(d_tag);
+        }
+    }
+
+    free(title);
+    free(summary);
+    free(image);
+}
+
+static int is_safe_relative_path_local(const char* path) {
+    if (!path || path[0] == '\0') return 0;
+    if (path[0] == '/') return 0;
+    if (strstr(path, "..") != NULL) return 0;
+    if (strchr(path, '\\') != NULL) return 0;
+    return 1;
+}
+
+static int build_tool_path_local(tools_context_t* ctx, const char* rel_path, char* out, size_t out_size) {
+    if (!ctx || !ctx->cfg || !rel_path || !out || out_size == 0) return -1;
+    if (!is_safe_relative_path_local(rel_path)) return -1;
+
+    const char* cwd = ctx->cfg->tools.shell.working_directory[0] != '\0'
+                          ? ctx->cfg->tools.shell.working_directory
+                          : ".";
+
+    int n = 0;
+    if (strcmp(cwd, ".") == 0) {
+        n = snprintf(out, out_size, "%s", rel_path);
+    } else {
+        n = snprintf(out, out_size, "%s/%s", cwd, rel_path);
+    }
+
+    if (n < 0 || (size_t)n >= out_size) return -1;
+    return 0;
+}
+
+static char* read_entire_file_local(const char* file_path, size_t* out_bytes) {
+    if (!file_path) return NULL;
+
+    FILE* fp = fopen(file_path, "rb");
+    if (!fp) return NULL;
+
+    if (fseek(fp, 0, SEEK_END) != 0) {
+        fclose(fp);
+        return NULL;
+    }
+
+    long size = ftell(fp);
+    if (size < 0) {
+        fclose(fp);
+        return NULL;
+    }
+
+    if (fseek(fp, 0, SEEK_SET) != 0) {
+        fclose(fp);
+        return NULL;
+    }
+
+    char* buf = (char*)malloc((size_t)size + 1U);
+    if (!buf) {
+        fclose(fp);
+        return NULL;
+    }
+
+    size_t n = fread(buf, 1, (size_t)size, fp);
+    fclose(fp);
+    buf[n] = '\0';
+
+    if (out_bytes) *out_bytes = n;
+    return buf;
+}
+
+static char* basename_lowercase_dup_local(const char* path) {
+    if (!path || path[0] == '\0') return NULL;
+
+    const char* base = strrchr(path, '/');
+    base = base ? (base + 1) : path;
+    if (base[0] == '\0') return NULL;
+
+    char* out = strdup(base);
+    if (!out) return NULL;
+
+    for (size_t i = 0; out[i] != '\0'; i++) {
+        out[i] = (char)tolower((unsigned char)out[i]);
+    }
+
+    return out;
+}
+
+char* execute_nostr_post(const char* args_json) {
+    const char* raw_args_json = args_json ? args_json : "{}";
+    raw_args_json = skip_ws_local(raw_args_json);
+    if (!raw_args_json || raw_args_json[0] == '\0') {
+        raw_args_json = "{}";
+    }
+
+    cJSON* args = cJSON_Parse(raw_args_json);
+    char* repaired_args_json = NULL;
+
+    if (args && cJSON_IsString(args) && args->valuestring) {
+        cJSON* nested = cJSON_Parse(args->valuestring);
+        if (nested) {
+            cJSON_Delete(args);
+            args = nested;
+        }
+    }
+
+    if (!args && raw_args_json) {
+        repaired_args_json = sanitize_json_string_controls_local(raw_args_json);
+        if (repaired_args_json) {
+            args = cJSON_Parse(repaired_args_json);
+            if (args && cJSON_IsString(args) && args->valuestring) {
+                cJSON* nested = cJSON_Parse(args->valuestring);
+                if (nested) {
+                    cJSON_Delete(args);
+                    args = nested;
+                }
+            }
+        }
+    }
+
+    if (!args && raw_args_json) {
+        args = parse_loose_nostr_post_args_local(raw_args_json);
+    }
+    if (!args) {
+        free(repaired_args_json);
+        return json_error_local("invalid arguments JSON");
+    }
+
+    cJSON* kind = cJSON_GetObjectItemCaseSensitive(args, "kind");
+    cJSON* content = cJSON_GetObjectItemCaseSensitive(args, "content");
+    cJSON* tags = cJSON_GetObjectItemCaseSensitive(args, "tags");
+    if (!kind || !cJSON_IsNumber(kind) || !content || !cJSON_IsString(content) || !content->valuestring) {
+        cJSON_Delete(args);
+        free(repaired_args_json);
+        return json_error_local("nostr_post requires integer kind and string content");
+    }
+    if (tags && !cJSON_IsArray(tags)) {
+        cJSON_Delete(args);
+        free(repaired_args_json);
+        return json_error_local("nostr_post tags must be an array when provided");
+    }
+
+    cJSON* tags_dup = NULL;
+    if (tags) {
+        tags_dup = cJSON_Duplicate(tags, 1);
+        if (!tags_dup) {
+            cJSON_Delete(args);
+            free(repaired_args_json);
+            return json_error_local("nostr_post failed to duplicate tags");
+        }
+    }
+
+    ensure_nip23_metadata_tags_local((int)kind->valuedouble, content->valuestring, &tags_dup);
+
+    nostr_publish_result_t publish_result;
+    memset(&publish_result, 0, sizeof(publish_result));
+
+    int rc = nostr_handler_publish_kind_event((int)kind->valuedouble,
+                                              content->valuestring,
+                                              tags_dup,
+                                              &publish_result);
+    cJSON_Delete(tags_dup);
+    cJSON_Delete(args);
+    free(repaired_args_json);
+
+    if (rc != 0) {
+        nostr_handler_publish_result_free(&publish_result);
+        return json_error_local("nostr_post failed");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        nostr_handler_publish_result_free(&publish_result);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", publish_result.success ? 1 : 0);
+    cJSON_AddStringToObject(out, "message", "nostr_post published");
+    cJSON_AddNumberToObject(out, "kind", publish_result.kind);
+    cJSON_AddStringToObject(out, "event_id", publish_result.event_id);
+    cJSON_AddNumberToObject(out, "relay_count", publish_result.relay_count);
+    cJSON_AddNumberToObject(out, "accepted_by_pool_count", publish_result.accepted_by_pool_count);
+
+    if (publish_result.note_uri[0] != '\0') cJSON_AddStringToObject(out, "note_uri", publish_result.note_uri);
+    if (publish_result.naddr_uri[0] != '\0') cJSON_AddStringToObject(out, "naddr_uri", publish_result.naddr_uri);
+    if (publish_result.d_tag[0] != '\0') cJSON_AddStringToObject(out, "d_tag", publish_result.d_tag);
+
+    cJSON* relays = cJSON_CreateArray();
+    if (!relays) {
+        nostr_handler_publish_result_free(&publish_result);
+        cJSON_Delete(out);
+        return NULL;
+    }
+    for (int i = 0; i < publish_result.relay_count; i++) {
+        cJSON_AddItemToArray(relays, cJSON_CreateString(publish_result.relays[i] ? publish_result.relays[i] : ""));
+    }
+    cJSON_AddItemToObject(out, "relays", relays);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    nostr_handler_publish_result_free(&publish_result);
+    return json;
+}
+
+char* execute_nostr_post_readme(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_tool_args_json_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char readme_path[PATH_MAX];
+    if (build_tool_path_local(ctx, "README.md", readme_path, sizeof(readme_path)) != 0) {
+        return json_error_local("failed to resolve README path");
+    }
+
+    size_t bytes_read = 0;
+    char* content = read_entire_file_local(readme_path, &bytes_read);
+    if (!content) {
+        return json_error_local("failed to read README.md");
+    }
+
+    cJSON* tags = cJSON_CreateArray();
+    if (!tags) {
+        free(content);
+        return json_error_local("failed to create tags");
+    }
+
+    if (add_string_tag_local(tags, "d", "readme.md") != 0 ||
+        add_string_tag_local(tags,
+                             "image",
+                             "https://laantungir.github.io/img_repo/d21c4060632ab3d9d37a6062eeecbdbfbd67f03cb20dbd64838b1ba0d9cd8922.jpg") != 0) {
+        cJSON_Delete(tags);
+        free(content);
+        return json_error_local("failed to set required tags");
+    }
+
+    ensure_nip23_metadata_tags_local(30023, content, &tags);
+
+    nostr_publish_result_t publish_result;
+    memset(&publish_result, 0, sizeof(publish_result));
+
+    int rc = nostr_handler_publish_kind_event(30023, content, tags, &publish_result);
+    cJSON_Delete(tags);
+    free(content);
+
+    if (rc != 0) {
+        nostr_handler_publish_result_free(&publish_result);
+        return json_error_local("nostr_post_readme failed");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        nostr_handler_publish_result_free(&publish_result);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", publish_result.success ? 1 : 0);
+    cJSON_AddStringToObject(out, "message", "nostr_post_readme published");
+    cJSON_AddStringToObject(out, "path", readme_path);
+    cJSON_AddNumberToObject(out, "bytes_read", (double)bytes_read);
+    cJSON_AddNumberToObject(out, "kind", publish_result.kind);
+    cJSON_AddStringToObject(out, "event_id", publish_result.event_id);
+    cJSON_AddNumberToObject(out, "relay_count", publish_result.relay_count);
+    cJSON_AddNumberToObject(out, "accepted_by_pool_count", publish_result.accepted_by_pool_count);
+
+    if (publish_result.note_uri[0] != '\0') cJSON_AddStringToObject(out, "note_uri", publish_result.note_uri);
+    if (publish_result.naddr_uri[0] != '\0') cJSON_AddStringToObject(out, "naddr_uri", publish_result.naddr_uri);
+    if (publish_result.d_tag[0] != '\0') cJSON_AddStringToObject(out, "d_tag", publish_result.d_tag);
+
+    cJSON* relays = cJSON_CreateArray();
+    if (!relays) {
+        nostr_handler_publish_result_free(&publish_result);
+        cJSON_Delete(out);
+        return NULL;
+    }
+    for (int i = 0; i < publish_result.relay_count; i++) {
+        cJSON_AddItemToArray(relays, cJSON_CreateString(publish_result.relays[i] ? publish_result.relays[i] : ""));
+    }
+    cJSON_AddItemToObject(out, "relays", relays);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    nostr_handler_publish_result_free(&publish_result);
+    return json;
+}
+
+char* execute_nostr_file_md_to_longform_post(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_tool_args_json_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* file = cJSON_GetObjectItemCaseSensitive(args, "file");
+    cJSON* title = cJSON_GetObjectItemCaseSensitive(args, "title");
+    cJSON* image = cJSON_GetObjectItemCaseSensitive(args, "image");
+    cJSON* summary = cJSON_GetObjectItemCaseSensitive(args, "summary");
+
+    if (!file || !cJSON_IsString(file) || !file->valuestring || file->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("nostr_file_md_to_longform_post requires string file");
+    }
+    if (title && !cJSON_IsString(title)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_file_md_to_longform_post title must be string when provided");
+    }
+    if (image && !cJSON_IsString(image)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_file_md_to_longform_post image must be string when provided");
+    }
+    if (summary && !cJSON_IsString(summary)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_file_md_to_longform_post summary must be string when provided");
+    }
+
+    char file_path[PATH_MAX];
+    if (build_tool_path_local(ctx, file->valuestring, file_path, sizeof(file_path)) != 0) {
+        cJSON_Delete(args);
+        return json_error_local("failed to resolve markdown file path");
+    }
+
+    size_t bytes_read = 0;
+    char* content = read_entire_file_local(file_path, &bytes_read);
+    if (!content) {
+        cJSON_Delete(args);
+        return json_error_local("failed to read markdown file");
+    }
+
+    char* d_tag = basename_lowercase_dup_local(file->valuestring);
+    if (!d_tag || d_tag[0] == '\0') {
+        free(d_tag);
+        free(content);
+        cJSON_Delete(args);
+        return json_error_local("failed to derive d tag from filename");
+    }
+
+    cJSON* tags = cJSON_CreateArray();
+    if (!tags) {
+        free(d_tag);
+        free(content);
+        cJSON_Delete(args);
+        return json_error_local("failed to create tags");
+    }
+
+    if (add_string_tag_local(tags, "d", d_tag) != 0) {
+        free(d_tag);
+        cJSON_Delete(tags);
+        free(content);
+        cJSON_Delete(args);
+        return json_error_local("failed to set d tag");
+    }
+
+    if (title && title->valuestring && title->valuestring[0] != '\0') {
+        if (add_string_tag_local(tags, "title", title->valuestring) != 0) {
+            free(d_tag);
+            cJSON_Delete(tags);
+            free(content);
+            cJSON_Delete(args);
+            return json_error_local("failed to set title tag");
+        }
+    }
+
+    if (image && image->valuestring && image->valuestring[0] != '\0') {
+        if (add_string_tag_local(tags, "image", image->valuestring) != 0) {
+            free(d_tag);
+            cJSON_Delete(tags);
+            free(content);
+            cJSON_Delete(args);
+            return json_error_local("failed to set image tag");
+        }
+    }
+
+    if (summary && summary->valuestring && summary->valuestring[0] != '\0') {
+        if (add_string_tag_local(tags, "summary", summary->valuestring) != 0) {
+            free(d_tag);
+            cJSON_Delete(tags);
+            free(content);
+            cJSON_Delete(args);
+            return json_error_local("failed to set summary tag");
+        }
+    }
+
+    ensure_nip23_metadata_tags_local(30023, content, &tags);
+
+    nostr_publish_result_t publish_result;
+    memset(&publish_result, 0, sizeof(publish_result));
+
+    int rc = nostr_handler_publish_kind_event(30023, content, tags, &publish_result);
+    cJSON_Delete(tags);
+    free(content);
+    cJSON_Delete(args);
+
+    if (rc != 0) {
+        free(d_tag);
+        nostr_handler_publish_result_free(&publish_result);
+        return json_error_local("nostr_file_md_to_longform_post failed");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(d_tag);
+        nostr_handler_publish_result_free(&publish_result);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", publish_result.success ? 1 : 0);
+    cJSON_AddStringToObject(out, "message", "nostr_file_md_to_longform_post published");
+    cJSON_AddStringToObject(out, "path", file_path);
+    cJSON_AddStringToObject(out, "d_tag", d_tag);
+    cJSON_AddNumberToObject(out, "bytes_read", (double)bytes_read);
+    cJSON_AddNumberToObject(out, "kind", publish_result.kind);
+    cJSON_AddStringToObject(out, "event_id", publish_result.event_id);
+    cJSON_AddNumberToObject(out, "relay_count", publish_result.relay_count);
+    cJSON_AddNumberToObject(out, "accepted_by_pool_count", publish_result.accepted_by_pool_count);
+
+    if (publish_result.note_uri[0] != '\0') cJSON_AddStringToObject(out, "note_uri", publish_result.note_uri);
+    if (publish_result.naddr_uri[0] != '\0') cJSON_AddStringToObject(out, "naddr_uri", publish_result.naddr_uri);
+
+    cJSON* relays = cJSON_CreateArray();
+    if (!relays) {
+        free(d_tag);
+        nostr_handler_publish_result_free(&publish_result);
+        cJSON_Delete(out);
+        return NULL;
+    }
+    for (int i = 0; i < publish_result.relay_count; i++) {
+        cJSON_AddItemToArray(relays, cJSON_CreateString(publish_result.relays[i] ? publish_result.relays[i] : ""));
+    }
+    cJSON_AddItemToObject(out, "relays", relays);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(d_tag);
+    nostr_handler_publish_result_free(&publish_result);
+    return json;
+}

src/tools/tool_nostr_query.c

@@ -0,0 +1,62 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdlib.h>
+
+#include "cjson/cJSON.h"
+#include "../nostr_handler.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+char* execute_nostr_query(const char* args_json) {
+    cJSON* args = cJSON_Parse(args_json ? args_json : "{}");
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* filter = cJSON_GetObjectItemCaseSensitive(args, "filter");
+    cJSON* timeout = cJSON_GetObjectItemCaseSensitive(args, "timeout_ms");
+    if (!filter || !cJSON_IsObject(filter)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_query requires object filter");
+    }
+
+    cJSON* filter_dup = cJSON_Duplicate(filter, 1);
+    if (!filter_dup) {
+        cJSON_Delete(args);
+        return json_error_local("failed to duplicate filter");
+    }
+
+    int timeout_ms = (timeout && cJSON_IsNumber(timeout)) ? (int)timeout->valuedouble : 8000;
+    char* events_json = nostr_handler_query_json(filter_dup, timeout_ms);
+    cJSON_Delete(filter_dup);
+    cJSON_Delete(args);
+
+    if (!events_json) return json_error_local("nostr_query failed");
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(events_json);
+        return NULL;
+    }
+
+    cJSON* events = cJSON_Parse(events_json);
+    free(events_json);
+    if (!events) {
+        cJSON_Delete(out);
+        return json_error_local("nostr_query returned invalid JSON");
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddItemToObject(out, "events", events);
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}

src/tools/tool_nostr_relay.c

@@ -0,0 +1,94 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdlib.h>
+
+#include "cjson/cJSON.h"
+#include "../nostr_handler.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+char* execute_nostr_relay_status(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+    cJSON_Delete(args);
+
+    char* status_json = nostr_handler_relay_status_json();
+    if (!status_json) {
+        return json_error_local("nostr_relay_status failed");
+    }
+
+    cJSON* status = cJSON_Parse(status_json);
+    free(status_json);
+    if (!status) {
+        return json_error_local("nostr_relay_status returned invalid JSON");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        cJSON_Delete(status);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddItemToObject(out, "status", status);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_relay_info(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* relay_url = cJSON_GetObjectItemCaseSensitive(args, "relay_url");
+    if (!relay_url || !cJSON_IsString(relay_url) || !relay_url->valuestring || relay_url->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("nostr_relay_info requires relay_url");
+    }
+
+    char* info_json = nostr_handler_relay_info_json(relay_url->valuestring);
+    cJSON_Delete(args);
+    if (!info_json) {
+        return json_error_local("nostr_relay_info failed");
+    }
+
+    cJSON* info = cJSON_Parse(info_json);
+    free(info_json);
+    if (!info || !cJSON_IsObject(info)) {
+        cJSON_Delete(info);
+        return json_error_local("nostr_relay_info returned invalid JSON");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        cJSON_Delete(info);
+        return NULL;
+    }
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddItemToObject(out, "info", info);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}

src/tools/tool_nostr_social.c

@@ -0,0 +1,302 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cjson/cJSON.h"
+#include "../nostr_handler.h"
+#include "../../nostr_core_lib/nostr_core/nostr_core.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+static int is_hex_string_len_local(const char* s, size_t expected_len) {
+    if (!s) return 0;
+    if (strlen(s) != expected_len) return 0;
+    for (size_t i = 0; i < expected_len; i++) {
+        if (!((s[i] >= '0' && s[i] <= '9') ||
+              (s[i] >= 'a' && s[i] <= 'f') ||
+              (s[i] >= 'A' && s[i] <= 'F'))) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static int add_string_tag_local(cJSON* tags, const char* key, const char* value) {
+    if (!tags || !cJSON_IsArray(tags) || !key || !value) return -1;
+    cJSON* tuple = cJSON_CreateArray();
+    if (!tuple) return -1;
+    cJSON_AddItemToArray(tuple, cJSON_CreateString(key));
+    cJSON_AddItemToArray(tuple, cJSON_CreateString(value));
+    cJSON_AddItemToArray(tags, tuple);
+    return 0;
+}
+
+static void free_string_array_heap_local(char** items, int count) {
+    if (!items) return;
+    for (int i = 0; i < count; i++) free(items[i]);
+    free(items);
+}
+
+char* execute_nostr_react(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* event_id = cJSON_GetObjectItemCaseSensitive(args, "event_id");
+    cJSON* event_pubkey = cJSON_GetObjectItemCaseSensitive(args, "event_pubkey");
+    cJSON* event_kind = cJSON_GetObjectItemCaseSensitive(args, "event_kind");
+    cJSON* reaction = cJSON_GetObjectItemCaseSensitive(args, "reaction");
+
+    if (!event_id || !cJSON_IsString(event_id) || !event_id->valuestring || !is_hex_string_len_local(event_id->valuestring, 64U) ||
+        !event_pubkey || !cJSON_IsString(event_pubkey) || !event_pubkey->valuestring || !is_hex_string_len_local(event_pubkey->valuestring, 64U)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_react requires event_id and event_pubkey as 64-char hex strings");
+    }
+    if (event_kind && !cJSON_IsNumber(event_kind)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_react event_kind must be an integer when provided");
+    }
+    if (reaction && !cJSON_IsString(reaction)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_react reaction must be a string when provided");
+    }
+
+    cJSON* tags = cJSON_CreateArray();
+    if (!tags) {
+        cJSON_Delete(args);
+        return json_error_local("failed to create tags");
+    }
+
+    if (add_string_tag_local(tags, "e", event_id->valuestring) != 0 ||
+        add_string_tag_local(tags, "p", event_pubkey->valuestring) != 0) {
+        cJSON_Delete(tags);
+        cJSON_Delete(args);
+        return json_error_local("failed to add required reaction tags");
+    }
+
+    if (event_kind) {
+        char kind_buf[32];
+        snprintf(kind_buf, sizeof(kind_buf), "%d", (int)event_kind->valuedouble);
+        if (add_string_tag_local(tags, "k", kind_buf) != 0) {
+            cJSON_Delete(tags);
+            cJSON_Delete(args);
+            return json_error_local("failed to add k tag");
+        }
+    }
+
+    const char* reaction_content = (reaction && reaction->valuestring && reaction->valuestring[0] != '\0') ? reaction->valuestring : "+";
+
+    nostr_publish_result_t publish_result;
+    memset(&publish_result, 0, sizeof(publish_result));
+
+    int rc = nostr_handler_publish_kind_event(7, reaction_content, tags, &publish_result);
+    cJSON_Delete(tags);
+    cJSON_Delete(args);
+    if (rc != 0) {
+        nostr_handler_publish_result_free(&publish_result);
+        return json_error_local("nostr_react failed");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        nostr_handler_publish_result_free(&publish_result);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", publish_result.success ? 1 : 0);
+    cJSON_AddStringToObject(out, "message", "nostr_react published");
+    cJSON_AddStringToObject(out, "reaction", reaction_content);
+    cJSON_AddNumberToObject(out, "kind", publish_result.kind);
+    cJSON_AddStringToObject(out, "event_id", publish_result.event_id);
+    cJSON_AddNumberToObject(out, "relay_count", publish_result.relay_count);
+    cJSON_AddNumberToObject(out, "accepted_by_pool_count", publish_result.accepted_by_pool_count);
+
+    cJSON* relays = cJSON_CreateArray();
+    if (!relays) {
+        nostr_handler_publish_result_free(&publish_result);
+        cJSON_Delete(out);
+        return NULL;
+    }
+    for (int i = 0; i < publish_result.relay_count; i++) {
+        cJSON_AddItemToArray(relays, cJSON_CreateString(publish_result.relays[i] ? publish_result.relays[i] : ""));
+    }
+    cJSON_AddItemToObject(out, "relays", relays);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    nostr_handler_publish_result_free(&publish_result);
+    return json;
+}
+
+char* execute_nostr_profile_get(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* pubkey = cJSON_GetObjectItemCaseSensitive(args, "pubkey");
+    if (!pubkey || !cJSON_IsString(pubkey) || !pubkey->valuestring || !is_hex_string_len_local(pubkey->valuestring, 64U)) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_profile_get requires pubkey as 64-char hex string");
+    }
+
+    cJSON* filter = cJSON_CreateObject();
+    cJSON* kinds = cJSON_CreateArray();
+    cJSON* authors = cJSON_CreateArray();
+    if (!filter || !kinds || !authors) {
+        cJSON_Delete(filter);
+        cJSON_Delete(kinds);
+        cJSON_Delete(authors);
+        cJSON_Delete(args);
+        return json_error_local("failed to create profile query filter");
+    }
+
+    cJSON_AddItemToArray(kinds, cJSON_CreateNumber(0));
+    cJSON_AddItemToObject(filter, "kinds", kinds);
+    cJSON_AddItemToArray(authors, cJSON_CreateString(pubkey->valuestring));
+    cJSON_AddItemToObject(filter, "authors", authors);
+    cJSON_AddNumberToObject(filter, "limit", 1);
+
+    char* events_json = nostr_handler_query_json(filter, 8000);
+    cJSON_Delete(filter);
+    cJSON_Delete(args);
+    if (!events_json) {
+        return json_error_local("nostr_profile_get query failed");
+    }
+
+    cJSON* events = cJSON_Parse(events_json);
+    free(events_json);
+    if (!events || !cJSON_IsArray(events)) {
+        cJSON_Delete(events);
+        return json_error_local("nostr_profile_get returned invalid events JSON");
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        cJSON_Delete(events);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+
+    int found = cJSON_GetArraySize(events) > 0;
+    cJSON_AddBoolToObject(out, "found", found ? 1 : 0);
+
+    if (found) {
+        cJSON* ev = cJSON_GetArrayItem(events, 0);
+        cJSON* ev_dup = ev ? cJSON_Duplicate(ev, 1) : NULL;
+        if (ev_dup) {
+            cJSON_AddItemToObject(out, "event", ev_dup);
+        }
+
+        cJSON* content = ev ? cJSON_GetObjectItemCaseSensitive(ev, "content") : NULL;
+        if (content && cJSON_IsString(content) && content->valuestring) {
+            cJSON* profile = cJSON_Parse(content->valuestring);
+            if (profile && cJSON_IsObject(profile)) {
+                cJSON_AddItemToObject(out, "profile", profile);
+            } else {
+                cJSON_Delete(profile);
+                cJSON_AddStringToObject(out, "profile_raw", content->valuestring);
+            }
+        }
+    }
+
+    cJSON_Delete(events);
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}
+
+char* execute_nostr_nip05_lookup(const char* args_json) {
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* identifier = cJSON_GetObjectItemCaseSensitive(args, "identifier");
+    cJSON* pubkey = cJSON_GetObjectItemCaseSensitive(args, "pubkey");
+
+    if (!identifier || !cJSON_IsString(identifier) || !identifier->valuestring || strchr(identifier->valuestring, '@') == NULL) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_nip05_lookup requires identifier in user@domain format");
+    }
+    if (pubkey && (!cJSON_IsString(pubkey) || !pubkey->valuestring || !is_hex_string_len_local(pubkey->valuestring, 64U))) {
+        cJSON_Delete(args);
+        return json_error_local("nostr_nip05_lookup pubkey must be a 64-char hex string when provided");
+    }
+
+    char found_pubkey[65] = {0};
+    char** relays = NULL;
+    int relay_count = 0;
+    int rc = 0;
+
+    if (pubkey) {
+        rc = nostr_nip05_verify(identifier->valuestring,
+                                pubkey->valuestring,
+                                &relays,
+                                &relay_count,
+                                10);
+    } else {
+        rc = nostr_nip05_lookup(identifier->valuestring,
+                                found_pubkey,
+                                &relays,
+                                &relay_count,
+                                10);
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free_string_array_heap_local(relays, relay_count);
+        cJSON_Delete(args);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", rc == NOSTR_SUCCESS ? 1 : 0);
+    cJSON_AddStringToObject(out, "identifier", identifier->valuestring);
+
+    if (pubkey) {
+        cJSON_AddBoolToObject(out, "verified", rc == NOSTR_SUCCESS ? 1 : 0);
+        cJSON_AddStringToObject(out, "pubkey", pubkey->valuestring);
+    } else if (rc == NOSTR_SUCCESS) {
+        cJSON_AddStringToObject(out, "pubkey", found_pubkey);
+    }
+
+    cJSON* relay_arr = cJSON_CreateArray();
+    if (!relay_arr) {
+        cJSON_Delete(out);
+        free_string_array_heap_local(relays, relay_count);
+        cJSON_Delete(args);
+        return NULL;
+    }
+    for (int i = 0; i < relay_count; i++) {
+        cJSON_AddItemToArray(relay_arr, cJSON_CreateString(relays[i] ? relays[i] : ""));
+    }
+    cJSON_AddItemToObject(out, "relays", relay_arr);
+
+    if (rc != NOSTR_SUCCESS) {
+        cJSON_AddNumberToObject(out, "error_code", rc);
+    }
+
+    free_string_array_heap_local(relays, relay_count);
+    cJSON_Delete(args);
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    return json;
+}

src/tools/tool_task.c

@@ -0,0 +1,565 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "cjson/cJSON.h"
+
+static char* json_error_local(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+static cJSON* parse_args_local(const char* args_json) {
+    const char* raw = args_json ? args_json : "{}";
+    cJSON* args = cJSON_Parse(raw);
+    if (!args || !cJSON_IsObject(args)) {
+        cJSON_Delete(args);
+        return NULL;
+    }
+    return args;
+}
+
+static int is_safe_relative_path_local(const char* path) {
+    if (!path || path[0] == '\0') return 0;
+    if (path[0] == '/') return 0;
+    if (strstr(path, "..") != NULL) return 0;
+    if (strchr(path, '\\') != NULL) return 0;
+    return 1;
+}
+
+static int build_tool_path_local(tools_context_t* ctx, const char* rel_path, char* out, size_t out_size) {
+    if (!ctx || !ctx->cfg || !rel_path || !out || out_size == 0) return -1;
+    if (!is_safe_relative_path_local(rel_path)) return -1;
+
+    const char* cwd = ctx->cfg->tools.shell.working_directory[0] != '\0'
+                          ? ctx->cfg->tools.shell.working_directory
+                          : ".";
+
+    int n = 0;
+    if (strcmp(cwd, ".") == 0) {
+        n = snprintf(out, out_size, "%s", rel_path);
+    } else {
+        n = snprintf(out, out_size, "%s/%s", cwd, rel_path);
+    }
+
+    if (n < 0 || (size_t)n >= out_size) return -1;
+    return 0;
+}
+
+static cJSON* tasks_create_empty_root_local(void) {
+    cJSON* root = cJSON_CreateObject();
+    cJSON* tasks = cJSON_CreateArray();
+    if (!root || !tasks) {
+        cJSON_Delete(root);
+        cJSON_Delete(tasks);
+        return NULL;
+    }
+    cJSON_AddItemToObject(root, "tasks", tasks);
+    cJSON_AddNumberToObject(root, "next_id", 1);
+    return root;
+}
+
+static const char* normalize_task_status_local(const char* status) {
+    if (!status) return NULL;
+    if (strcmp(status, "pending") == 0) return "pending";
+    if (strcmp(status, "active") == 0) return "active";
+    if (strcmp(status, "done") == 0) return "done";
+    return NULL;
+}
+
+static cJSON* tasks_load_root_local(const char* path) {
+    if (!path) return NULL;
+
+    FILE* fp = fopen(path, "rb");
+    if (!fp) {
+        if (access(path, F_OK) == 0) {
+            return NULL;
+        }
+        return tasks_create_empty_root_local();
+    }
+
+    if (fseek(fp, 0, SEEK_END) != 0) {
+        fclose(fp);
+        return NULL;
+    }
+    long len = ftell(fp);
+    if (len < 0) {
+        fclose(fp);
+        return NULL;
+    }
+    if (fseek(fp, 0, SEEK_SET) != 0) {
+        fclose(fp);
+        return NULL;
+    }
+
+    char* buf = (char*)malloc((size_t)len + 1U);
+    if (!buf) {
+        fclose(fp);
+        return NULL;
+    }
+
+    size_t n = fread(buf, 1, (size_t)len, fp);
+    fclose(fp);
+    if (n != (size_t)len) {
+        free(buf);
+        return NULL;
+    }
+    buf[len] = '\0';
+
+    cJSON* root = cJSON_Parse(buf);
+    free(buf);
+    if (!root || !cJSON_IsObject(root)) {
+        cJSON_Delete(root);
+        return NULL;
+    }
+
+    cJSON* tasks = cJSON_GetObjectItemCaseSensitive(root, "tasks");
+    if (!tasks || !cJSON_IsArray(tasks)) {
+        cJSON_DeleteItemFromObjectCaseSensitive(root, "tasks");
+        cJSON_AddItemToObject(root, "tasks", cJSON_CreateArray());
+    }
+
+    cJSON* next_id = cJSON_GetObjectItemCaseSensitive(root, "next_id");
+    if (!next_id || !cJSON_IsNumber(next_id) || next_id->valuedouble < 1) {
+        cJSON_DeleteItemFromObjectCaseSensitive(root, "next_id");
+        cJSON_AddNumberToObject(root, "next_id", 1);
+    }
+
+    return root;
+}
+
+static int tasks_save_root_local(const char* path, cJSON* root) {
+    if (!path || !root) return -1;
+    char* raw = cJSON_PrintUnformatted(root);
+    if (!raw) return -1;
+
+    FILE* fp = fopen(path, "wb");
+    if (!fp) {
+        free(raw);
+        return -1;
+    }
+
+    size_t len = strlen(raw);
+    size_t n = fwrite(raw, 1, len, fp);
+    fclose(fp);
+    free(raw);
+    return (n == len) ? 0 : -1;
+}
+
+static cJSON* task_find_by_id_local(cJSON* tasks, int id, int* out_index) {
+    if (!tasks || !cJSON_IsArray(tasks) || id <= 0) return NULL;
+    int n = cJSON_GetArraySize(tasks);
+    for (int i = 0; i < n; i++) {
+        cJSON* task = cJSON_GetArrayItem(tasks, i);
+        cJSON* tid = task ? cJSON_GetObjectItemCaseSensitive(task, "id") : NULL;
+        if (tid && cJSON_IsNumber(tid) && (int)tid->valuedouble == id) {
+            if (out_index) *out_index = i;
+            return task;
+        }
+    }
+    return NULL;
+}
+
+char* execute_task_manage(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) return json_error_local("invalid arguments JSON");
+
+    cJSON* action = cJSON_GetObjectItemCaseSensitive(args, "action");
+    if (!action || !cJSON_IsString(action) || !action->valuestring || action->valuestring[0] == '\0') {
+        cJSON_Delete(args);
+        return json_error_local("task_manage requires string action");
+    }
+
+    char tasks_path[PATH_MAX];
+    if (build_tool_path_local(ctx, "tasks.json", tasks_path, sizeof(tasks_path)) != 0) {
+        cJSON_Delete(args);
+        return json_error_local("failed to resolve tasks file path");
+    }
+
+    cJSON* root = tasks_load_root_local(tasks_path);
+    if (!root) {
+        cJSON_Delete(args);
+        return json_error_local("failed to load tasks file");
+    }
+
+    cJSON* tasks = cJSON_GetObjectItemCaseSensitive(root, "tasks");
+    if (!tasks || !cJSON_IsArray(tasks)) {
+        cJSON_DeleteItemFromObjectCaseSensitive(root, "tasks");
+        tasks = cJSON_CreateArray();
+        cJSON_AddItemToObject(root, "tasks", tasks);
+    }
+
+    cJSON* next_id_item = cJSON_GetObjectItemCaseSensitive(root, "next_id");
+    int next_id = (next_id_item && cJSON_IsNumber(next_id_item) && next_id_item->valuedouble >= 1)
+                    ? (int)next_id_item->valuedouble
+                    : 1;
+
+    const char* action_s = action->valuestring;
+    int mutated = 0;
+
+    if (strcmp(action_s, "list") == 0) {
+    } else if (strcmp(action_s, "add") == 0) {
+        cJSON* text = cJSON_GetObjectItemCaseSensitive(args, "text");
+        cJSON* status = cJSON_GetObjectItemCaseSensitive(args, "status");
+        if (!text || !cJSON_IsString(text) || !text->valuestring || text->valuestring[0] == '\0') {
+            cJSON_Delete(args);
+            cJSON_Delete(root);
+            return json_error_local("task_manage add requires non-empty string text");
+        }
+
+        const char* normalized_status = "pending";
+        if (status && !cJSON_IsNull(status)) {
+            if (!cJSON_IsString(status) || !status->valuestring) {
+                cJSON_Delete(args);
+                cJSON_Delete(root);
+                return json_error_local("task_manage add status must be string when provided");
+            }
+            normalized_status = normalize_task_status_local(status->valuestring);
+            if (!normalized_status) {
+                cJSON_Delete(args);
+                cJSON_Delete(root);
+                return json_error_local("task_manage add status must be pending, active, or done");
+            }
+        }
+
+        cJSON* task = cJSON_CreateObject();
+        if (!task) {
+            cJSON_Delete(args);
+            cJSON_Delete(root);
+            return json_error_local("allocation failure");
+        }
+
+        time_t now = time(NULL);
+        cJSON_AddNumberToObject(task, "id", next_id++);
+        cJSON_AddStringToObject(task, "text", text->valuestring);
+        cJSON_AddStringToObject(task, "status", normalized_status);
+        cJSON_AddNumberToObject(task, "created_at", (double)now);
+        cJSON_AddNumberToObject(task, "updated_at", (double)now);
+        cJSON_AddItemToArray(tasks, task);
+        mutated = 1;
+    } else if (strcmp(action_s, "update") == 0) {
+        cJSON* id = cJSON_GetObjectItemCaseSensitive(args, "id");
+        cJSON* text = cJSON_GetObjectItemCaseSensitive(args, "text");
+        cJSON* status = cJSON_GetObjectItemCaseSensitive(args, "status");
+
+        if (!id || !cJSON_IsNumber(id) || id->valuedouble < 1) {
+            cJSON_Delete(args);
+            cJSON_Delete(root);
+            return json_error_local("task_manage update requires integer id");
+        }
+
+        if ((!text || cJSON_IsNull(text)) && (!status || cJSON_IsNull(status))) {
+            cJSON_Delete(args);
+            cJSON_Delete(root);
+            return json_error_local("task_manage update requires text and/or status");
+        }
+
+        cJSON* task = task_find_by_id_local(tasks, (int)id->valuedouble, NULL);
+        if (!task) {
+            cJSON_Delete(args);
+            cJSON_Delete(root);
+            return json_error_local("task not found");
+        }
+
+        if (text && !cJSON_IsNull(text)) {
+            if (!cJSON_IsString(text) || !text->valuestring || text->valuestring[0] == '\0') {
+                cJSON_Delete(args);
+                cJSON_Delete(root);
+                return json_error_local("task_manage update text must be non-empty string when provided");
+            }
+            cJSON_DeleteItemFromObjectCaseSensitive(task, "text");
+            cJSON_AddStringToObject(task, "text", text->valuestring);
+            mutated = 1;
+        }
+
+        if (status && !cJSON_IsNull(status)) {
+            if (!cJSON_IsString(status) || !status->valuestring) {
+                cJSON_Delete(args);
+                cJSON_Delete(root);
+                return json_error_local("task_manage update status must be string when provided");
+            }
+            const char* normalized_status = normalize_task_status_local(status->valuestring);
+            if (!normalized_status) {
+                cJSON_Delete(args);
+                cJSON_Delete(root);
+                return json_error_local("task_manage update status must be pending, active, or done");
+            }
+            cJSON_DeleteItemFromObjectCaseSensitive(task, "status");
+            cJSON_AddStringToObject(task, "status", normalized_status);
+            mutated = 1;
+        }
+
+        if (mutated) {
+            time_t now = time(NULL);
+            cJSON_DeleteItemFromObjectCaseSensitive(task, "updated_at");
+            cJSON_AddNumberToObject(task, "updated_at", (double)now);
+        }
+    } else if (strcmp(action_s, "remove") == 0) {
+        cJSON* id = cJSON_GetObjectItemCaseSensitive(args, "id");
+        if (!id || !cJSON_IsNumber(id) || id->valuedouble < 1) {
+            cJSON_Delete(args);
+            cJSON_Delete(root);
+            return json_error_local("task_manage remove requires integer id");
+        }
+
+        int idx = -1;
+        cJSON* task = task_find_by_id_local(tasks, (int)id->valuedouble, &idx);
+        if (!task || idx < 0) {
+            cJSON_Delete(args);
+            cJSON_Delete(root);
+            return json_error_local("task not found");
+        }
+
+        cJSON_DeleteItemFromArray(tasks, idx);
+        mutated = 1;
+    } else if (strcmp(action_s, "clear") == 0) {
+        cJSON* status = cJSON_GetObjectItemCaseSensitive(args, "status");
+        if (!status || cJSON_IsNull(status)) {
+            while (cJSON_GetArraySize(tasks) > 0) {
+                cJSON_DeleteItemFromArray(tasks, 0);
+            }
+            mutated = 1;
+        } else {
+            if (!cJSON_IsString(status) || !status->valuestring) {
+                cJSON_Delete(args);
+                cJSON_Delete(root);
+                return json_error_local("task_manage clear status must be string when provided");
+            }
+            const char* normalized_status = normalize_task_status_local(status->valuestring);
+            if (!normalized_status) {
+                cJSON_Delete(args);
+                cJSON_Delete(root);
+                return json_error_local("task_manage clear status must be pending, active, or done");
+            }
+
+            int i = 0;
+            while (i < cJSON_GetArraySize(tasks)) {
+                cJSON* task = cJSON_GetArrayItem(tasks, i);
+                cJSON* task_status = task ? cJSON_GetObjectItemCaseSensitive(task, "status") : NULL;
+                const char* task_status_s = (task_status && cJSON_IsString(task_status) && task_status->valuestring)
+                                              ? task_status->valuestring
+                                              : "pending";
+                if (strcmp(task_status_s, normalized_status) == 0) {
+                    cJSON_DeleteItemFromArray(tasks, i);
+                    mutated = 1;
+                } else {
+                    i++;
+                }
+            }
+        }
+    } else if (strcmp(action_s, "replace") == 0) {
+        cJSON* tasks_in = cJSON_GetObjectItemCaseSensitive(args, "tasks");
+        if (!tasks_in || !cJSON_IsArray(tasks_in)) {
+            cJSON_Delete(args);
+            cJSON_Delete(root);
+            return json_error_local("task_manage replace requires array tasks");
+        }
+
+        while (cJSON_GetArraySize(tasks) > 0) {
+            cJSON_DeleteItemFromArray(tasks, 0);
+        }
+
+        int n = cJSON_GetArraySize(tasks_in);
+        time_t now = time(NULL);
+        for (int i = 0; i < n; i++) {
+            cJSON* text = cJSON_GetArrayItem(tasks_in, i);
+            if (!text || !cJSON_IsString(text) || !text->valuestring || text->valuestring[0] == '\0') {
+                continue;
+            }
+
+            cJSON* task = cJSON_CreateObject();
+            if (!task) {
+                cJSON_Delete(args);
+                cJSON_Delete(root);
+                return json_error_local("allocation failure");
+            }
+
+            cJSON_AddNumberToObject(task, "id", next_id++);
+            cJSON_AddStringToObject(task, "text", text->valuestring);
+            cJSON_AddStringToObject(task, "status", "pending");
+            cJSON_AddNumberToObject(task, "created_at", (double)now);
+            cJSON_AddNumberToObject(task, "updated_at", (double)now);
+            cJSON_AddItemToArray(tasks, task);
+        }
+        mutated = 1;
+    } else {
+        cJSON_Delete(args);
+        cJSON_Delete(root);
+        return json_error_local("task_manage action must be one of: list, add, update, remove, clear, replace");
+    }
+
+    if (mutated) {
+        cJSON_DeleteItemFromObjectCaseSensitive(root, "next_id");
+        cJSON_AddNumberToObject(root, "next_id", next_id);
+        if (tasks_save_root_local(tasks_path, root) != 0) {
+            cJSON_Delete(args);
+            cJSON_Delete(root);
+            return json_error_local("failed to save tasks file");
+        }
+    }
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        cJSON_Delete(args);
+        cJSON_Delete(root);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "action", action_s);
+    cJSON_AddStringToObject(out, "path", tasks_path);
+    cJSON_AddBoolToObject(out, "mutated", mutated ? 1 : 0);
+    cJSON_AddNumberToObject(out, "count", cJSON_GetArraySize(tasks));
+
+    cJSON* tasks_dup = cJSON_Duplicate(tasks, 1);
+    if (!tasks_dup) {
+        cJSON_Delete(args);
+        cJSON_Delete(root);
+        cJSON_Delete(out);
+        return NULL;
+    }
+    cJSON_AddItemToObject(out, "tasks", tasks_dup);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    cJSON_Delete(args);
+    cJSON_Delete(root);
+    return json;
+}
+
+char* execute_task_list(tools_context_t* ctx, const char* args_json) {
+    if (!ctx || !ctx->cfg) return json_error_local("tool context unavailable");
+
+    char* listed = execute_task_manage(ctx, "{\"action\":\"list\"}");
+    if (!listed) return json_error_local("task_list failed to list tasks");
+
+    cJSON* listed_root = cJSON_Parse(listed);
+    if (!listed_root || !cJSON_IsObject(listed_root)) {
+        cJSON_Delete(listed_root);
+        free(listed);
+        return json_error_local("task_list received invalid task_manage response");
+    }
+
+    cJSON* tasks = cJSON_GetObjectItemCaseSensitive(listed_root, "tasks");
+    int tcount = (tasks && cJSON_IsArray(tasks)) ? cJSON_GetArraySize(tasks) : 0;
+
+    size_t cap = 512U;
+    char* content = (char*)malloc(cap);
+    if (!content) {
+        cJSON_Delete(listed_root);
+        free(listed);
+        return NULL;
+    }
+    size_t used = 0U;
+    int n = snprintf(content + used,
+                     cap - used,
+                     "## Current Task List\n\n### Current Tasks\n\nYour active task list - short-term working memory for tracking plan steps.\n\n");
+    if (n < 0) {
+        free(content);
+        cJSON_Delete(listed_root);
+        free(listed);
+        return NULL;
+    }
+    used += (size_t)n;
+
+    int written = 0;
+    for (int i = 0; i < tcount; i++) {
+        cJSON* task = cJSON_GetArrayItem(tasks, i);
+        cJSON* id = task ? cJSON_GetObjectItemCaseSensitive(task, "id") : NULL;
+        cJSON* text = task ? cJSON_GetObjectItemCaseSensitive(task, "text") : NULL;
+        cJSON* status = task ? cJSON_GetObjectItemCaseSensitive(task, "status") : NULL;
+        if (!text || !cJSON_IsString(text) || !text->valuestring || text->valuestring[0] == '\0') {
+            continue;
+        }
+
+        const char* status_s = (status && cJSON_IsString(status) && status->valuestring) ? status->valuestring : "pending";
+        const char* mark = " ";
+        if (strcmp(status_s, "done") == 0) mark = "x";
+        else if (strcmp(status_s, "active") == 0) mark = "-";
+
+        int id_value = (id && cJSON_IsNumber(id)) ? (int)id->valuedouble : (i + 1);
+
+        int needed = snprintf(NULL, 0, "- [%s] %d. %s\n", mark, id_value, text->valuestring);
+        if (needed < 0) continue;
+        if (used + (size_t)needed + 1U > cap) {
+            size_t next = cap;
+            while (used + (size_t)needed + 1U > next) next *= 2U;
+            char* grown = (char*)realloc(content, next);
+            if (!grown) {
+                free(content);
+                cJSON_Delete(listed_root);
+                free(listed);
+                return NULL;
+            }
+            content = grown;
+            cap = next;
+        }
+        snprintf(content + used, cap - used, "- [%s] %d. %s\n", mark, id_value, text->valuestring);
+        used += (size_t)needed;
+        written++;
+    }
+
+    if (written == 0) {
+        const char* fallback = "- [ ] No active tasks yet.\n";
+        size_t need = strlen(fallback);
+        if (used + need + 1U > cap) {
+            size_t next = cap;
+            while (used + need + 1U > next) next *= 2U;
+            char* grown = (char*)realloc(content, next);
+            if (!grown) {
+                free(content);
+                cJSON_Delete(listed_root);
+                free(listed);
+                return NULL;
+            }
+            content = grown;
+            cap = next;
+        }
+        memcpy(content + used, fallback, need + 1U);
+        used += need;
+    }
+
+    cJSON* args = parse_args_local(args_json);
+    if (!args) {
+        free(content);
+        cJSON_Delete(listed_root);
+        free(listed);
+        return json_error_local("invalid arguments JSON");
+    }
+    cJSON_Delete(args);
+
+    cJSON* out = cJSON_CreateObject();
+    if (!out) {
+        free(content);
+        cJSON_Delete(listed_root);
+        free(listed);
+        return NULL;
+    }
+
+    cJSON_AddBoolToObject(out, "success", 1);
+    cJSON_AddStringToObject(out, "content", content);
+    cJSON* tasks_dup = tasks ? cJSON_Duplicate(tasks, 1) : cJSON_CreateArray();
+    if (!tasks_dup) tasks_dup = cJSON_CreateArray();
+    cJSON_AddItemToObject(out, "tasks", tasks_dup);
+
+    char* json = cJSON_PrintUnformatted(out);
+    cJSON_Delete(out);
+    free(content);
+    cJSON_Delete(listed_root);
+    free(listed);
+    return json;
+}

src/tools/tools.h

@@ -3,8 +3,13 @@
 
 #include "config.h"
 
+struct trigger_manager;
+
 typedef struct {
     didactyl_config_t* cfg;
+    struct trigger_manager* trigger_manager;
+    int template_sender_tier;
+    const char* template_current_user_message;
 } tools_context_t;
 
 int tools_init(tools_context_t* ctx, didactyl_config_t* cfg);

src/tools/tools_common.c

@@ -0,0 +1,3 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"

src/tools/tools_dispatch.c

@@ -0,0 +1,215 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "tools_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "cjson/cJSON.h"
+
+static char* json_error(const char* msg) {
+    cJSON* root = cJSON_CreateObject();
+    if (!root) return NULL;
+    cJSON_AddBoolToObject(root, "success", 0);
+    cJSON_AddStringToObject(root, "error", msg ? msg : "unknown error");
+    char* out = cJSON_PrintUnformatted(root);
+    cJSON_Delete(root);
+    return out;
+}
+
+int tools_init_legacy(tools_context_t* ctx, didactyl_config_t* cfg) {
+    if (!ctx || !cfg) return -1;
+    memset(ctx, 0, sizeof(*ctx));
+    ctx->cfg = cfg;
+    ctx->trigger_manager = NULL;
+    ctx->template_sender_tier = 0;
+    ctx->template_current_user_message = NULL;
+    return 0;
+}
+
+void tools_cleanup_legacy(tools_context_t* ctx) {
+    if (!ctx) return;
+    memset(ctx, 0, sizeof(*ctx));
+}
+
+char* tools_execute_legacy(tools_context_t* ctx, const char* tool_name, const char* args_json) {
+    if (!tool_name) return json_error("missing tool name");
+
+    if (strcmp(tool_name, "nostr_post") == 0) {
+        return execute_nostr_post(args_json);
+    }
+    if (strcmp(tool_name, "nostr_delete") == 0) {
+        return execute_nostr_delete(args_json);
+    }
+    if (strcmp(tool_name, "nostr_react") == 0) {
+        return execute_nostr_react(args_json);
+    }
+    if (strcmp(tool_name, "nostr_profile_get") == 0) {
+        return execute_nostr_profile_get(args_json);
+    }
+    if (strcmp(tool_name, "nostr_relay_status") == 0) {
+        return execute_nostr_relay_status(args_json);
+    }
+    if (strcmp(tool_name, "nostr_nip05_lookup") == 0) {
+        return execute_nostr_nip05_lookup(args_json);
+    }
+    if (strcmp(tool_name, "nostr_encode") == 0) {
+        return execute_nostr_encode(args_json);
+    }
+    if (strcmp(tool_name, "nostr_decode") == 0) {
+        return execute_nostr_decode(args_json);
+    }
+    if (strcmp(tool_name, "nostr_dm_send") == 0) {
+        return execute_nostr_dm_send(args_json);
+    }
+    if (strcmp(tool_name, "nostr_relay_info") == 0) {
+        return execute_nostr_relay_info(args_json);
+    }
+    if (strcmp(tool_name, "nostr_encrypt") == 0) {
+        return execute_nostr_encrypt(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_decrypt") == 0) {
+        return execute_nostr_decrypt(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_dm_send_nip17") == 0) {
+        return execute_nostr_dm_send_nip17(args_json);
+    }
+    if (strcmp(tool_name, "nostr_list_manage") == 0) {
+        return execute_nostr_list_manage(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_query") == 0) {
+        return execute_nostr_query(args_json);
+    }
+    if (strcmp(tool_name, "agent_version") == 0) {
+        return execute_agent_version(args_json);
+    }
+    if (strcmp(tool_name, "nostr_pubkey") == 0) {
+        return execute_nostr_pubkey(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_npub") == 0) {
+        return execute_nostr_npub(ctx, args_json);
+    }
+    if (strcmp(tool_name, "my_pubkey") == 0) {
+        return execute_nostr_pubkey(ctx, args_json);
+    }
+    if (strcmp(tool_name, "my_npub") == 0) {
+        return execute_nostr_npub(ctx, args_json);
+    }
+    if (strcmp(tool_name, "local_http_fetch") == 0) {
+        return execute_local_http_fetch(ctx, args_json);
+    }
+    if (strcmp(tool_name, "local_shell_exec") == 0) {
+        return execute_local_shell_exec(ctx, args_json);
+    }
+    if (strcmp(tool_name, "local_file_read") == 0) {
+        return execute_local_file_read(ctx, args_json);
+    }
+    if (strcmp(tool_name, "local_file_write") == 0) {
+        return execute_local_file_write(ctx, args_json);
+    }
+    if (strcmp(tool_name, "skill_create") == 0) {
+        return execute_skill_create(ctx, args_json);
+    }
+    if (strcmp(tool_name, "skill_list") == 0) {
+        return execute_skill_list(ctx, args_json);
+    }
+    if (strcmp(tool_name, "skill_adopt") == 0) {
+        return execute_skill_adopt(ctx, args_json);
+    }
+    if (strcmp(tool_name, "skill_remove") == 0) {
+        return execute_skill_remove(ctx, args_json);
+    }
+    if (strcmp(tool_name, "skill_search") == 0) {
+        return execute_skill_search(args_json);
+    }
+    if (strcmp(tool_name, "skill_edit") == 0) {
+        return execute_skill_edit(ctx, args_json);
+    }
+    if (strcmp(tool_name, "trigger_list") == 0) {
+        return execute_trigger_list(ctx, args_json);
+    }
+    if (strcmp(tool_name, "tool_list") == 0) {
+        return execute_tool_list(ctx, args_json);
+    }
+    if (strcmp(tool_name, "model_get") == 0) {
+        return execute_model_get(args_json);
+    }
+    if (strcmp(tool_name, "model_set") == 0) {
+        return execute_model_set(ctx, args_json);
+    }
+    if (strcmp(tool_name, "model_list") == 0) {
+        return execute_model_list(args_json);
+    }
+
+    if (strcmp(tool_name, "nostr_post_readme") == 0) {
+        return execute_nostr_post_readme(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_file_md_to_longform_post") == 0) {
+        return execute_nostr_file_md_to_longform_post(ctx, args_json);
+    }
+    if (strcmp(tool_name, "task_manage") == 0) {
+        return execute_task_manage(ctx, args_json);
+    }
+    if (strcmp(tool_name, "admin_identity") == 0) {
+        return execute_admin_identity(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_admin_profile") == 0) {
+        return execute_nostr_admin_profile(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_admin_contacts") == 0) {
+        return execute_nostr_admin_contacts(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_admin_relays") == 0) {
+        return execute_nostr_admin_relays(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_admin_notes") == 0) {
+        return execute_nostr_admin_notes(ctx, args_json);
+    }
+    if (strcmp(tool_name, "task_list") == 0) {
+        return execute_task_list(ctx, args_json);
+    }
+    if (strcmp(tool_name, "message_current") == 0) {
+        return execute_message_current(ctx, args_json);
+    }
+    if (strcmp(tool_name, "agent_identity") == 0) {
+        return execute_agent_identity(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_agent_profile") == 0) {
+        return execute_nostr_agent_profile(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_agent_contacts") == 0) {
+        return execute_nostr_agent_contacts(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_agent_relays") == 0) {
+        return execute_nostr_agent_relays(ctx, args_json);
+    }
+    if (strcmp(tool_name, "nostr_agent_notes") == 0) {
+        return execute_nostr_agent_notes(ctx, args_json);
+    }
+    if (strcmp(tool_name, "my_kind0_profile") == 0) {
+        return execute_nostr_agent_profile(ctx, args_json);
+    }
+    if (strcmp(tool_name, "my_contacts") == 0) {
+        return execute_nostr_agent_contacts(ctx, args_json);
+    }
+    if (strcmp(tool_name, "my_relays") == 0) {
+        return execute_nostr_agent_relays(ctx, args_json);
+    }
+    if (strcmp(tool_name, "my_notes") == 0) {
+        return execute_nostr_agent_notes(ctx, args_json);
+    }
+
+    return json_error("unknown tool");
+}
+
+int tools_init(tools_context_t* ctx, didactyl_config_t* cfg) {
+    return tools_init_legacy(ctx, cfg);
+}
+
+void tools_cleanup(tools_context_t* ctx) {
+    tools_cleanup_legacy(ctx);
+}
+
+char* tools_execute(tools_context_t* ctx, const char* tool_name, const char* args_json) {
+    return tools_execute_legacy(ctx, tool_name, args_json);
+}

src/tools/tools_internal.h

@@ -0,0 +1,60 @@
+#ifndef DIDACTYL_TOOLS_INTERNAL_H
+#define DIDACTYL_TOOLS_INTERNAL_H
+
+#include "tools.h"
+
+int tools_init_legacy(tools_context_t* ctx, didactyl_config_t* cfg);
+void tools_cleanup_legacy(tools_context_t* ctx);
+char* tools_build_openai_schema_json_legacy(const tools_context_t* ctx);
+char* tools_execute_legacy(tools_context_t* ctx, const char* tool_name, const char* args_json);
+
+char* execute_tool_list(tools_context_t* ctx, const char* args_json);
+char* execute_trigger_list(tools_context_t* ctx, const char* args_json);
+char* execute_message_current(tools_context_t* ctx, const char* args_json);
+char* execute_agent_identity(tools_context_t* ctx, const char* args_json);
+char* execute_agent_version(const char* args_json);
+char* execute_nostr_agent_profile(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_agent_contacts(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_agent_relays(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_agent_notes(tools_context_t* ctx, const char* args_json);
+char* execute_model_get(const char* args_json);
+char* execute_model_set(tools_context_t* ctx, const char* args_json);
+char* execute_model_list(const char* args_json);
+char* execute_nostr_query(const char* args_json);
+char* execute_nostr_pubkey(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_npub(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_encode(const char* args_json);
+char* execute_nostr_decode(const char* args_json);
+char* execute_nostr_react(const char* args_json);
+char* execute_nostr_profile_get(const char* args_json);
+char* execute_nostr_nip05_lookup(const char* args_json);
+char* execute_nostr_relay_status(const char* args_json);
+char* execute_nostr_relay_info(const char* args_json);
+char* execute_nostr_dm_send(const char* args_json);
+char* execute_nostr_encrypt(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_decrypt(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_dm_send_nip17(const char* args_json);
+char* execute_nostr_delete(const char* args_json);
+char* execute_nostr_list_manage(tools_context_t* ctx, const char* args_json);
+char* execute_admin_identity(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_admin_profile(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_admin_contacts(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_admin_relays(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_admin_notes(tools_context_t* ctx, const char* args_json);
+char* execute_task_list(tools_context_t* ctx, const char* args_json);
+char* execute_task_manage(tools_context_t* ctx, const char* args_json);
+char* execute_local_http_fetch(tools_context_t* ctx, const char* args_json);
+char* execute_local_shell_exec(tools_context_t* ctx, const char* args_json);
+char* execute_local_file_read(tools_context_t* ctx, const char* args_json);
+char* execute_local_file_write(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_post(const char* args_json);
+char* execute_nostr_post_readme(tools_context_t* ctx, const char* args_json);
+char* execute_nostr_file_md_to_longform_post(tools_context_t* ctx, const char* args_json);
+char* execute_skill_create(tools_context_t* ctx, const char* args_json);
+char* execute_skill_list(tools_context_t* ctx, const char* args_json);
+char* execute_skill_adopt(tools_context_t* ctx, const char* args_json);
+char* execute_skill_remove(tools_context_t* ctx, const char* args_json);
+char* execute_skill_edit(tools_context_t* ctx, const char* args_json);
+char* execute_skill_search(const char* args_json);
+
+#endif

src/trigger_manager.h

@@ -0,0 +1,87 @@
+#ifndef DIDACTYL_TRIGGER_MANAGER_H
+#define DIDACTYL_TRIGGER_MANAGER_H
+
+#include <pthread.h>
+#include <time.h>
+
+#include "config.h"
+#include "cjson/cJSON.h"
+#include "../nostr_core_lib/nostr_core/nostr_core.h"
+
+#define TRIGGER_DEFAULT_MAX_ACTIVE 16
+#define TRIGGER_SKILL_D_TAG_MAX 65
+#define TRIGGER_SKILL_CONTENT_MAX 4096
+#define TRIGGER_FILTER_JSON_MAX 2048
+
+typedef enum {
+    TRIGGER_ACTION_LLM = 0,
+    TRIGGER_ACTION_TEMPLATE = 1
+} trigger_action_type_t;
+
+typedef enum {
+    TRIGGER_TYPE_NOSTR_SUBSCRIPTION = 0,
+    TRIGGER_TYPE_WEBHOOK = 1,
+    TRIGGER_TYPE_CRON = 2,
+    TRIGGER_TYPE_CHAIN = 3
+} trigger_type_t;
+
+typedef struct {
+    char skill_d_tag[TRIGGER_SKILL_D_TAG_MAX];
+    char skill_content[TRIGGER_SKILL_CONTENT_MAX];
+    char filter_json[TRIGGER_FILTER_JSON_MAX];
+    trigger_action_type_t action_type;
+    int enabled;
+    trigger_type_t trigger_type;
+    time_t last_fired;
+    time_t last_seen_created_at;
+    time_t last_cron_fire;
+    char cron_expr[64];
+    nostr_pool_subscription_t* subscription;
+    void* subscription_ctx;
+} active_trigger_t;
+
+typedef struct trigger_manager {
+    active_trigger_t* triggers;
+    int count;
+    int capacity;
+    didactyl_config_t* cfg;
+    pthread_mutex_t mutex;
+    time_t last_poll_at;
+} trigger_manager_t;
+
+int trigger_manager_init(trigger_manager_t* mgr, didactyl_config_t* cfg);
+int trigger_manager_load_from_skills(trigger_manager_t* mgr);
+int trigger_manager_load_from_startup_events(trigger_manager_t* mgr);
+trigger_type_t trigger_type_from_string(const char* s);
+const char* trigger_type_to_string(trigger_type_t t);
+
+int trigger_manager_add(trigger_manager_t* mgr,
+                        const char* skill_d_tag,
+                        const char* content,
+                        const char* filter_json,
+                        trigger_action_type_t action_type,
+                        const char* trigger_type_str,
+                        int enabled);
+int trigger_manager_remove(trigger_manager_t* mgr, const char* skill_d_tag);
+int trigger_manager_find(trigger_manager_t* mgr, const char* skill_d_tag, active_trigger_t* out);
+int trigger_manager_update(trigger_manager_t* mgr,
+                           const char* skill_d_tag,
+                           const char* content,
+                           const char* filter_json,
+                           trigger_action_type_t action_type,
+                           const char* trigger_type_str,
+                           int enabled);
+int trigger_manager_fire(trigger_manager_t* mgr,
+                         const char* skill_d_tag,
+                         cJSON* event,
+                         const char* source_label);
+int trigger_manager_fire_chains(trigger_manager_t* mgr,
+                                const char* source_skill_d_tag,
+                                cJSON* source_event,
+                                const char* source_label);
+int trigger_manager_active_count(trigger_manager_t* mgr);
+int trigger_manager_poll(trigger_manager_t* mgr);
+char* trigger_manager_status_json(trigger_manager_t* mgr);
+void trigger_manager_cleanup(trigger_manager_t* mgr);
+
+#endif

tasks.json

@@ -0,0 +1 @@
+{"tasks":[{"id":9,"text":"Publish README.md as longform post","created_at":1773326251,"status":"done","updated_at":1773326287},{"id":10,"text":"Publish docs/CONTEXT.md as longform post","created_at":1773326251,"status":"done","updated_at":1773326310},{"id":11,"text":"Publish docs/TOOLS.md as longform post","created_at":1773326251,"status":"done","updated_at":1773326320},{"id":12,"text":"Publish docs/SUBSCRIPTIONS.md as longform post","created_at":1773326251,"status":"done","updated_at":1773327937},{"id":13,"text":"DM admin after each publish","created_at":1773326251,"status":"done","updated_at":1773327937},{"id":14,"text":"Return final summary","created_at":1773326251,"status":"done","updated_at":1773327937}],"next_id":15}

tests/test.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+
+PASS_COUNT=0
+FAIL_COUNT=0
+
+pass() {
+  PASS_COUNT=$((PASS_COUNT + 1))
+  printf "[PASS] %s\n" "$1"
+}
+
+fail() {
+  FAIL_COUNT=$((FAIL_COUNT + 1))
+  printf "[FAIL] %s\n" "$1"
+}
+
+assert_grep() {
+  local pattern="$1"
+  local file="$2"
+  local desc="$3"
+  if grep -E -q "$pattern" "$file"; then
+    pass "$desc"
+  else
+    fail "$desc (pattern not found in $file)"
+  fi
+}
+
+assert_cmd() {
+  local desc="$1"
+  shift
+  if "$@" >/dev/null 2>&1; then
+    pass "$desc"
+  else
+    fail "$desc"
+  fi
+}
+
+printf "== Didactyl Trigger Feature Test ==\n"
+printf "Root: %s\n" "$ROOT_DIR"
+
+printf "\n-- Build check --\n"
+if make -j >/tmp/didactyl-test-build.log 2>&1; then
+  pass "Project builds successfully"
+else
+  fail "Project build failed (see /tmp/didactyl-test-build.log)"
+fi
+
+assert_cmd "Built binary exists" test -x ./didactyl
+
+printf "\n-- Source wiring checks --\n"
+assert_grep "TRIGGER_TYPE_WEBHOOK" src/trigger_manager.h "Webhook trigger type defined"
+assert_grep "TRIGGER_TYPE_CRON" src/trigger_manager.h "Cron trigger type defined"
+assert_grep "TRIGGER_TYPE_CHAIN" src/trigger_manager.h "Chain trigger type defined"
+
+assert_grep "trigger_manager_fire\(" src/trigger_manager.c "Generic trigger fire API implemented"
+assert_grep "trigger_manager_fire_chains\(" src/trigger_manager.c "Chain fire API implemented"
+assert_grep "cron_matches_now\(" src/trigger_manager.c "Cron matcher implemented"
+assert_grep "trigger_type_to_string" src/trigger_manager.c "Trigger type serialization implemented"
+
+assert_grep "\"/api/trigger/\*\"" src/http_api.c "Webhook API route registered"
+assert_grep "handle_trigger_webhook\(" src/http_api.c "Webhook handler implemented"
+
+assert_grep "nostr-subscription, webhook, cron, chain" src/tools.c "skill_create validation accepts 4 trigger types"
+assert_grep "skill_edit trigger must be one of: nostr-subscription, webhook, cron, chain" src/tools.c "skill_edit validation accepts 4 trigger types"
+
+assert_grep "trigger_manager_fire_chains\(" src/agent.c "Post-execution chain hook wired in agent"
+
+printf "\n-- Docs checks --\n"
+assert_grep "\`webhook\`" docs/SKILLS.md "SKILLS docs include webhook trigger"
+assert_grep "\`cron\`" docs/SKILLS.md "SKILLS docs include cron trigger"
+assert_grep "\`chain\`" docs/SKILLS.md "SKILLS docs include chain trigger"
+assert_grep "POST /api/trigger/:d_tag" docs/API.md "API docs include webhook endpoint"
+
+printf "\n-- Optional local API probe --\n"
+if command -v curl >/dev/null 2>&1; then
+  HTTP_CODE=""
+  HTTP_CODE="$(curl -k -s --connect-timeout 2 --max-time 5 -o /tmp/didactyl-trigger-probe.out -w "%{http_code}" https://127.0.0.1:8484/api/trigger/nonexistent -X POST -H 'Content-Type: application/json' -d '{}' || true)"
+  if [[ "$HTTP_CODE" == "000" ]]; then
+    HTTP_CODE="$(curl -s --connect-timeout 2 --max-time 5 -o /tmp/didactyl-trigger-probe.out -w "%{http_code}" http://127.0.0.1:8484/api/trigger/nonexistent -X POST -H 'Content-Type: application/json' -d '{}' || true)"
+  fi
+
+  if [[ "$HTTP_CODE" == "200" || "$HTTP_CODE" == "400" || "$HTTP_CODE" == "404" || "$HTTP_CODE" == "503" ]]; then
+    pass "Webhook endpoint responds on local API (http code: $HTTP_CODE)"
+  elif [[ "$HTTP_CODE" == "000" || -z "$HTTP_CODE" ]]; then
+    pass "Webhook endpoint probe skipped (no local API listener detected)"
+  else
+    fail "Webhook endpoint probe did not get expected response (http code: ${HTTP_CODE:-none})"
+  fi
+else
+  fail "curl not available for API probe"
+fi
+
+printf "\n== Result ==\n"
+printf "Pass: %d\n" "$PASS_COUNT"
+printf "Fail: %d\n" "$FAIL_COUNT"
+
+if [[ "$FAIL_COUNT" -gt 0 ]]; then
+  exit 1
+fi
+
+exit 0

view_api_call_logs.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+set -euo pipefail
+
+LOG_FILE="${1:-}"
+
+if [ -z "$LOG_FILE" ]; then
+  for candidate in "./didactyl.log" "./debug.log" "./context.log.md"; do
+    if [ -f "$candidate" ]; then
+      LOG_FILE="$candidate"
+      break
+    fi
+  done
+fi
+
+if [ -z "$LOG_FILE" ] || [ ! -f "$LOG_FILE" ]; then
+  echo "Log file not found." >&2
+  echo "Tried defaults: ./didactyl.log ./debug.log ./context.log.md" >&2
+  echo "Usage: $0 [path/to/logfile]" >&2
+  exit 1
+fi
+
+echo "Following API call logs from: $LOG_FILE"
+echo "(Press Ctrl+C to stop)"
+
+# Show request/response failure lines related to outbound LLM HTTP calls.
+# These are emitted by Didactyl in src/llm.c via fprintf(stderr, ...).
+tail -n 0 -F "$LOG_FILE" \
+  | stdbuf -oL grep -E --line-buffered "\\[didactyl\\] llm request:|\\[didactyl\\] llm http request failed:|\\[didactyl\\] llm error response:|\\[didactyl\\] llm partial response:|\\[didactyl\\] llm hint:"