v0.0.81 - Add loop progress controls and admin limit diagnostics for DM, HTTP API, and triggers

.gitignore

@@ -10,7 +10,7 @@ test_keys.txt
 
 /mongoose/
 /Trash/
-
+deploy_lt.sh
 
 # Build artifacts
 /build/

README.md

@@ -55,11 +55,11 @@ Skills compose by adoption-list order (`10123`) and trigger tags carry runtime e
 
 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.75
+## Current Status — v0.0.81
 
 **Active build — this project is barely working. Experiment at your own risk.**
 
-> Last release update: v0.0.75 — Add rsync deploy script and wizard root-shell handoff for service install path
+> Last release update: v0.0.81 — Add loop progress controls and admin limit diagnostics for DM, HTTP API, and triggers
 
 - Connects to configured relays with auto-reconnect and relay state transition logging
 - Publishes configured startup events per relay as each relay becomes connected

config.jsonc.example

@@ -40,10 +40,11 @@
   // 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
+    "max_turns": 20,                            // default max turns for normal agent tool loops
+    "trigger_max_turns": 12,                    // max turns for triggered-skill executions
+    "api_default_max_turns": 8,                 // default when HTTP body omits max_turns
+    "api_max_turns_ceiling": 32,                // hard cap applied to API-provided max_turns
+    "stall_repeat_threshold": 3,                // stop early when identical tool-call turns repeat this many times
     "local_http_fetch_default_timeout_seconds": 20,
     "local_http_fetch_max_timeout_seconds": 120,
     "shell": {

deploy_lt.sh

@@ -17,6 +17,14 @@ if [ ! -f "$SOURCE_BINARY" ]; then
     exit 1
 fi
 
+echo "Building static binary first..."
+"$SCRIPT_DIR/build_static.sh"
+
+if [ ! -f "$SOURCE_BINARY" ]; then
+    echo "ERROR: Build completed but source binary not found: $SOURCE_BINARY"
+    exit 1
+fi
+
 echo "Deploying $SOURCE_BINARY to $REMOTE_TARGET"
 rsync -avz --progress "$SOURCE_BINARY" "$REMOTE_TARGET"
 echo "Deployment complete."

plans/default_skill_missing_from_cache.md

@@ -0,0 +1,91 @@
+# Fix: Default Skill Missing from skill_list Cache
+
+## Problem
+
+When a new didactyl agent is created via the setup wizard, the default skill (`didactyl-default`, kind 31124) does not appear in the `skill_list` output. The agent IS using the default skill as its system context, but the skill cache (`g_self_skill_events`) does not contain it.
+
+## Evidence
+
+- Default skill event IS published to relays (confirmed by `nostr_my_events`)
+- Default skill event shows `in_current_cache: false`
+- `skill_list` returns `count: 1` with only `infrastructure-monitor`
+- The kind 10123 adoption list only contains `infrastructure-monitor`
+
+## Root Cause Analysis
+
+The startup sequence in `main.c` is:
+
+```
+1. nostr_handler_init()              — resets g_self_skill_events to []
+2. wait_for_connected_relays()       — waits for relay connections
+3. reconcile_startup_events()        — publishes default skill to relays
+   -> publish_kind_event_to_relays() — inserts into cache IF sent > 0
+4. ... relay list expansion ...
+5. subscribe_self_skills()           — subscribes to relays for kinds 31123/31124/10123
+```
+
+The default skill SHOULD be inserted into the cache at step 3 via `publish_kind_event_to_relays` -> `self_skill_cache_upsert_event_locked`. However, the cache insert at line 2750 is gated by `if (sent > 0)`.
+
+There are two failure modes:
+
+### Failure Mode 1: Async publish timing
+The startup publish creates a NEW event per relay via `publish_pending_startup_events_for_relay_index`. Each call to `publish_kind_event_to_relays` creates a fresh event with `nostr_create_and_sign_event`. If the relay is not connected at that moment, `sent = 0` and the cache insert is skipped.
+
+### Failure Mode 2: Subscription race condition
+Even if the cache insert succeeds at step 3, the self-skill subscription at step 5 queries relays. For a brand new agent, the default skill was JUST published asynchronously. If the relay hasn't indexed it by the time the subscription query runs, the subscription returns EOSE without the default skill. The subscription stays open but the default skill was published BEFORE the subscription started, so it won't arrive as a live event.
+
+The cache entry from step 3 should persist, but there may be an edge case where the relay pool reconnection handler at line 792 triggers another publish cycle, creating a new event that replaces the cache entry, and if that publish fails (sent=0), the replacement doesn't happen but the old entry is still there.
+
+### Most Likely Cause
+The most likely cause is that `publish_kind_event_to_relays` returns `sent = 0` for the default skill during the initial reconcile. This can happen if:
+- The relay connection drops momentarily between `wait_for_connected_relays` and the actual publish
+- The relay pool's async publish fails silently
+
+## Proposed Fix
+
+### Approach: Seed the cache directly from config during reconcile
+
+In `nostr_handler_reconcile_startup_events()`, after publishing startup events, explicitly seed the self-skill cache with a synthetic event built from `g_cfg->default_skill`. This ensures the default skill is ALWAYS in the cache regardless of relay publish success.
+
+### Implementation
+
+In `nostr_handler.c`, add a new static function `seed_default_skill_into_cache()` that:
+
+1. Checks if `g_cfg->default_skill.content` is non-empty
+2. Builds a cJSON event object with:
+   - `kind`: `g_cfg->default_skill.kind` (31124)
+   - `pubkey`: `g_cfg->keys.public_key_hex`
+   - `content`: `g_cfg->default_skill.content`
+   - `tags`: parsed from `g_cfg->default_skill.tags_json`
+   - `created_at`: `time(NULL)` (or 0 as a floor value)
+   - `id`: a placeholder hex string (e.g., all zeros) — will be replaced when the real event arrives from relay
+3. Calls `self_skill_cache_upsert_event_locked()` with this synthetic event
+
+Call this function at the END of `nostr_handler_reconcile_startup_events()`, AFTER the publish loop. This way:
+- If the publish succeeded, the cache already has the real event (with real ID/sig). The synthetic event would have `created_at` <= the real one, so the upsert would be a no-op.
+- If the publish failed, the cache gets the synthetic event as a fallback.
+- When the subscription later returns the real event from relays, it replaces the synthetic one (since it has a real ID and potentially newer timestamp).
+
+### Alternative Approach: Remove the `sent > 0` gate
+
+Change `publish_kind_event_to_relays` to always insert skill events (kinds 31123/31124) into the cache, regardless of whether the relay publish succeeded. This is simpler but changes the semantics — the cache would contain events that may not be on any relay.
+
+### Recommended: Approach 1 (seed from config)
+
+This is safer because:
+- It doesn't change the publish function's behavior
+- It explicitly handles the default skill case
+- The synthetic event gets replaced by the real one when it arrives from relays
+- It works even if the publish completely fails
+
+### Files to Modify
+
+1. `src/nostr_handler.c`:
+   - Add `seed_default_skill_into_cache()` static function
+   - Call it at the end of `nostr_handler_reconcile_startup_events()`
+
+### Edge Cases
+
+- If the default skill is later updated via `skill_update`, the relay version will have a newer `created_at` and will replace the synthetic entry
+- If the agent has no default skill configured, the seed function is a no-op
+- The synthetic event has a placeholder ID, so `in_current_cache` checks by event ID won't match it — but `skill_list` iterates all events and doesn't check by ID

plans/enhanced_existing_agent_wizard.md

@@ -0,0 +1,149 @@
+# Enhanced Existing Agent Wizard Flow
+
+## Problem
+
+When choosing "existing agent" in the wizard, the current flow:
+1. Asks for nsec
+2. Recovers kind 10002 relay list from Nostr
+3. Immediately boots the agent
+
+This is insufficient when installing an existing agent on a **new server** because:
+- You cannot review or change the admin pubkey
+- You cannot review or change the LLM provider/model/API key
+- You cannot install a systemd service with a dedicated user
+- You cannot see what config was recovered from Nostr
+- The agent name is not recovered from the kind 0 profile
+
+## Current Code
+
+- [`existing_agent_flow()`](src/setup_wizard.c:1795) — 22 lines, minimal recovery
+- [`recover_existing_config_from_nostr()`](src/setup_wizard.c:792) — only recovers kind 10002 relays
+- Returns `SETUP_WIZARD_RC_EXISTING` (2) which does NOT set `bootstrap_mode`
+- In `main.c`, existing agents skip `reconcile_startup_events()` unless `first_run` is detected
+
+## Data Available on Nostr for an Existing Agent
+
+| Data | Kind | Storage | Recovery Method |
+|------|------|---------|-----------------|
+| Relay list | 10002 | Public tags | `query_and_extract_kind10002_relays()` |
+| Agent profile/name | 0 | Public JSON content | Query kind 0 by agent pubkey |
+| LLM config | 30078 d=llm_config | NIP-44 encrypted to self | `fetch_self_config_plaintext()` |
+| Agent config - admin pubkey, DM protocol | 30078 d=agent_config | NIP-44 encrypted to self | `fetch_self_config_plaintext()` |
+| Default skill | 31124 d=didactyl-default | Public content | Query kind 31124 by agent pubkey |
+| Adoption list | 10123 | Public tags | Query kind 10123 by agent pubkey |
+
+## Proposed Enhanced Flow
+
+```mermaid
+flowchart TD
+    A[Enter nsec] --> B[Connect to default relays]
+    B --> C[Recover kind 10002 relay list]
+    C --> D{Relay list found?}
+    D -->|No| E{Offer to create new agent with this nsec}
+    E -->|Yes| E2[Jump to new_agent_flow with nsec pre-loaded]
+    E -->|No| E3[Return to main menu]
+    D -->|Yes| F[Reconnect with recovered relays]
+    F --> G[Recover all config from Nostr]
+    G --> H[Display recovered config summary]
+    H --> I{Review each setting}
+    I -->|Keep all| J[Review summary + launch options]
+    I -->|Change admin| K[Prompt new admin pubkey]
+    I -->|Change LLM| L[Prompt LLM config]
+    I -->|Change relays| M[Prompt relay config]
+    K --> I
+    L --> I
+    M --> I
+    J --> N{Launch option}
+    N -->|Boot now| O[Return EXISTING]
+    N -->|Install systemd| P[Install dedicated-user service]
+    N -->|Quit| Q[Exit]
+```
+
+### Step-by-step
+
+#### Step 1: Identity — Enter nsec
+Same as current. Derive keys from nsec.
+
+#### Step 2: Recovery — Connect and fetch config from Nostr
+1. Init nostr handler with default relays
+2. Wait for relay connections
+3. Query kind 10002 for relay list — if not found, offer to create a new agent with this nsec (jump to `new_agent_flow` with keys pre-loaded, skipping identity step)
+4. Cleanup and re-init with recovered relays
+5. Wait for relay connections on recovered relays
+6. Query kind 0 for agent profile — extract display_name/name
+7. Query kind 30078 d=llm_config — decrypt and parse LLM settings
+8. Query kind 30078 d=agent_config — decrypt and parse admin pubkey + DM protocol
+9. Cleanup nostr handler
+
+#### Step 3: Review — Present recovered config
+Display all recovered values:
+```
+  ┌─────────────────────────────────────────────┐
+  │  Existing Agent -- Recovered Configuration  │
+  ├─────────────────────────────────────────────┤
+  │  Agent name:    Simon                       │
+  │  Identity:      b27072b7fc2edf45...         │
+  │  Admin:         a1b2c3d4e5f6...             │
+  │  LLM Provider:  ppq                         │
+  │  LLM Model:     claude-haiku-4.5            │
+  │  LLM Base URL:  https://api.ppq.ai          │
+  │  LLM API Key:   sk-...****                  │
+  │  DM Protocol:   nip04                       │
+  │  Relays:        5 configured                │
+  └─────────────────────────────────────────────┘
+```
+
+Then offer a menu:
+```
+  [a] change Admin pubkey
+  [l] change LLM provider/model/key
+  [r] change Relay configuration
+  [c] continue with these settings
+  [q] quit
+```
+
+Each change option reuses the existing prompt functions (`prompt_admin_pubkey`, `prompt_llm_config`, `prompt_relay_configuration`) but with context-appropriate headers.
+
+After any change, redisplay the summary and menu.
+
+#### Step 4: Launch — Boot or install systemd
+Same as the new-agent flow's final step:
+```
+  [b] boot the agent now
+  [i] install dedicated-user systemd service and boot
+  [q] quit
+```
+
+The systemd install reuses `install_system_service_with_dedicated_user()`.
+
+### Return Codes
+
+- If user chooses "boot now": return `SETUP_WIZARD_RC_EXISTING` (2) — same as current
+- If user chooses "install systemd": return `SETUP_WIZARD_RC_EXIT` (1) — agent runs as systemd service
+- If user changed config values: the `main()` flow should still work because `recover_missing_runtime_config_from_nostr()` at line 1108 will fill in any gaps, and the existing agent path at line 1163 loads system context from adopted skills
+
+### Key Consideration: bootstrap_mode for changed configs
+
+If the user changes LLM or admin config in the wizard, those changes need to be persisted back to Nostr. Currently, `persist_runtime_config_to_nostr()` is only called when `bootstrap_mode || first_run`. 
+
+**Solution**: When the existing-agent wizard detects that config was changed, return `SETUP_WIZARD_RC_BOOTSTRAP` (0) instead of `SETUP_WIZARD_RC_EXISTING` (2). This triggers the full reconcile path which persists the updated config.
+
+## Files to Modify
+
+1. **`src/setup_wizard.c`**:
+   - Add `recover_full_config_from_nostr()` — fetches kind 0, kind 30078 llm_config, kind 30078 agent_config
+   - Add `query_self_kind0_name()` — queries agent's own kind 0 profile for name
+   - Add `fetch_and_decrypt_self_config()` — replicates `fetch_self_config_plaintext()` logic from main.c for use in wizard context
+   - Rewrite `existing_agent_flow()` with the enhanced multi-step flow
+   - Make `prompt_admin_pubkey()`, `prompt_llm_config()`, `prompt_relay_configuration()` accept a context string parameter for the page header, or add wrapper versions for the existing-agent context
+
+2. **`src/main.c`**:
+   - Potentially expose `fetch_self_config_plaintext()`, `apply_recalled_llm_config()`, `apply_recalled_agent_config()` as non-static, OR duplicate the logic in setup_wizard.c
+   - Better approach: move these to a shared location or make them accessible via a header
+
+## Implementation Notes
+
+- The wizard already calls `nostr_handler_init()` / `nostr_handler_cleanup()` for validation queries. The enhanced flow will do the same but with two init/cleanup cycles: first with default relays to get kind 10002, then with recovered relays to get everything else.
+- The `prompt_admin_pubkey()` and `prompt_llm_config()` functions currently have hardcoded step headers like "Step 3 of 7". These should be parameterized or have existing-agent variants.
+- The `fetch_self_config_plaintext()` function in main.c requires an active nostr handler. The wizard will need to have the handler initialized when calling it.
+- API key display should be masked — show only first 4 and last 4 characters.

plans/fix_kind30078_agent_config_publish.md

@@ -0,0 +1,69 @@
+# Fix: Kind 30078 `d=agent_config` Publish Gaps
+
+## Problem
+
+The agent stores its admin pubkey and DM protocol in a NIP-44 self-encrypted kind 30078 replaceable event (`d=agent_config`). This event is critical for the `--nsec`-only startup path (used by systemd services) to recover the admin identity.
+
+**Multiple startup paths fail to publish this event**, causing:
+- Agents installed via wizard "Install Service" to lose their admin pubkey on restart
+- Agents recovering on new servers to use stale/old admin pubkeys from relays
+- Agents with genesis files to silently ignore newer kind 30078 values
+
+## Affected Files
+
+- `src/setup_wizard.c` — wizard flows
+- `src/main.c` — main startup logic
+
+## Fixes
+
+### Fix A: `new_agent_flow` — publish before service install
+**File:** `src/setup_wizard.c` ~line 2184  
+**Problem:** When user chooses "Install systemd service" in new agent flow, `persist_runtime_config_to_nostr_wizard_online` is never called. The service starts with `--nsec` only and has no kind 30078 to recover from.  
+**Fix:** Call `persist_runtime_config_to_nostr_wizard_online(cfg)` before `install_system_service_with_dedicated_user()`. Fail the install if publish fails (same pattern as existing_agent_flow).
+
+### Fix B: `new_agent_flow` — publish before "boot now" return
+**File:** `src/setup_wizard.c` ~line 2177  
+**Problem:** When user chooses "Boot now", the wizard returns `SETUP_WIZARD_RC_BOOTSTRAP` and relies on `main()` to publish later. This works but is fragile — if the bootstrap publish in `main()` fails, the kind 30078 is never created.  
+**Fix:** Call `persist_runtime_config_to_nostr_wizard_online(cfg)` before returning 0. This is belt-and-suspenders — `main()` will also publish, but the wizard ensures it happens at least once. If the wizard publish fails, log a warning but continue (non-fatal since main will retry).
+
+### Fix C: `existing_agent_flow` — always publish before service install
+**File:** `src/setup_wizard.c` ~line 2368  
+**Problem:** `persist_runtime_config_to_nostr_wizard_online` is only called `if (config_changed)`. If the user accepts the recovered config as-is, the kind 30078 is not re-published. The event may have been lost from relays.  
+**Fix:** Remove the `config_changed` gate. Always call `persist_runtime_config_to_nostr_wizard_online(cfg)` before installing the service. Kind 30078 is a replaceable event, so re-publishing is safe and idempotent.
+
+### Fix D: `existing_agent_flow` — always return BOOTSTRAP
+**File:** `src/setup_wizard.c` ~line 2364  
+**Problem:** When user chooses "Boot now" and `config_changed == 0`, the flow returns `SETUP_WIZARD_RC_EXISTING` which means `bootstrap_mode = 0` in `main()`. If `first_run = 0` (kind 10002 exists), `persist_runtime_config_to_nostr` is skipped.  
+**Fix:** Always return `SETUP_WIZARD_RC_BOOTSTRAP` from the "boot now" path, regardless of `config_changed`. This ensures `main()` always re-publishes the kind 30078. The wizard has all the config in memory — it should always be treated as authoritative.
+
+### Fix E: `persist_runtime_config_to_nostr_wizard_online` — ensure relay delivery
+**File:** `src/setup_wizard.c` ~line 1159  
+**Problem:** The function publishes the event and immediately calls `nostr_handler_cleanup()`. The event may not have been delivered to relays yet (fire-and-forget).  
+**Fix:** Add a brief poll loop (e.g., 2-3 seconds of `nostr_handler_poll()`) after the publish call and before `nostr_handler_cleanup()` to give the event time to propagate. This matches the pattern used elsewhere for relay operations.
+
+### Fix F: `main()` — always fetch kind 30078 and compare
+**File:** `src/main.c` ~line 847 (`recover_missing_runtime_config_from_nostr`)  
+**Problem:** The recovery only runs when `admin_config_is_complete()` returns false. If a genesis file provides an admin pubkey, the kind 30078 is never checked, even if it has a different (newer) value.  
+**Fix:** Always fetch the kind 30078 `d=agent_config` regardless of whether the genesis already provided values. Compare the fetched admin_pubkey with the loaded one. If they differ, log a `DEBUG_WARN` with both values. Genesis wins (operator intent), but the warning makes the conflict visible in logs.
+
+### Fix G: `main()` — always re-publish kind 30078
+**File:** `src/main.c` ~line 1152  
+**Problem:** `persist_runtime_config_to_nostr` only runs when `bootstrap_mode || first_run`. On subsequent runs, the kind 30078 is never refreshed. If relays purge the event, it's gone.  
+**Fix:** Move `persist_runtime_config_to_nostr(&cfg)` outside the `if (bootstrap_mode || first_run)` block so it runs on every startup. Kind 30078 is a replaceable event — re-publishing is safe, idempotent, and ensures relay persistence. Log the result but don't fail startup if it doesn't succeed.
+
+## Execution Order
+
+1. Fix E first (relay delivery) — this makes all other wizard publishes more reliable
+2. Fixes A + B (new_agent_flow) — the most critical bug
+3. Fixes C + D (existing_agent_flow) — second most critical
+4. Fix G (always re-publish in main) — ensures long-term relay persistence
+5. Fix F (conflict detection) — nice-to-have logging improvement
+
+## Testing
+
+- Wizard → New Agent → Install Service: verify kind 30078 exists on relays after service starts
+- Wizard → New Agent → Boot: verify kind 30078 exists on relays
+- Wizard → Existing Agent → Install Service (no changes): verify kind 30078 re-published
+- Wizard → Existing Agent → Boot (no changes): verify kind 30078 re-published
+- `--nsec` only restart: verify kind 30078 recovered and re-published
+- `--config genesis.jsonc` with different admin than kind 30078: verify warning logged, genesis wins, kind 30078 updated

src/agent.c

@@ -79,6 +79,63 @@ static uint64_t message_fingerprint(const char* sender_pubkey_hex, const char* m
     return a ^ (b + 0x9e3779b97f4a7c15ULL + (a << 6) + (a >> 2));
 }
 
+static uint64_t tool_calls_fingerprint(const llm_response_t* resp) {
+    if (!resp || resp->tool_call_count <= 0 || !resp->tool_calls) {
+        return 1469598103934665603ULL;
+    }
+
+    uint64_t h = 1469598103934665603ULL;
+    for (int i = 0; i < resp->tool_call_count; i++) {
+        const llm_tool_call_t* tc = &resp->tool_calls[i];
+        uint64_t name_h = fnv1a64(tc->name ? tc->name : "");
+        uint64_t args_h = fnv1a64(tc->arguments_json ? tc->arguments_json : "{}");
+        uint64_t part = name_h ^ (args_h + 0x9e3779b97f4a7c15ULL + (name_h << 6) + (name_h >> 2));
+        h ^= part + (uint64_t)(i + 1) * 1099511628211ULL;
+        h *= 1099511628211ULL;
+    }
+
+    h ^= (uint64_t)resp->tool_call_count;
+    h *= 1099511628211ULL;
+    return h;
+}
+
+static void notify_admin_limit_diagnostic(const char* source,
+                                          const char* reason,
+                                          const char* subject,
+                                          int max_turns,
+                                          int turns_run,
+                                          int stall_repeat_threshold,
+                                          int repeated_tool_turns,
+                                          const char* final_answer) {
+    if (!g_cfg || g_cfg->admin.pubkey[0] == '\0') {
+        return;
+    }
+
+    char diag[1400];
+    snprintf(diag,
+             sizeof(diag),
+             "⚠️ Didactyl limit diagnostic\n"
+             "source=%s\n"
+             "reason=%s\n"
+             "subject=%s\n"
+             "max_turns=%d\n"
+             "turns_run=%d\n"
+             "stall_repeat_threshold=%d\n"
+             "repeated_tool_turns=%d\n"
+             "final_answer_preview=%.*s",
+             source ? source : "unknown",
+             reason ? reason : "unknown",
+             subject ? subject : "n/a",
+             max_turns,
+             turns_run,
+             stall_repeat_threshold,
+             repeated_tool_turns,
+             360,
+             final_answer ? final_answer : "");
+
+    (void)nostr_handler_send_dm_auto(g_cfg->admin.pubkey, diag);
+}
+
 static int agent_message_is_debounced(const char* sender_pubkey_hex, const char* message) {
     time_t now = time(NULL);
     uint64_t fp = message_fingerprint(sender_pubkey_hex, message);
@@ -1815,7 +1872,10 @@ void agent_on_trigger(const char* skill_d_tag,
                         ? g_cfg->tools.trigger_max_turns
                         : (g_cfg->tools.max_turns > 0 ? g_cfg->tools.max_turns : 8);
 
+    int turns_run = 0;
+    int trigger_completed = 0;
     for (int turn = 0; turn < max_turns; turn++) {
+        turns_run = turn + 1;
         char* messages_json = cJSON_PrintUnformatted(messages);
         if (!messages_json) {
             break;
@@ -1836,6 +1896,7 @@ void agent_on_trigger(const char* skill_d_tag,
         }
 
         if (resp.tool_call_count <= 0) {
+            trigger_completed = 1;
             llm_response_free(&resp);
             break;
         }
@@ -1871,6 +1932,17 @@ void agent_on_trigger(const char* skill_d_tag,
         llm_response_free(&resp);
     }
 
+    if (!trigger_completed && turns_run >= max_turns) {
+        notify_admin_limit_diagnostic("trigger_skill_loop",
+                                      "max_turns_exhausted",
+                                      skill_d_tag,
+                                      max_turns,
+                                      turns_run,
+                                      g_cfg->tools.stall_repeat_threshold > 1 ? g_cfg->tools.stall_repeat_threshold : 3,
+                                      0,
+                                      "");
+    }
+
     if (g_trigger_manager) {
         (void)trigger_manager_fire_chains(g_trigger_manager,
                                           skill_d_tag,
@@ -2097,10 +2169,16 @@ void agent_on_message(const char* sender_pubkey_hex,
         cJSON_AddNumberToObject(live_user_msg, "_ts", (double)time(NULL));
     }
 
-    int max_turns = g_cfg->tools.max_turns > 0 ? g_cfg->tools.max_turns : 8;
+    int max_turns = g_cfg->tools.max_turns > 0 ? g_cfg->tools.max_turns : 20;
+    int stall_repeat_threshold = g_cfg->tools.stall_repeat_threshold > 1 ? g_cfg->tools.stall_repeat_threshold : 3;
+    uint64_t last_tool_fp = 0;
+    int repeated_tool_turns = 0;
+    int exited_on_stall = 0;
     char* final_answer_owned = NULL;
+    int turns_run = 0;
 
     for (int turn = 0; turn < max_turns; turn++) {
+        turns_run = turn + 1;
         char* messages_json = cJSON_PrintUnformatted(messages);
         if (!messages_json) {
             break;
@@ -2128,6 +2206,20 @@ void agent_on_message(const char* sender_pubkey_hex,
             break;
         }
 
+        uint64_t current_tool_fp = tool_calls_fingerprint(&resp);
+        if (turn == 0 || current_tool_fp != last_tool_fp) {
+            repeated_tool_turns = 1;
+            last_tool_fp = current_tool_fp;
+        } else {
+            repeated_tool_turns++;
+        }
+
+        if (repeated_tool_turns >= stall_repeat_threshold) {
+            exited_on_stall = 1;
+            llm_response_free(&resp);
+            break;
+        }
+
         if (append_assistant_tool_calls_message(messages, &resp) != 0) {
             llm_response_free(&resp);
             break;
@@ -2162,10 +2254,41 @@ void agent_on_message(const char* sender_pubkey_hex,
     }
 
     if (!final_answer_owned) {
-        final_answer_owned = strdup("I hit my tool-use limit for this request.");
+        char* messages_json = cJSON_PrintUnformatted(messages);
+        if (messages_json) {
+            llm_response_t final_resp;
+            int final_rc = llm_chat_with_tools_messages(messages_json, tools_json, "none", &final_resp);
+            free(messages_json);
+            if (final_rc == 0) {
+                const char* forced_answer = final_resp.content ? final_resp.content : "";
+                if (forced_answer[0] != '\0') {
+                    final_answer_owned = strdup(forced_answer);
+                }
+                llm_response_free(&final_resp);
+            }
+        }
+    }
+
+    int exhausted_on_max_turns = (!final_answer_owned && !exited_on_stall && turns_run >= max_turns);
+
+    if (!final_answer_owned) {
+        final_answer_owned = strdup(exited_on_stall
+                                        ? "I stopped repeated tool calls after detecting a loop and could not produce a final summary."
+                                        : "I hit my tool-use limit for this request.");
     }
 
     const char* final_answer = final_answer_owned ? final_answer_owned : "I hit my tool-use limit for this request.";
+
+    if (exited_on_stall || exhausted_on_max_turns) {
+        notify_admin_limit_diagnostic("dm_agent_loop",
+                                      exited_on_stall ? "stall_repetition_detected" : "max_turns_exhausted",
+                                      sender_pubkey_hex,
+                                      max_turns,
+                                      turns_run,
+                                      stall_repeat_threshold,
+                                      repeated_tool_turns,
+                                      final_answer);
+    }
     fprintf(stdout, "[didactyl] final response: %.240s%s\n",
             final_answer,
             strlen(final_answer) > 240 ? "..." : "");

src/agent.h

@@ -4,7 +4,7 @@
 #include "config.h"
 #include "nostr_handler.h"
 #include "cjson/cJSON.h"
-#include "tools.h"
+#include "tools/tools.h"
 
 struct trigger_manager;
 

src/config.c

@@ -225,6 +225,7 @@ static int parse_tools_config(cJSON* root, didactyl_config_t* config) {
     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* stall_repeat_threshold = cJSON_GetObjectItemCaseSensitive(tools, "stall_repeat_threshold");
     cJSON* local_http_fetch_default_timeout_seconds =
         cJSON_GetObjectItemCaseSensitive(tools, "local_http_fetch_default_timeout_seconds");
     cJSON* local_http_fetch_max_timeout_seconds =
@@ -244,6 +245,9 @@ static int parse_tools_config(cJSON* root, didactyl_config_t* config) {
     if (api_max_turns_ceiling && cJSON_IsNumber(api_max_turns_ceiling)) {
         config->tools.api_max_turns_ceiling = (int)api_max_turns_ceiling->valuedouble;
     }
+    if (stall_repeat_threshold && cJSON_IsNumber(stall_repeat_threshold)) {
+        config->tools.stall_repeat_threshold = (int)stall_repeat_threshold->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;
@@ -294,6 +298,9 @@ static int parse_tools_config(cJSON* root, didactyl_config_t* config) {
     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.stall_repeat_threshold < 2) {
+        config->tools.stall_repeat_threshold = 3;
+    }
     if (config->tools.local_http_fetch_default_timeout_seconds < 1) {
         config->tools.local_http_fetch_default_timeout_seconds = 20;
     }
@@ -1124,10 +1131,11 @@ int config_load(const char* path, didactyl_config_t* config) {
     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.max_turns = 20;
+    config->tools.trigger_max_turns = 12;
+    config->tools.api_default_max_turns = 8;
+    config->tools.api_max_turns_ceiling = 32;
+    config->tools.stall_repeat_threshold = 3;
     config->tools.local_http_fetch_default_timeout_seconds = 20;
     config->tools.local_http_fetch_max_timeout_seconds = 120;
     config->tools.shell.enabled = 1;

src/config.h

@@ -50,6 +50,7 @@ typedef struct {
     int trigger_max_turns;
     int api_default_max_turns;
     int api_max_turns_ceiling;
+    int stall_repeat_threshold;
     int local_http_fetch_default_timeout_seconds;
     int local_http_fetch_max_timeout_seconds;
     shell_tools_config_t shell;

src/http_api.c

@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdint.h>
 #include <time.h>
 
 #include "agent.h"
@@ -81,6 +82,73 @@ static int estimate_tokens_from_chars(int chars) {
     return (chars + 3) / 4;
 }
 
+static uint64_t fnv1a64_local(const char* s) {
+    uint64_t h = 1469598103934665603ULL;
+    if (!s) return h;
+    while (*s) {
+        h ^= (unsigned char)(*s++);
+        h *= 1099511628211ULL;
+    }
+    return h;
+}
+
+static uint64_t tool_calls_fingerprint_local(const llm_response_t* resp) {
+    if (!resp || resp->tool_call_count <= 0 || !resp->tool_calls) {
+        return 1469598103934665603ULL;
+    }
+
+    uint64_t h = 1469598103934665603ULL;
+    for (int i = 0; i < resp->tool_call_count; i++) {
+        const llm_tool_call_t* tc = &resp->tool_calls[i];
+        uint64_t name_h = fnv1a64_local(tc->name ? tc->name : "");
+        uint64_t args_h = fnv1a64_local(tc->arguments_json ? tc->arguments_json : "{}");
+        uint64_t part = name_h ^ (args_h + 0x9e3779b97f4a7c15ULL + (name_h << 6) + (name_h >> 2));
+        h ^= part + (uint64_t)(i + 1) * 1099511628211ULL;
+        h *= 1099511628211ULL;
+    }
+
+    h ^= (uint64_t)resp->tool_call_count;
+    h *= 1099511628211ULL;
+    return h;
+}
+
+static void notify_admin_limit_diagnostic_http(const char* source,
+                                               const char* reason,
+                                               const char* subject,
+                                               int max_turns,
+                                               int turns_run,
+                                               int stall_repeat_threshold,
+                                               int repeated_tool_turns,
+                                               const char* final_answer) {
+    if (!g_api_ctx.cfg || g_api_ctx.cfg->admin.pubkey[0] == '\0') {
+        return;
+    }
+
+    char diag[1400];
+    snprintf(diag,
+             sizeof(diag),
+             "⚠️ Didactyl limit diagnostic\n"
+             "source=%s\n"
+             "reason=%s\n"
+             "subject=%s\n"
+             "max_turns=%d\n"
+             "turns_run=%d\n"
+             "stall_repeat_threshold=%d\n"
+             "repeated_tool_turns=%d\n"
+             "final_answer_preview=%.*s",
+             source ? source : "unknown",
+             reason ? reason : "unknown",
+             subject ? subject : "n/a",
+             max_turns,
+             turns_run,
+             stall_repeat_threshold,
+             repeated_tool_turns,
+             360,
+             final_answer ? final_answer : "");
+
+    (void)nostr_handler_send_dm_auto(g_api_ctx.cfg->admin.pubkey, diag);
+}
+
 static int uri_extract_after_prefix(const struct mg_str* uri,
                                     const char* prefix,
                                     char* out,
@@ -844,9 +912,19 @@ static cJSON* run_prompt_with_tools_convo(cJSON* convo,
         return NULL;
     }
 
+    int stall_repeat_threshold = 3;
+    if (g_api_ctx.cfg && g_api_ctx.cfg->tools.stall_repeat_threshold > 1) {
+        stall_repeat_threshold = g_api_ctx.cfg->tools.stall_repeat_threshold;
+    }
+
     char* final_response = NULL;
+    uint64_t last_tool_fp = 0;
+    int repeated_tool_turns = 0;
+    int exited_on_stall = 0;
+    int turns_run = 0;
 
     for (int turn = 0; turn < max_turns; turn++) {
+        turns_run = turn + 1;
         char* messages_json = cJSON_PrintUnformatted(convo);
         if (!messages_json) break;
 
@@ -877,6 +955,20 @@ static cJSON* run_prompt_with_tools_convo(cJSON* convo,
             break;
         }
 
+        uint64_t current_tool_fp = tool_calls_fingerprint_local(&resp);
+        if (turn == 0 || current_tool_fp != last_tool_fp) {
+            repeated_tool_turns = 1;
+            last_tool_fp = current_tool_fp;
+        } else {
+            repeated_tool_turns++;
+        }
+
+        if (repeated_tool_turns >= stall_repeat_threshold) {
+            exited_on_stall = 1;
+            llm_response_free(&resp);
+            break;
+        }
+
         if (append_assistant_tool_calls_message_local(convo, &resp) != 0) {
             llm_response_free(&resp);
             final_response = strdup("Failed to append assistant tool calls.");
@@ -917,9 +1009,40 @@ static cJSON* run_prompt_with_tools_convo(cJSON* convo,
         llm_response_free(&resp);
     }
 
-done:
+done:;
+    int hit_max_turn_limit = (!final_response && !exited_on_stall && turns_run >= max_turns);
+
     if (!final_response) {
-        final_response = strdup(tool_limit_message ? tool_limit_message : "I hit my tool-use limit for this prompt run.");
+        char* messages_json = cJSON_PrintUnformatted(convo);
+        if (messages_json) {
+            llm_response_t final_resp;
+            int final_rc = llm_chat_with_tools_messages(messages_json, tools_json, "none", &final_resp);
+            free(messages_json);
+            if (final_rc == 0) {
+                const char* forced_answer = final_resp.content ? final_resp.content : "";
+                if (forced_answer[0] != '\0') {
+                    final_response = strdup(forced_answer);
+                }
+                llm_response_free(&final_resp);
+            }
+        }
+    }
+
+    if (!final_response) {
+        final_response = strdup(exited_on_stall
+                                    ? "Stopped repeated tool calls after detecting a loop, and no final summary was produced."
+                                    : (tool_limit_message ? tool_limit_message : "I hit my tool-use limit for this prompt run."));
+    }
+
+    if (exited_on_stall || hit_max_turn_limit) {
+        notify_admin_limit_diagnostic_http("http_api_tool_loop",
+                                           exited_on_stall ? "stall_repetition_detected" : "max_turns_exhausted",
+                                           log_sender,
+                                           max_turns,
+                                           turns_run,
+                                           stall_repeat_threshold,
+                                           repeated_tool_turns,
+                                           final_response ? final_response : "");
     }
 
     cJSON_AddBoolToObject(root, "success", 1);

src/http_api.h

@@ -2,7 +2,7 @@
 #define DIDACTYL_HTTP_API_H
 
 #include "config.h"
-#include "tools.h"
+#include "tools/tools.h"
 
 struct trigger_manager;
 

src/main.c

@@ -75,6 +75,8 @@ static void print_usage(const char* prog) {
             "      If file is missing, startup falls back to minimal nsec-only mode.\n"
             "  --nsec <nsec_or_hex>\n"
             "      Private key as nsec1... or 64-char hex; overrides DIDACTYL_NSEC.\n"
+            "  --admin <npub_or_hex>\n"
+            "      Administrator pubkey override; accepts npub1... or 64-char hex.\n"
             "  --api-port <port>\n"
             "      Enable HTTP API and bind to this port (1-65535).\n"
             "  --api-bind <addr>\n"
@@ -316,10 +318,11 @@ static int query_self_kind10002_relays(const didactyl_config_t* cfg,
         return 0;
     }
 
+    size_t events_json_len = strlen(events_json);
     cJSON* events = cJSON_Parse(events_json);
     free(events_json);
     if (!events || !cJSON_IsArray(events)) {
-        DEBUG_WARN("[didactyl] kind10002 query parse failed or non-array payload (len=%zu)", strlen(events_json));
+        DEBUG_WARN("[didactyl] kind10002 query parse failed or non-array payload (len=%zu)", events_json_len);
         cJSON_Delete(events);
         return 0;
     }
@@ -862,24 +865,32 @@ static void recover_missing_runtime_config_from_nostr(didactyl_config_t* cfg) {
         free(llm_plaintext);
     }
 
-    if (!admin_config_is_complete(cfg)) {
-        char* agent_plaintext = NULL;
-        if (fetch_self_config_plaintext(cfg, "agent_config", &agent_plaintext) == 0 && agent_plaintext) {
-            if (apply_recalled_agent_config(cfg, agent_plaintext) == 0) {
+    char* agent_plaintext = NULL;
+    if (fetch_self_config_plaintext(cfg, "agent_config", &agent_plaintext) == 0 && agent_plaintext) {
+        didactyl_config_t recalled = *cfg;
+        if (apply_recalled_agent_config(&recalled, agent_plaintext) == 0) {
+            if (!admin_config_is_complete(cfg)) {
+                snprintf(cfg->admin.pubkey, sizeof(cfg->admin.pubkey), "%s", recalled.admin.pubkey);
+                cfg->dm_protocol = recalled.dm_protocol;
                 DEBUG_INFO("[didactyl] startup phase: recovered agent_config from Nostr");
-            } else {
-                DEBUG_WARN("[didactyl] startup phase: failed to apply recalled agent_config");
+            } else if (recalled.admin.pubkey[0] != '\0' && strcmp(cfg->admin.pubkey, recalled.admin.pubkey) != 0) {
+                DEBUG_WARN("[didactyl] startup phase: agent_config admin pubkey differs from loaded config (loaded=%.16s..., nostr=%.16s...); loaded config wins",
+                           cfg->admin.pubkey,
+                           recalled.admin.pubkey);
             }
         } else {
-            DEBUG_WARN("[didactyl] startup phase: agent_config recall unavailable");
+            DEBUG_WARN("[didactyl] startup phase: failed to parse/decrypt recalled agent_config");
         }
-        free(agent_plaintext);
+    } else {
+        DEBUG_WARN("[didactyl] startup phase: agent_config recall unavailable");
     }
+    free(agent_plaintext);
 }
 
 int main(int argc, char** argv) {
     const char* config_path = "./genesis.jsonc";
     const char* cli_nsec = NULL;
+    const char* cli_admin_pubkey = NULL;
     const char* api_bind_override = NULL;
     int api_port_override = 0;
     int debug_level = DEBUG_LEVEL_NONE;
@@ -943,6 +954,8 @@ int main(int argc, char** argv) {
                 debug_level = atoi(argv[++i]);
             } else if (strcmp(argv[i], "--nsec") == 0 && i + 1 < argc) {
                 cli_nsec = argv[++i];
+            } else if (strcmp(argv[i], "--admin") == 0 && i + 1 < argc) {
+                cli_admin_pubkey = argv[++i];
             } else if (strcmp(argv[i], "--api-port") == 0 && i + 1 < argc) {
                 api_port_override = atoi(argv[++i]);
             } else if (strcmp(argv[i], "--api-bind") == 0 && i + 1 < argc) {
@@ -996,6 +1009,18 @@ int main(int argc, char** argv) {
         }
     }
 
+    if (cli_admin_pubkey && cli_admin_pubkey[0] != '\0') {
+        char decoded_admin[65] = {0};
+        if (decode_pubkey_hex_or_npub_local(cli_admin_pubkey, decoded_admin) != 0) {
+            fprintf(stderr, "Invalid admin pubkey provided via --admin (expected npub1... or 64-char hex)\n");
+            config_free(&cfg);
+            nostr_cleanup();
+            return 1;
+        }
+        snprintf(cfg.admin.pubkey, sizeof(cfg.admin.pubkey), "%s", decoded_admin);
+        DEBUG_INFO("[didactyl] startup phase: admin override applied from --admin (%.16s...)", cfg.admin.pubkey);
+    }
+
     if (config_ensure_default_skill_startup_events(&cfg) != 0) {
         fprintf(stderr, "Failed to synthesize startup events from default_skill\n");
         config_free(&cfg);
@@ -1123,7 +1148,7 @@ int main(int argc, char** argv) {
     if (!admin_config_is_complete(&cfg)) {
         startup_step_fail(4, "Validate admin config", "missing admin pubkey");
         fprintf(stderr,
-                "Missing admin config: provide admin.pubkey in genesis or store d=agent_config via config_store\n");
+                "Missing admin config: provide admin.pubkey in genesis, pass --admin, or store d=agent_config via config_store\n");
         nostr_handler_cleanup();
         config_free(&cfg);
         nostr_cleanup();
@@ -1152,17 +1177,19 @@ int main(int argc, char** argv) {
         if (nostr_handler_reconcile_startup_events() != 0) {
             DEBUG_WARN("[didactyl] startup phase: reconcile startup events failed (continuing)");
         }
-        if (persist_runtime_config_to_nostr(&cfg) != 0) {
-            DEBUG_WARN("[didactyl] startup phase: failed to persist encrypted runtime config to Nostr");
-        } else {
-            DEBUG_INFO("[didactyl] startup phase: persisted encrypted runtime config to Nostr");
-        }
     } else {
-        DEBUG_INFO("[didactyl] startup phase: existing-agent mode; skipping bootstrap publish on subsequent run");
+        DEBUG_INFO("[didactyl] startup phase: existing-agent mode; skipping startup-event reconcile on subsequent run");
         if (nostr_handler_load_system_context_from_adopted_skills() != 0) {
             DEBUG_WARN("[didactyl] startup phase: failed to load system context from adopted skills (continuing with fallback)");
         }
     }
+
+    if (persist_runtime_config_to_nostr(&cfg) != 0) {
+        DEBUG_WARN("[didactyl] startup phase: failed to persist encrypted runtime config to Nostr");
+    } else {
+        DEBUG_INFO("[didactyl] startup phase: persisted encrypted runtime config to Nostr");
+    }
+
     startup_step_ok(7, "Reconcile/persist startup state", NULL);
 
     const char* system_context = nostr_handler_get_system_context();

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 75
-#define DIDACTYL_VERSION "v0.0.75"
+#define DIDACTYL_VERSION_PATCH 81
+#define DIDACTYL_VERSION "v0.0.81"
 
 // Agent metadata
 #define DIDACTYL_NAME "Didactyl"

src/nostr_handler.c

@@ -416,6 +416,7 @@ static int managed_subscription_register_locked(managed_subscription_id_t id,
 static int managed_subscriptions_resubscribe_all_locked(void);
 static int managed_subscription_id_from_name(const char* name, managed_subscription_id_t* out_id);
 static int apply_runtime_kind10002_relays(cJSON* tags, const char* source_label);
+static void seed_default_skill_into_cache(void);
 
 static int relay_list_contains_local(char** relays, int relay_count, const char* relay_url) {
     if (!relays || relay_count <= 0 || !relay_url || relay_url[0] == '\0') {
@@ -1249,6 +1250,50 @@ static void self_skill_cache_upsert_event_locked(cJSON* event) {
     cJSON_AddItemToArray(g_self_skill_events, dup);
 }
 
+static void seed_default_skill_into_cache(void) {
+    if (!g_cfg) {
+        return;
+    }
+
+    if (g_cfg->default_skill.kind != 31123 && g_cfg->default_skill.kind != 31124) {
+        return;
+    }
+
+    if (g_cfg->keys.public_key_hex[0] == '\0' ||
+        !g_cfg->default_skill.content || g_cfg->default_skill.content[0] == '\0' ||
+        !g_cfg->default_skill.tags_json || g_cfg->default_skill.tags_json[0] == '\0') {
+        return;
+    }
+
+    cJSON* tags = cJSON_Parse(g_cfg->default_skill.tags_json);
+    if (!tags || !cJSON_IsArray(tags)) {
+        cJSON_Delete(tags);
+        return;
+    }
+
+    cJSON* event = cJSON_CreateObject();
+    if (!event) {
+        cJSON_Delete(tags);
+        return;
+    }
+
+    const double now = (double)time(NULL);
+    cJSON_AddNumberToObject(event, "kind", g_cfg->default_skill.kind);
+    cJSON_AddStringToObject(event, "pubkey", g_cfg->keys.public_key_hex);
+    cJSON_AddStringToObject(event, "content", g_cfg->default_skill.content);
+    cJSON_AddItemToObject(event, "tags", tags);
+    cJSON_AddNumberToObject(event, "created_at", now);
+    cJSON_AddStringToObject(event,
+                            "id",
+                            "0000000000000000000000000000000000000000000000000000000000000000");
+
+    pthread_mutex_lock(&g_self_skill_mutex);
+    self_skill_cache_upsert_event_locked(event);
+    pthread_mutex_unlock(&g_self_skill_mutex);
+
+    cJSON_Delete(event);
+}
+
 static int hex_to_pubkey(const char* hex, unsigned char out_pubkey[32]) {
     if (!hex || !out_pubkey || strlen(hex) != 64U) {
         return -1;
@@ -2969,6 +3014,8 @@ int nostr_handler_reconcile_startup_events(void) {
         publish_pending_startup_events_for_relay_index(relay_index, "startup_reconcile");
     }
 
+    seed_default_skill_into_cache();
+
     return 0;
 }
 

src/prompt_template.h

@@ -2,7 +2,7 @@
 #define DIDACTYL_PROMPT_TEMPLATE_H
 
 #include "cjson/cJSON.h"
-#include "tools.h"
+#include "tools/tools.h"
 
 #define PROMPT_TEMPLATE_MAX_SECTIONS 32
 #define PROMPT_TEMPLATE_MAX_NAME_LEN 64

src/tools/tools.h

@@ -1,7 +1,7 @@
 #ifndef DIDACTYL_TOOLS_H
 #define DIDACTYL_TOOLS_H
 
-#include "config.h"
+#include "../config.h"
 
 struct trigger_manager;