Fixes.

CODE_DOCS.md

@@ -1,57 +1,33 @@
 # Agent Module API Documentation
 
-This document provides an overview of the public functions available in the Agent module, which facilitates creating, configuring, and running AI agents.
+This document provides an overview of the public functions available in the Agent module, including `src/agent.c` and `include/agent.h`. These functions facilitate the creation, configuration, and management of agent instances.
 
-## Functions
+## Function Signatures
 
-### `agent_create`
+### Creation and Destruction
-- **Description:** Creates a new agent instance with a specified goal and optional message history.
+- `agent_handle agent_create(const char *goal, messages_handle messages);`
-- **Signature:** `agent_handle agent_create(const char *goal, messages_handle messages)`
+- `void agent_destroy(agent_handle agent);`
 
-### `agent_destroy`
+### Configuration
-- **Description:** Destroys an agent instance, freeing associated resources.
+- `void agent_set_max_iterations(agent_handle agent, int max);`
-- **Signature:** `void agent_destroy(agent_handle agent)`
+- `void agent_set_verbose(agent_handle agent, bool verbose);`
+- `void agent_set_is_subagent(agent_handle agent, bool is_subagent);`
+- `void agent_set_tool_registry(agent_handle agent, tool_registry_t *registry);`
+- `void agent_set_id(agent_handle agent, const char *id);`
+- `void agent_set_role(agent_handle agent, const char *role);`
+- `void agent_set_manager_id(agent_handle agent, const char *manager_id);`
 
-### `agent_set_max_iterations`
+### Retrieval
-- **Description:** Sets the maximum number of iterations the agent will perform.
+- `agent_state_t agent_get_state(agent_handle agent);`
-- **Signature:** `void agent_set_max_iterations(agent_handle agent, int max)`
+- `int agent_get_iteration_count(agent_handle agent);`
 
-### `agent_set_verbose`
+### Miscellaneous
-- **Description:** Enables or disables verbose output for debugging.
+- `void agent_set_max_iterations(agent_handle agent, int max);`
-- **Signature:** `void agent_set_verbose(agent_handle agent, bool verbose)`
+- `void agent_set_verbose(agent_handle agent, bool verbose);`
+- `void agent_set_is_subagent(agent_handle agent, bool is_subagent);`
+- `void agent_set_tool_registry(agent_handle agent, tool_registry_t *registry);`
+- `void agent_set_id(agent_handle agent, const char *id);`
+- `void agent_set_role(agent_handle agent, const char *role);`
+- `void agent_set_manager_id(agent_handle agent, const char *manager_id);`
 
-### `agent_set_is_subagent`
+This documentation is intended to assist developers in understanding and utilizing the Agent API effectively.
-- **Description:** Marks the agent as a sub-agent, affecting its logging and behavior.
-- **Signature:** `void agent_set_is_subagent(agent_handle agent, bool is_subagent)`
-
-### `agent_set_tool_registry`
-- **Description:** Sets the tool registry for the agent, allowing it to use external tools.
-- **Signature:** `void agent_set_tool_registry(agent_handle agent, tool_registry_t *registry)`
-
-### `agent_get_state`
-- **Description:** Retrieves the current state of the agent.
-- **Signature:** `agent_state_t agent_get_state(agent_handle agent)`
-
-### `agent_get_error`
-- **Description:** Gets the last error message from the agent.
-- **Signature:** `const char *agent_get_error(agent_handle agent)`
-
-### `agent_get_iteration_count`
-- **Description:** Returns the number of iterations the agent has performed.
-- **Signature:** `int agent_get_iteration_count(agent_handle agent)`
-
-### `agent_run`
-- **Description:** Runs the agent with a user message, returning the generated response.
-- **Signature:** `char *agent_run(agent_handle agent, const char *user_message)`
-
-### `agent_chat`
-- **Description:** Convenience function to create an agent, run it, and destroy it.
-- **Signature:** `char *agent_chat(const char *user_message, messages_handle messages)`
-
-### `agent_chat_with_limit`
-- **Description:** Runs the agent with a maximum iteration limit.
-- **Signature:** `char *agent_chat_with_limit(const char *user_message, int max_iterations, messages_handle messages)`
-
----
-
-This API provides the core functions needed to manage AI agents within your application, including creation, configuration, execution, and cleanup.

Makefile

@@ -32,6 +32,8 @@ SRC_TOOLS = $(TOOLSDIR)/tools_init.c \
             $(TOOLSDIR)/tool_code.c \
             $(TOOLSDIR)/tool_file_edit.c \
             $(TOOLSDIR)/tool_system.c \
+            $(TOOLSDIR)/tool_enterprise.c \
+            $(TOOLSDIR)/tool_research.c \
             $(TOOLSDIR)/tool_network.c \
             $(TOOLSDIR)/tool_dns.c \
             $(TOOLSDIR)/tool_automation.c \

cloud_comparison.md

@@ -1,4 +1,11 @@
-Provider,Key AI Services,Special Features,Hardware/Infrastructure
+# Cloud AI Offerings Comparison 2026
-"AWS","SageMaker, AI-powered industry services, custom chips (Trainium, Inferentia)","Automated ML, multimodal AI, large models","Custom chips for training/inference"
+
-"Azure","Azure OpenAI, AI for productivity, enterprise AI tools","Advanced LLMs, model management, hardware optimization","AI hardware, integrated cloud infrastructure"
+| Feature/Service | AWS | Azure | Google Cloud |
-"Google Cloud","Vertex AI, data analytics AI, multimodal models","Automation, ethical AI, responsible AI frameworks","TPUs, accelerated AI workloads"
+|-------------------|-------|--------|--------------|
+| AI Platform       | SageMaker, Bedrock, Vertex AI | Azure OpenAI, Azure Machine Learning | Vertex AI, Gemini models |
+| Model Options     | Extensive, including custom models | Wide range, with enterprise controls | Focus on ease of use, integrated tooling |
+| Special Features  | AI Factories, multi-cloud interconnects | Exclusive GPT-4 access, Copilot | Generative AI, large language models |
+| Certifications    | AWS Certified AI Practitioner | Azure AI Fundamentals | Google Cloud ML certifications |
+| Notable Projects  | Cloud AI projects in 2026 | AI/ML projects on Azure | Top AI/ML projects on AWS & Azure |
+
+This table summarizes the latest AI offerings from the major cloud providers in 2026, highlighting their key services, features, and notable projects.

db_migration.sql

@@ -1,27 +1,17 @@
-BEGIN TRANSACTION;
+-- SQLite schema for library system
 CREATE TABLE authors (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    id INTEGER PRIMARY KEY,
-    name TEXT NOT NULL,
+    name TEXT NOT NULL
-    birth_year INTEGER
 );
-INSERT INTO "authors" VALUES(1,'Jane Austen',1775);
+
-INSERT INTO "authors" VALUES(2,'Charles Dickens',1812);
-INSERT INTO "authors" VALUES(3,'Leo Tolstoy',1828);
-INSERT INTO "authors" VALUES(4,'Mark Twain',1835);
-INSERT INTO "authors" VALUES(5,'Virginia Woolf',1882);
 CREATE TABLE books (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    id INTEGER PRIMARY KEY,
     title TEXT NOT NULL,
     author_id INTEGER,
-    published_year INTEGER,
     FOREIGN KEY(author_id) REFERENCES authors(id)
 );
-INSERT INTO "books" VALUES(1,'Pride and Prejudice',1,1813);
+
-INSERT INTO "books" VALUES(2,'Great Expectations',2,1861);
+-- Sample records
-INSERT INTO "books" VALUES(3,'War and Peace',3,1869);
+INSERT INTO authors (id, name) VALUES (1, 'Jane Austen'), (2, 'Mark Twain'), (3, 'Charles Dickens'), (4, 'Virginia Woolf'), (5, 'George Orwell');
-INSERT INTO "books" VALUES(4,'Adventures of Huckleberry Finn',4,1884);
+
-INSERT INTO "books" VALUES(5,'Mrs. Dalloway',5,1925);
+INSERT INTO books (id, title, author_id) VALUES (1, 'Pride and Prejudice', 1), (2, 'Adventures of Huckleberry Finn', 2), (3, 'Great Expectations', 3), (4, 'Mrs Dalloway', 4), (5, '1984', 5);
-DELETE FROM "sqlite_sequence";
-INSERT INTO "sqlite_sequence" VALUES('authors',5);
-INSERT INTO "sqlite_sequence" VALUES('books',5);
-COMMIT;

dummy_log.txt

@@ -1,20 +1,20 @@
-ERROR message 0
+INFO: Message 0
-INFO message 1
+ERROR: Message 1
-INFO message 2
+INFO: Message 2
-ERROR message 3
+ERROR: Message 3
-INFO message 4
+INFO: Message 4
-INFO message 5
+ERROR: Message 5
-ERROR message 6
+INFO: Message 6
-INFO message 7
+ERROR: Message 7
-INFO message 8
+INFO: Message 8
-ERROR message 9
+ERROR: Message 9
-INFO message 10
+INFO: Message 10
-INFO message 11
+ERROR: Message 11
-ERROR message 12
+INFO: Message 12
-INFO message 13
+ERROR: Message 13
-INFO message 14
+INFO: Message 14
-ERROR message 15
+ERROR: Message 15
-INFO message 16
+INFO: Message 16
-INFO message 17
+ERROR: Message 17
-ERROR message 18
+INFO: Message 18
-INFO message 19
+ERROR: Message 19

git_summary.md

@@ -1,14 +1,7 @@
-### Last 5 Git Commit Messages
+# Last 5 Git Commit Messages
 
-1. a
+1. Commit all modified tracked files
-2. OK!
+2. a
-3. OK..
+3. OK!
 4. OK..
-5. Update
+5. OK..
-
-### Summary of Changes
-- Minor updates and fixes.
-- General improvements.
-- Content updates.
-
-(Note: The commit messages are brief; for detailed changes, review the full commit logs.)

include/agent.h

@@ -34,6 +34,13 @@ agent_state_t agent_get_state(agent_handle agent);
 const char *agent_get_error(agent_handle agent);
 int agent_get_iteration_count(agent_handle agent);
 
+void agent_set_id(agent_handle agent, const char *id);
+void agent_set_role(agent_handle agent, const char *role);
+void agent_set_manager_id(agent_handle agent, const char *manager_id);
+const char *agent_get_id(agent_handle agent);
+const char *agent_get_role(agent_handle agent);
+const char *agent_get_manager_id(agent_handle agent);
+
 char *agent_run(agent_handle agent, const char *user_message);
 char *agent_chat(const char *user_message, messages_handle messages);
 char *agent_chat_with_limit(const char *user_message, int max_iterations, messages_handle messages);

include/db.h

@@ -20,5 +20,7 @@ char *db_get_schema(db_handle db);
 r_status_t db_store_file_version(db_handle db, const char *path);
 r_status_t db_save_conversation(db_handle db, const char *session_key, const char *data);
 r_status_t db_load_conversation(db_handle db, const char *session_key, char **data);
+long long db_get_conversation_age(db_handle db, const char *session_key);
+r_status_t db_delete_conversation(db_handle db, const char *session_key);
 
 #endif

log_analysis.json

@@ -1 +1 @@
-{"error_count": 7, "total_lines": 20}
+{"total_lines": 20, "error_count": 10}

mixed_async.txt

@@ -1,2 +1,2 @@
-Python Output: Python OK
+Python OK
-Shell Output: Shell OK
+Shell OK

network_report.txt

@@ -1,11 +1,3 @@
-Network Connectivity Report
+Host,IP,Port,Status,Latency_ms
-
+"google.com","142.250.185.142","80","OPEN","N/A"
-Google.com:
+"github.com","140.82.121.4","80","OPEN","N/A"
-- Port 80: OPEN
-- DNS Lookup (Google DNS 8.8.8.8): 142.250.185.142
-- Latency: 0 ms (assumed immediate response)
-
-GitHub.com:
-- Port 80: OPEN
-- DNS Lookup (Google DNS 8.8.8.8): 140.82.121.3
-- Latency: 0 ms (assumed immediate response)

parallel_results.txt

@@ -1,2 +1,2 @@
-Script A Output: Script A Done
+Script A Done
-Script B Output: Script B Done
+Script B Done

security_scan.txt

@@ -1,4 +1,4 @@
-./security_report_2026.txt:6:Despite the inability to access the latest CVE database directly, recent trends indicate that vulnerabilities in software components, misconfigurations, and outdated systems continue to be prevalent. This report summarizes common vulnerabilities observed in 2026 and provides recommended remediation steps.
+# Security scan report for current directory
 ./security_report_2026.txt:25:- Description: Weak password policies, poor session management, or broken access controls.
 ./security_report_2026.txt:47:| **Authentication & Authorization** | - Enforce strong password policies.
 ./.git/hooks/pre-receive.sample:14:		eval "value=\$GIT_PUSH_OPTION_$i"

src/agent.c

@@ -1,18 +1,24 @@
 // retoor <retoor@molodetz.nl>
-
 #include "agent.h"
 #include "http_client.h"
+#include "db.h"
 #include "r_config.h"
 #include "tool.h"
 #include "context_manager.h"
 #include "markdown.h"
 #include <json-c/json.h>
+#include <sqlite3.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
-
 struct agent_t {
+    char *agent_id;
+    char *role;
+    char *manager_id;
+    char *department;
+    long budget_limit;
+    long used_tokens;
     char *goal;
     int iteration_count;
     int max_iterations;
@@ -28,7 +34,6 @@ struct agent_t {
     http_client_handle http;
     tool_registry_t *tools;
 };
-
 static const char *incomplete_phrases[] = {
     "I'll ",      "I will ",    "Let me ",     "I'm going to ",
     "Next, I",    "Now I'll",   "Now I will",  "I'll now",
@@ -40,12 +45,10 @@ static const char *incomplete_phrases[] = {
     "Do you want", "Shall I",
     NULL
 };
-
 static const char *incomplete_endings[] = {
     "...", ":", "files:", "content:", "implementation:", "?",
     NULL
 };
-
 static const char *completion_phrases[] = {
     "task is complete", "task complete", "tasks complete",
     "goal is achieved", "goal achieved",
@@ -56,31 +59,49 @@ static const char *completion_phrases[] = {
     "setup is complete", "is ready to use",
     NULL
 };
-
 static const char *passive_phrases[] = {
     "let me know", "feel free", "if you need", "awaiting",
     "ready for", "standby", "standing by", "happy to help",
     "do not hesitate", "anything else",
     NULL
 };
-
 extern tool_registry_t *tools_get_registry(void);
-
+static void agent_update_heartbeat(agent_handle agent) {
+    if (!agent || !agent->agent_id) return;
+    db_handle db = db_open(NULL);
+    char *sql = sqlite3_mprintf("UPDATE agents SET last_heartbeat = CURRENT_TIMESTAMP WHERE agent_id = %Q", agent->agent_id);
+    struct json_object *res = NULL;
+    db_execute(db, sql, &res);
+    sqlite3_free(sql);
+    if (res) json_object_put(res);
+    db_close(db);
+}
+static bool agent_check_budget(agent_handle agent) {
+    if (!agent || agent->budget_limit <= 0) return true;
+    return agent->used_tokens < agent->budget_limit;
+}
+static void agent_add_tokens(agent_handle agent, long tokens) {
+    if (!agent || !agent->agent_id) return;
+    agent->used_tokens += tokens;
+    db_handle db = db_open(NULL);
+    char *sql = sqlite3_mprintf("UPDATE agents SET used_tokens = used_tokens + %ld WHERE agent_id = %Q", tokens, agent->agent_id);
+    struct json_object *res = NULL;
+    db_execute(db, sql, &res);
+    sqlite3_free(sql);
+    if (res) json_object_put(res);
+    db_close(db);
+}
 static void agent_set_error(agent_handle agent, const char *error) {
     if (!agent) return;
     free(agent->last_error);
     agent->last_error = error ? strdup(error) : NULL;
 }
-
 static char *agent_build_request(agent_handle agent, const char *role, const char *message) {
     r_config_handle cfg = r_config_get_instance();
-
     struct json_object *root = json_object_new_object();
     if (!root) return NULL;
-
     json_object_object_add(root, "model",
         json_object_new_string(r_config_get_model(cfg)));
-
     if (role && message) {
         messages_add(agent->messages, role, message);
     }
@@ -89,14 +110,12 @@ static char *agent_build_request(agent_handle agent, const char *role, const cha
         json_object_object_add(root, "tools",
             tool_registry_get_descriptions(agent->tools));
     }
-
     json_object_object_add(root, "messages",
         json_object_get(messages_to_json(agent->messages)));
     json_object_object_add(root, "temperature",
         json_object_new_double(r_config_get_temperature(cfg)));
     json_object_object_add(root, "max_tokens",
         json_object_new_int(r_config_get_max_tokens(cfg)));
-
     char *result = strdup(json_object_to_json_string_ext(root, JSON_C_TO_STRING_PRETTY));
     if (agent->verbose && !agent->is_subagent) {
         fprintf(stderr, "\n[LLM Request]\n%s\n", result);
@@ -104,26 +123,26 @@ static char *agent_build_request(agent_handle agent, const char *role, const cha
     json_object_put(root);
     return result;
 }
-
 static struct json_object *agent_process_response(agent_handle agent, const char *json_data) {
     r_config_handle cfg = r_config_get_instance();
-
     char *response = NULL;
     r_status_t status = http_post(agent->http, r_config_get_api_url(cfg), json_data, &response);
-
+    agent_update_heartbeat(agent);
     if (status != R_SUCCESS || !response) {
         return NULL;
     }
-
-    if (agent->verbose && !agent->is_subagent) {
-        fprintf(stderr, "\n[LLM Response]\n%s\n", response);
-    }
-
     struct json_object *parsed = json_tokener_parse(response);
+    
+    // Track tokens
+    struct json_object *usage;
+    if (parsed && json_object_object_get_ex(parsed, "usage", &usage)) {
+        struct json_object *total_tokens;
+        if (json_object_object_get_ex(usage, "total_tokens", &total_tokens)) {
+            agent_add_tokens(agent, json_object_get_int64(total_tokens));
+        }
+    }
     free(response);
-
     if (!parsed) return NULL;
-
     struct json_object *error_obj;
     if (json_object_object_get_ex(parsed, "error", &error_obj)) {
         const char *err_str = json_object_to_json_string(error_obj);
@@ -143,42 +162,32 @@ static struct json_object *agent_process_response(agent_handle agent, const char
         json_object_put(parsed);
         return NULL;
     }
-
     struct json_object *choices;
     if (!json_object_object_get_ex(parsed, "choices", &choices)) {
         json_object_put(parsed);
         return NULL;
     }
-
     struct json_object *first_choice = json_object_array_get_idx(choices, 0);
     if (!first_choice) {
         json_object_put(parsed);
         return NULL;
     }
-
     return first_choice;
 }
-
 static bool agent_has_tool_calls(struct json_object *choice) {
     struct json_object *message_obj;
     if (!json_object_object_get_ex(choice, "message", &message_obj)) return false;
-
     struct json_object *tool_calls;
     if (!json_object_object_get_ex(message_obj, "tool_calls", &tool_calls)) return false;
-
     return json_object_array_length(tool_calls) > 0;
 }
-
 static struct json_object *agent_get_tool_calls(struct json_object *choice) {
     struct json_object *message_obj;
     if (!json_object_object_get_ex(choice, "message", &message_obj)) return NULL;
-
     struct json_object *tool_calls;
     if (!json_object_object_get_ex(message_obj, "tool_calls", &tool_calls)) return NULL;
-
     return tool_calls;
 }
-
 static struct json_object *agent_get_message(struct json_object *choice) {
     struct json_object *message_obj;
     if (json_object_object_get_ex(choice, "message", &message_obj)) {
@@ -186,35 +195,27 @@ static struct json_object *agent_get_message(struct json_object *choice) {
     }
     return NULL;
 }
-
 static char *agent_get_content(struct json_object *choice) {
     struct json_object *message_obj;
     if (!json_object_object_get_ex(choice, "message", &message_obj)) return NULL;
-
     struct json_object *content_obj;
     if (!json_object_object_get_ex(message_obj, "content", &content_obj)) return NULL;
-
     const char *content = json_object_get_string(content_obj);
     return content ? strdup(content) : NULL;
 }
-
 static bool agent_response_indicates_incomplete(const char *content) {
     if (!content) return false;
-
     // Check for explicit completion phrases first (Overrides incomplete indicators)
     for (int i = 0; completion_phrases[i]; i++) {
         if (strcasestr(content, completion_phrases[i])) return false;
     }
-
     // Check for passive/closing phrases (Overrides incomplete indicators)
     for (int i = 0; passive_phrases[i]; i++) {
         if (strcasestr(content, passive_phrases[i])) return false;
     }
-
     for (int i = 0; incomplete_phrases[i]; i++) {
         if (strcasestr(content, incomplete_phrases[i])) return true;
     }
-
     size_t len = strlen(content);
     if (len > 3) {
         for (int i = 0; incomplete_endings[i]; i++) {
@@ -224,14 +225,11 @@ static bool agent_response_indicates_incomplete(const char *content) {
             }
         }
     }
-
     return false;
 }
-
 agent_handle agent_create(const char *goal, messages_handle messages) {
     struct agent_t *agent = calloc(1, sizeof(struct agent_t));
     if (!agent) return NULL;
-
     if (goal) {
         agent->goal = strdup(goal);
         if (!agent->goal) {
@@ -239,9 +237,7 @@ agent_handle agent_create(const char *goal, messages_handle messages) {
             return NULL;
         }
     }
-
     r_config_handle cfg = r_config_get_instance();
-
     agent->iteration_count = 0;
     agent->max_iterations = AGENT_MAX_ITERATIONS;
     agent->tool_retry_count = 0;
@@ -249,7 +245,17 @@ agent_handle agent_create(const char *goal, messages_handle messages) {
     agent->state = AGENT_STATE_IDLE;
     agent->start_time = time(NULL);
     agent->verbose = r_config_is_verbose(cfg);
-
+    agent->agent_id = strdup("Executive-Apex");
+    agent->role = strdup("Executive");
+    agent->budget_limit = 1000000;
+    db_handle db = db_open(NULL);
+    char *sql = sqlite3_mprintf("INSERT OR IGNORE INTO agents (agent_id, role, budget_limit_tokens) VALUES (%Q, %Q, %ld)",
+                                agent->agent_id, agent->role, agent->budget_limit);
+    struct json_object *res = NULL;
+    db_execute(db, sql, &res);
+    sqlite3_free(sql);
+    if (res) json_object_put(res);
+    db_close(db);
     if (messages) {
         agent->messages = messages;
         agent->owns_messages = false;
@@ -257,13 +263,11 @@ agent_handle agent_create(const char *goal, messages_handle messages) {
         agent->messages = messages_create(r_config_get_session_id(cfg));
         agent->owns_messages = true;
     }
-
     if (!agent->messages) {
         free(agent->goal);
         free(agent);
         return NULL;
     }
-
     const char *system_msg = r_config_get_system_message(cfg);
     if (system_msg && *system_msg) {
         bool has_system = false;
@@ -282,7 +286,6 @@ agent_handle agent_create(const char *goal, messages_handle messages) {
             messages_add(agent->messages, "system", system_msg);
         }
     }
-
     agent->http = http_client_create(r_config_get_api_key(cfg));
     if (!agent->http) {
         if (agent->owns_messages) {
@@ -292,77 +295,93 @@ agent_handle agent_create(const char *goal, messages_handle messages) {
         free(agent);
         return NULL;
     }
-
     agent->tools = tools_get_registry();
-
     return agent;
 }
-
 void agent_destroy(agent_handle agent) {
     if (!agent) return;
     if (agent->http) http_client_destroy(agent->http);
     if (agent->messages && agent->owns_messages) messages_destroy(agent->messages);
+    free(agent->agent_id);
+    free(agent->role);
+    free(agent->manager_id);
+    free(agent->department);
     free(agent->goal);
     free(agent->last_error);
     free(agent);
 }
-
 void agent_set_max_iterations(agent_handle agent, int max) {
     if (agent) agent->max_iterations = max;
 }
-
 void agent_set_verbose(agent_handle agent, bool verbose) {
     if (agent) agent->verbose = verbose;
 }
-
 void agent_set_is_subagent(agent_handle agent, bool is_subagent) {
     if (agent) agent->is_subagent = is_subagent;
 }
-
 void agent_set_tool_registry(agent_handle agent, tool_registry_t *registry) {
     if (agent && registry) agent->tools = registry;
 }
-
 agent_state_t agent_get_state(agent_handle agent) {
     return agent ? agent->state : AGENT_STATE_ERROR;
 }
-
 const char *agent_get_error(agent_handle agent) {
     return agent ? agent->last_error : NULL;
 }
-
 int agent_get_iteration_count(agent_handle agent) {
     return agent ? agent->iteration_count : 0;
 }
-
+void agent_set_id(agent_handle agent, const char *id) {
+    if (!agent) return;
+    free(agent->agent_id);
+    agent->agent_id = id ? strdup(id) : NULL;
+}
+void agent_set_role(agent_handle agent, const char *role) {
+    if (!agent) return;
+    free(agent->role);
+    agent->role = role ? strdup(role) : NULL;
+}
+void agent_set_manager_id(agent_handle agent, const char *manager_id) {
+    if (!agent) return;
+    free(agent->manager_id);
+    agent->manager_id = manager_id ? strdup(manager_id) : NULL;
+}
+const char *agent_get_id(agent_handle agent) {
+    return agent ? agent->agent_id : NULL;
+}
+const char *agent_get_role(agent_handle agent) {
+    return agent ? agent->role : NULL;
+}
+const char *agent_get_manager_id(agent_handle agent) {
+    return agent ? agent->manager_id : NULL;
+}
 char *agent_run(agent_handle agent, const char *user_message) {
     if (!agent) return NULL;
-
     agent->state = AGENT_STATE_RUNNING;
     agent->iteration_count = 0;
     agent->tool_retry_count = 0;
-
     if (!user_message || !*user_message) {
         agent->state = AGENT_STATE_ERROR;
         agent_set_error(agent, "Empty user message");
         return NULL;
     }
-
     messages_load(agent->messages);
-
     char *json_data = agent_build_request(agent, "user", user_message);
     if (!json_data) {
         agent->state = AGENT_STATE_ERROR;
         agent_set_error(agent, "Failed to create chat JSON");
         return NULL;
     }
-
     char *accumulated_response = NULL;
     size_t accumulated_len = 0;
-
     while (agent->state == AGENT_STATE_RUNNING || agent->state == AGENT_STATE_EXECUTING_TOOLS) {
         agent->iteration_count++;
-
+        if (!agent_check_budget(agent)) {
+            agent->state = AGENT_STATE_ERROR;
+            agent_set_error(agent, "QUARTERLY_BUDGET_EXCEEDED");
+            if (agent->verbose) fprintf(stderr, "\033[1;31m[Middleware] Process killed: Token budget exceeded.\033[0m\n");
+            break;
+        }
         if (agent->iteration_count > agent->max_iterations) {
             agent->state = AGENT_STATE_MAX_ITERATIONS;
             agent_set_error(agent, "Maximum iterations reached");
@@ -372,12 +391,10 @@ char *agent_run(agent_handle agent, const char *user_message) {
             free(json_data);
             break;
         }
-
         if (agent->verbose && !agent->is_subagent) {
             fprintf(stderr, "[Agent] Iteration %d/%d\n",
                 agent->iteration_count, agent->max_iterations);
         }
-
         struct json_object *choice = agent_process_response(agent, json_data);
         
         if (!choice && agent->last_error && strcmp(agent->last_error, "CONTEXT_OVERFLOW") == 0) {
@@ -394,10 +411,8 @@ char *agent_run(agent_handle agent, const char *user_message) {
                 break;
             }
         }
-
         free(json_data);
         json_data = NULL;
-
         if (!choice) {
             agent->tool_retry_count++;
             if (agent->tool_retry_count >= agent->max_tool_retries) {
@@ -413,21 +428,17 @@ char *agent_run(agent_handle agent, const char *user_message) {
             agent->state = AGENT_STATE_RUNNING;
             continue;
         }
-
         agent->tool_retry_count = 0;
-
         struct json_object *message_obj = agent_get_message(choice);
         if (message_obj) {
             messages_add_object(agent->messages, json_object_get(message_obj));
         }
-
         char *content = agent_get_content(choice);
         if (content && *content) {
             if (!agent->is_subagent) {
                 parse_markdown_to_ansi(content);
                 printf("\n");
             }
-
             size_t content_len = strlen(content);
             char *new_acc = realloc(accumulated_response, accumulated_len + content_len + 2);
             if (new_acc) {
@@ -440,31 +451,23 @@ char *agent_run(agent_handle agent, const char *user_message) {
                 accumulated_len += content_len;
             }
         }
-
         bool has_tools = agent_has_tool_calls(choice);
-
         if (agent->verbose && !agent->is_subagent) {
             fprintf(stderr, "[Agent] has_tool_calls=%s\n", has_tools ? "true" : "false");
         }
-
         if (has_tools) {
             agent->state = AGENT_STATE_EXECUTING_TOOLS;
-
             struct json_object *tool_calls = agent_get_tool_calls(choice);
-
             if (agent->verbose && !agent->is_subagent) {
                 int num_tools = json_object_array_length(tool_calls);
                 fprintf(stderr, "[Agent] Executing %d tool(s)\n", num_tools);
             }
-
             struct json_object *results = tool_registry_execute(agent->tools, tool_calls, agent->verbose);
-
             int count = json_object_array_length(results);
             for (int i = 0; i < count; i++) {
                 struct json_object *result = json_object_array_get_idx(results, i);
                 messages_add_tool_call(agent->messages, json_object_get(result));
             }
-
             agent->state = AGENT_STATE_RUNNING;
             json_data = agent_build_request(agent, NULL, NULL);
             if (!json_data) {
@@ -473,12 +476,10 @@ char *agent_run(agent_handle agent, const char *user_message) {
                 free(content);
                 break;
             }
-
         } else if (content && agent_response_indicates_incomplete(content)) {
             if (agent->verbose && !agent->is_subagent) {
                 fprintf(stderr, "[Agent] Response indicates incomplete work, auto-continuing\n");
             }
-
             json_data = agent_build_request(agent, "user",
                 "Continue. Execute the necessary actions to complete the task.");
             agent->state = AGENT_STATE_RUNNING;
@@ -497,36 +498,27 @@ char *agent_run(agent_handle agent, const char *user_message) {
         }
         free(content);
     }
-
     free(json_data);
     return accumulated_response;
 }
-
 char *agent_chat(const char *user_message, messages_handle messages) {
     agent_handle agent = agent_create(user_message, messages);
     if (!agent) return NULL;
-
     char *response = agent_run(agent, user_message);
-
     if (agent->verbose && agent->state != AGENT_STATE_COMPLETED && agent->last_error) {
         if (!agent->is_subagent) fprintf(stderr, "[Agent] Error: %s\n", agent->last_error);
     }
-
     agent_destroy(agent);
     return response;
 }
-
 char *agent_chat_with_limit(const char *user_message, int max_iterations, messages_handle messages) {
     agent_handle agent = agent_create(user_message, messages);
     if (!agent) return NULL;
-
     agent_set_max_iterations(agent, max_iterations);
     char *response = agent_run(agent, user_message);
-
     if (agent->verbose && agent->state != AGENT_STATE_COMPLETED && agent->last_error) {
         if (!agent->is_subagent) fprintf(stderr, "[Agent] Error: %s\n", agent->last_error);
     }
-
     agent_destroy(agent);
     return response;
 }

src/bash_executor.c

@@ -1,5 +1,4 @@
 // retoor <retoor@molodetz.nl>
-
 #define _GNU_SOURCE
 #include "bash_executor.h"
 #include <stdio.h>
@@ -14,47 +13,37 @@
 #include <signal.h>
 #include <errno.h>
 #include <time.h>
-
 #define DEFAULT_TIMEOUT 300
-
 void r_process_result_free(r_process_result_t *res) {
     if (!res) return;
     free(res->output);
     free(res->log_path);
     free(res);
 }
-
 static char *get_log_path(int pid) {
     char *path = NULL;
     if (asprintf(&path, "/tmp/r_process_%d.log", pid) == -1) return NULL;
     return path;
 }
-
 r_process_result_t *r_bash_execute_ext(const char *command, int timeout_seconds, bool async) {
     if (!command) return NULL;
-
     r_process_result_t *res = calloc(1, sizeof(r_process_result_t));
     if (!res) return NULL;
-
     if (timeout_seconds <= 0) timeout_seconds = DEFAULT_TIMEOUT;
-
     char tmp_script[] = "/tmp/r_bash_XXXXXX.sh";
     int script_fd = mkstemps(tmp_script, 3);
     if (script_fd == -1) {
         res->output = strdup("Error: failed to create temp script");
         return res;
     }
-
     dprintf(script_fd, "%s\n", command);
     close(script_fd);
-
     int pipe_fds[2];
     if (pipe(pipe_fds) == -1) {
         unlink(tmp_script);
         res->output = strdup("Error: pipe failed");
         return res;
     }
-
     pid_t pid = fork();
     if (pid == -1) {
         close(pipe_fds[0]);
@@ -63,7 +52,6 @@ r_process_result_t *r_bash_execute_ext(const char *command, int timeout_seconds,
         res->output = strdup("Error: fork failed");
         return res;
     }
-
     if (pid == 0) {
         // Child
         setsid(); // New session to prevent signals to parent
@@ -73,7 +61,6 @@ r_process_result_t *r_bash_execute_ext(const char *command, int timeout_seconds,
         char *log_p = get_log_path(getpid());
         int log_fd = open(log_p, O_WRONLY | O_CREAT | O_TRUNC, 0644);
         free(log_p);
-
         if (log_fd != -1) {
             dup2(log_fd, STDOUT_FILENO);
             dup2(log_fd, STDERR_FILENO);
@@ -87,30 +74,25 @@ r_process_result_t *r_bash_execute_ext(const char *command, int timeout_seconds,
         // Actually, let's just use log file for everything.
         
         close(pipe_fds[1]);
-
         char *args[] = {"bash", tmp_script, NULL};
         execvp("bash", args);
         exit(1);
     }
-
     // Parent
     res->pid = pid;
     res->log_path = get_log_path(pid);
     res->is_running = true;
     close(pipe_fds[1]);
     close(pipe_fds[0]);
-
     if (async) {
         res->output = strdup("Process started in background.");
         usleep(100000); // Give child time to start
         unlink(tmp_script);
         return res;
     }
-
     // Wait for timeout
     time_t start_time = time(NULL);
     long last_read_pos = 0;
-
     while (true) {
         int status;
         pid_t ret = waitpid(pid, &status, WNOHANG);
@@ -127,7 +109,6 @@ r_process_result_t *r_bash_execute_ext(const char *command, int timeout_seconds,
             last_read_pos = ftell(f_tail);
             fclose(f_tail);
         }
-
         if (ret == pid) {
             res->is_running = false;
             res->exit_status = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
@@ -136,14 +117,12 @@ r_process_result_t *r_bash_execute_ext(const char *command, int timeout_seconds,
             res->is_running = false;
             break;
         }
-
         if (time(NULL) - start_time >= timeout_seconds) {
             res->timed_out = true;
             break;
         }
         usleep(50000); // 100ms -> 50ms for better responsiveness
     }
-
     // Read log file for output
     FILE *log_f = fopen(res->log_path, "r");
     if (log_f) {
@@ -159,13 +138,10 @@ r_process_result_t *r_bash_execute_ext(const char *command, int timeout_seconds,
         }
         fclose(log_f);
     }
-
     if (!res->output) res->output = strdup("");
-
     unlink(tmp_script);
     return res;
 }
-
 char *r_bash_execute(const char *command, bool interactive, int timeout_seconds) {
     // Legacy support wrapper
     r_process_result_t *res = r_bash_execute_ext(command, timeout_seconds, false);

src/bash_repair.c

@@ -1,12 +1,10 @@
 // retoor <retoor@molodetz.nl>
-
 #include "bash_repair.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>
 #include <ctype.h>
-
 static char *ensure_shebang(const char *text) {
     if (!text || !*text) return strdup("");
     
@@ -16,7 +14,6 @@ static char *ensure_shebang(const char *text) {
     if (strncmp(p, "#!", 2) == 0 || strncmp(p, ": <<", 4) == 0) {
         return strdup(text);
     }
-
     // Heuristic: if it has multiple lines, add shebang
     if (strchr(text, '\n')) {
         char *result = malloc(strlen(text) + 32);
@@ -25,25 +22,20 @@ static char *ensure_shebang(const char *text) {
         strcat(result, text);
         return result;
     }
-
     return strdup(text);
 }
-
 static char *normalize_whitespace_and_operators(const char *src) {
     if (!src) return NULL;
     size_t src_len = strlen(src);
     char *result = malloc(src_len * 2 + 1);
     if (!result) return NULL;
-
     char *dst = result;
     const char *curr = src;
-
     while (*curr) {
         if (*curr == '\r') {
             curr++;
             continue;
         }
-
         // Detect operators to normalize spaces around them
         const char *ops[] = {"||", "&&", ">>", "|&", "|", ";", ">", "<", NULL};
         bool matched_op = false;
@@ -66,18 +58,15 @@ static char *normalize_whitespace_and_operators(const char *src) {
                 break;
             }
         }
-
         if (!matched_op) {
             *dst++ = *curr++;
         }
     }
     *dst = '\0';
-
     // Second pass to strip trailing spaces on each line
     char *s2 = strdup(result);
     free(result);
     if (!s2) return NULL;
-
     char *final = malloc(strlen(s2) + 1);
     char *f_ptr = final;
     char *line = s2;
@@ -102,25 +91,20 @@ static char *normalize_whitespace_and_operators(const char *src) {
     free(s2);
     return final;
 }
-
 static char *fix_line_issues(const char *src) {
     if (!src) return NULL;
     size_t src_len = strlen(src);
     char *result = malloc(src_len * 2 + 1024);
     if (!result) return NULL;
-
     char *dst = result;
     const char *line = src;
-
     while (line && *line) {
         const char *next_line = strchr(line, '\n');
         size_t line_len = next_line ? (size_t)(next_line - line) : strlen(line);
-
         char line_buf[4096];
         if (line_len >= sizeof(line_buf)) line_len = sizeof(line_buf) - 1;
         memcpy(line_buf, line, line_len);
         line_buf[line_len] = '\0';
-
         // 1. Tiny Shell Lint (else if -> elif)
         char *else_if = strstr(line_buf, "else if ");
         if (else_if) {
@@ -128,7 +112,6 @@ static char *fix_line_issues(const char *src) {
             memmove(else_if + 4, else_if + 8, strlen(else_if + 8) + 1);
             memcpy(else_if, "elif", 4);
         }
-
         // 2. Fix unbalanced quotes
         int single = 0, double_q = 0;
         bool escaped = false;
@@ -140,7 +123,6 @@ static char *fix_line_issues(const char *src) {
         }
         if (single % 2 == 1 && double_q == 0) strcat(line_buf, "'");
         else if (double_q % 2 == 1 && single == 0) strcat(line_buf, "\"");
-
         // 3. Fix trailing operators
         size_t cur_len = strlen(line_buf);
         const char *ops[] = {"||", "&&", ">>", "|&", "|", ">", "<", NULL};
@@ -159,24 +141,20 @@ static char *fix_line_issues(const char *src) {
                 }
             }
         }
-
         // 4. Dangerous rm -rf check
         if (strstr(line_buf, "sudo rm -rf /") || strstr(line_buf, "rm -rf / ")) {
             strcpy(dst, "# WARNING: potentially destructive command detected\n");
             dst += strlen(dst);
         }
-
         strcpy(dst, line_buf);
         dst += strlen(dst);
         if (next_line) *dst++ = '\n';
-
         if (next_line) line = next_line + 1;
         else break;
     }
     *dst = '\0';
     return result;
 }
-
 static char *collapse_nested_bash_c(const char *src) {
     if (!src) return NULL;
     // Pattern: bash -c "bash -c '...'")
@@ -222,10 +200,8 @@ static char *collapse_nested_bash_c(const char *src) {
     }
     return s1;
 }
-
 char *bash_repair_command(const char *src) {
     if (!src) return NULL;
-
     char *s1 = normalize_whitespace_and_operators(src);
     char *s2 = fix_line_issues(s1);
     free(s1);
@@ -233,6 +209,5 @@ char *bash_repair_command(const char *src) {
     free(s2);
     char *s4 = ensure_shebang(s3);
     free(s3);
-
     return s4;
 }

src/context_manager.c

@@ -1,13 +1,10 @@
 // retoor <retoor@molodetz.nl>
-
 #include "context_manager.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
 #define MIN_KEEP_CHARS 500
 #define TRUNCATE_MARKER "\n\n[... content truncated for context management ...]\n\n"
-
 static const char *get_message_role(struct json_object *msg) {
     struct json_object *role_obj;
     if (json_object_object_get_ex(msg, "role", &role_obj)) {
@@ -20,7 +17,6 @@ static const char *get_message_role(struct json_object *msg) {
     }
     return "";
 }
-
 static bool has_tool_calls(struct json_object *msg) {
     struct json_object *tool_calls;
     if (json_object_object_get_ex(msg, "tool_calls", &tool_calls)) {
@@ -28,20 +24,16 @@ static bool has_tool_calls(struct json_object *msg) {
     }
     return false;
 }
-
 static size_t get_message_content_len(struct json_object *msg) {
     struct json_object *content_obj;
     const char *content = NULL;
-
     if (json_object_object_get_ex(msg, "content", &content_obj)) {
         content = json_object_get_string(content_obj);
     } else if (json_object_object_get_ex(msg, "tool_result", &content_obj)) {
         content = json_object_get_string(content_obj);
     }
-
     return content ? strlen(content) : 0;
 }
-
 static size_t calculate_total_size(messages_handle msgs) {
     size_t total = 0;
     int count = messages_count(msgs);
@@ -50,63 +42,49 @@ static size_t calculate_total_size(messages_handle msgs) {
     }
     return total;
 }
-
 static r_status_t perform_truncate(messages_handle msgs, int index, double ratio) {
     struct json_object *msg = messages_get_object(msgs, index);
     if (!msg) return R_ERROR_NOT_FOUND;
-
     struct json_object *content_obj;
     const char *content = NULL;
     bool is_tool_result = false;
-
     if (json_object_object_get_ex(msg, "content", &content_obj)) {
         content = json_object_get_string(content_obj);
     } else if (json_object_object_get_ex(msg, "tool_result", &content_obj)) {
         content = json_object_get_string(content_obj);
         is_tool_result = true;
     }
-
     if (!content) return R_SUCCESS;
-
     size_t len = strlen(content);
     size_t target_len = (size_t)(len * ratio);
     if (target_len < MIN_KEEP_CHARS * 2) target_len = MIN_KEEP_CHARS * 2;
     if (target_len >= len) return R_SUCCESS;
-
     size_t keep_each = target_len / 2;
     
     char *new_content = malloc(keep_each * 2 + strlen(TRUNCATE_MARKER) + 1);
     if (!new_content) return R_ERROR_OUT_OF_MEMORY;
-
     strncpy(new_content, content, keep_each);
     new_content[keep_each] = '\0';
     strcat(new_content, TRUNCATE_MARKER);
     strcat(new_content, content + len - keep_each);
-
     struct json_object *new_msg = json_tokener_parse(json_object_to_json_string(msg));
     if (is_tool_result) {
         json_object_object_add(new_msg, "tool_result", json_object_new_string(new_content));
     } else {
         json_object_object_add(new_msg, "content", json_object_new_string(new_content));
     }
-
     free(new_content);
     return messages_replace_at(msgs, index, new_msg);
 }
-
 r_status_t context_manager_shrink(messages_handle msgs) {
     if (!msgs) return R_ERROR_INVALID_ARG;
-
     int count = messages_count(msgs);
     if (count <= 2) return R_ERROR_API_ERROR;
-
     size_t initial_size = calculate_total_size(msgs);
     size_t target_size = (size_t)(initial_size * 0.5);
     if (target_size < 20000) target_size = 20000;
-
     fprintf(stderr, "  \033[2m-> Context overflow (%zu chars). Middle-out shrinking to %zu...\033[0m\n", 
             initial_size, target_size);
-
     // Strategy 1: Truncate very large messages first (safe, doesn't break sequence)
     for (int i = 0; i < messages_count(msgs); i++) {
         struct json_object *msg = messages_get_object(msgs, i);
@@ -114,7 +92,6 @@ r_status_t context_manager_shrink(messages_handle msgs) {
             perform_truncate(msgs, i, 0.2);
         }
     }
-
     // Strategy 2: Remove messages from the middle until size is within target
     // We keep: 
     // - System message (usually index 0)
@@ -123,7 +100,6 @@ r_status_t context_manager_shrink(messages_handle msgs) {
         int middle_idx = 1; // Start after system
         struct json_object *msg = messages_get_object(msgs, middle_idx);
         const char *role = get_message_role(msg);
-
         int remove_count = 1;
         if (strcmp(role, "assistant") == 0 && has_tool_calls(msg)) {
             // Must also remove the following tool results to maintain sequence
@@ -138,18 +114,14 @@ r_status_t context_manager_shrink(messages_handle msgs) {
                 }
             }
         }
-
         // Ensure we don't eat into the "recent" buffer
         if (middle_idx + remove_count > messages_count(msgs) - 4) {
             break;
         }
-
         messages_remove_range(msgs, middle_idx, remove_count);
     }
-
     size_t final_size = calculate_total_size(msgs);
     fprintf(stderr, "  \033[2m-> Context shrunk to %zu chars. Remaining messages: %d\033[0m\n", 
             final_size, messages_count(msgs));
-
     return R_SUCCESS;
 }

src/context_summarizer.c

@@ -1,8 +1,7 @@
-#include "context_summarizer.h"
+// retoor <retoor@molodetz.nl>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-
 // Placeholder for LLM API call
 // In a real implementation, this function would call the LLM API to get the summary.
 static char* call_llm_to_summarize(const char* messages_concatenated) {
@@ -14,7 +13,6 @@ static char* call_llm_to_summarize(const char* messages_concatenated) {
     }
     return result;
 }
-
 char* summarize_oldest_messages(const char** messages, size_t message_count) {
     // Concatenate the oldest 20 messages
     size_t total_length = 0;
@@ -25,20 +23,17 @@ char* summarize_oldest_messages(const char** messages, size_t message_count) {
     for (size_t i = start_index; i < message_count; ++i) {
         total_length += strlen(messages[i]) + 1; // +1 for separator
     }
-
     char* concatenated = malloc(total_length + 1);
     if (!concatenated) {
         return NULL;
     }
     concatenated[0] = '\0';
-
     for (size_t i = start_index; i < message_count; ++i) {
         strcat(concatenated, messages[i]);
         if (i < message_count - 1) {
             strcat(concatenated, " "); // separator
         }
     }
-
     // Call the LLM API to get the summary
     char* summary = call_llm_to_summarize(concatenated);
     free(concatenated);

src/db.c

@@ -1,5 +1,4 @@
 // retoor <retoor@molodetz.nl>
-
 #include "db.h"
 #include "r_config.h"
 #include <sqlite3.h>
@@ -7,65 +6,52 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
-
 struct db_t {
     sqlite3 *conn;
     char *path;
 };
-
 static char *expand_home_directory(const char *path) {
     if (!path) return NULL;
     if (path[0] != '~') return strdup(path);
-
     const char *home_dir = getenv("HOME");
     if (!home_dir) home_dir = getenv("USERPROFILE");
     if (!home_dir) return strdup(path);
-
     size_t home_len = strlen(home_dir);
     size_t path_len = strlen(path);
     char *expanded = malloc(home_len + path_len);
     if (!expanded) return NULL;
-
     strcpy(expanded, home_dir);
     strcat(expanded, path + 1);
     return expanded;
 }
-
 db_handle db_open(const char *path) {
     struct db_t *db = calloc(1, sizeof(struct db_t));
     if (!db) return NULL;
-
     if (!path) {
         r_config_handle cfg = r_config_get_instance();
         path = r_config_get_db_path(cfg);
     }
-
     db->path = expand_home_directory(path);
     if (!db->path) {
         free(db);
         return NULL;
     }
-
     if (sqlite3_open(db->path, &db->conn) != SQLITE_OK) {
         free(db->path);
         free(db);
         return NULL;
     }
-
     db_init(db);
     return db;
 }
-
 void db_close(db_handle db) {
     if (!db) return;
     if (db->conn) sqlite3_close(db->conn);
     free(db->path);
     free(db);
 }
-
 r_status_t db_init(db_handle db) {
     if (!db || !db->conn) return R_ERROR_INVALID_ARG;
-
     const char *sql =
         "CREATE TABLE IF NOT EXISTS kv ("
         "    key TEXT PRIMARY KEY,"
@@ -93,8 +79,45 @@ r_status_t db_init(db_handle db) {
         "    status TEXT DEFAULT 'pending',"
         "    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
         "    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
+        ");"
+        "CREATE TABLE IF NOT EXISTS gtr ("
+        "    task_hash TEXT PRIMARY KEY,"
+        "    task_description TEXT NOT NULL,"
+        "    status TEXT NOT NULL,"
+        "    owner_agent TEXT NOT NULL,"
+        "    result_summary TEXT,"
+        "    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
+        "    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
+        ");"
+        "CREATE TABLE IF NOT EXISTS audit_log ("
+        "    id INTEGER PRIMARY KEY AUTOINCREMENT,"
+        "    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
+        "    issuer_agent TEXT NOT NULL,"
+        "    recipient_agent TEXT NOT NULL,"
+        "    order_description TEXT NOT NULL,"
+        "    logic_justification TEXT NOT NULL,"
+        "    status TEXT NOT NULL"
+        ");"
+        "CREATE TABLE IF NOT EXISTS agents ("
+        "    agent_id TEXT PRIMARY KEY,"
+        "    role TEXT NOT NULL,"
+        "    manager_id TEXT,"
+        "    department TEXT,"
+        "    budget_limit_tokens INTEGER DEFAULT 1000000,"
+        "    used_tokens INTEGER DEFAULT 0,"
+        "    last_heartbeat TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
+        "    status TEXT DEFAULT 'active'"
+        ");"
+        "CREATE TABLE IF NOT EXISTS research_tasks ("
+        "    id INTEGER PRIMARY KEY AUTOINCREMENT,"
+        "    url_hash TEXT UNIQUE,"
+        "    url TEXT NOT NULL,"
+        "    status TEXT NOT NULL,"
+        "    summary TEXT,"
+        "    batch_id TEXT,"
+        "    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
+        "    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
         ");";
-
     char *err_msg = NULL;
     if (sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg) != SQLITE_OK) {
         sqlite3_free(err_msg);
@@ -102,57 +125,43 @@ r_status_t db_init(db_handle db) {
     }
     return R_SUCCESS;
 }
-
 r_status_t db_kv_set(db_handle db, const char *key, const char *value) {
     if (!db || !db->conn || !key || !value) return R_ERROR_INVALID_ARG;
-
     char *sql = sqlite3_mprintf(
         "INSERT OR REPLACE INTO kv (key, value, updated_at) VALUES (%Q, %Q, CURRENT_TIMESTAMP)",
         key, value);
     if (!sql) return R_ERROR_OUT_OF_MEMORY;
-
     char *err_msg = NULL;
     int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
     sqlite3_free(sql);
-
     if (rc != SQLITE_OK) {
         sqlite3_free(err_msg);
         return R_ERROR_DB_QUERY;
     }
     return R_SUCCESS;
 }
-
 r_status_t db_kv_get(db_handle db, const char *key, char **value) {
     if (!db || !db->conn || !key || !value) return R_ERROR_INVALID_ARG;
-
     *value = NULL;
     const char *sql = "SELECT value FROM kv WHERE key = ?";
     sqlite3_stmt *stmt = NULL;
-
     if (sqlite3_prepare_v2(db->conn, sql, -1, &stmt, NULL) != SQLITE_OK) {
         return R_ERROR_DB_QUERY;
     }
-
     sqlite3_bind_text(stmt, 1, key, -1, SQLITE_STATIC);
-
     int rc = sqlite3_step(stmt);
     if (rc == SQLITE_ROW) {
         const char *val = (const char *)sqlite3_column_text(stmt, 0);
         *value = val ? strdup(val) : NULL;
     }
-
     sqlite3_finalize(stmt);
     return (rc == SQLITE_ROW) ? R_SUCCESS : R_ERROR_DB_NOT_FOUND;
 }
-
 r_status_t db_execute(db_handle db, const char *sql, struct json_object **result) {
     if (!db || !db->conn || !sql || !result) return R_ERROR_INVALID_ARG;
-
     *result = NULL;
-
     const char *select_check = sql;
     while (*select_check == ' ') select_check++;
-
     if (strncasecmp(select_check, "SELECT", 6) != 0) {
         char *err_msg = NULL;
         int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
@@ -169,7 +178,6 @@ r_status_t db_execute(db_handle db, const char *sql, struct json_object **result
         *result = success_obj;
         return R_SUCCESS;
     }
-
     sqlite3_stmt *stmt = NULL;
     if (sqlite3_prepare_v2(db->conn, sql, -1, &stmt, NULL) != SQLITE_OK) {
         struct json_object *error_obj = json_object_new_object();
@@ -178,17 +186,13 @@ r_status_t db_execute(db_handle db, const char *sql, struct json_object **result
         *result = error_obj;
         return R_ERROR_DB_QUERY;
     }
-
     struct json_object *array = json_object_new_array();
     int col_count = sqlite3_column_count(stmt);
-
     while (sqlite3_step(stmt) == SQLITE_ROW) {
         struct json_object *row = json_object_new_object();
-
         for (int i = 0; i < col_count; i++) {
             const char *col_name = sqlite3_column_name(stmt, i);
             int col_type = sqlite3_column_type(stmt, i);
-
             switch (col_type) {
                 case SQLITE_INTEGER:
                     json_object_object_add(row, col_name,
@@ -211,108 +215,107 @@ r_status_t db_execute(db_handle db, const char *sql, struct json_object **result
                     break;
             }
         }
-
         json_object_array_add(array, row);
     }
-
     sqlite3_finalize(stmt);
     *result = array;
     return R_SUCCESS;
 }
-
 char *db_get_schema(db_handle db) {
     if (!db || !db->conn) return strdup("Database not available");
-
     struct json_object *result = NULL;
     r_status_t status = db_execute(db,
         "SELECT name, sql FROM sqlite_master WHERE type='table' ORDER BY name",
         &result);
-
     if (status != R_SUCCESS || !result) {
         return strdup("Failed to get schema");
     }
-
     char *schema = strdup(json_object_to_json_string_ext(result, JSON_C_TO_STRING_PRETTY));
     json_object_put(result);
     return schema;
 }
-
 r_status_t db_store_file_version(db_handle db, const char *path) {
     if (!db || !db->conn || !path) return R_ERROR_INVALID_ARG;
-
     FILE *fp = fopen(path, "r");
     if (!fp) return R_ERROR_FILE_NOT_FOUND;
-
     fseek(fp, 0, SEEK_END);
     long size = ftell(fp);
     rewind(fp);
-
     if (size <= 0 || size > 1000000) {
         fclose(fp);
         return R_SUCCESS;
     }
-
     char *content = malloc(size + 1);
     if (!content) {
         fclose(fp);
         return R_ERROR_OUT_OF_MEMORY;
     }
-
     size_t read_size = fread(content, 1, size, fp);
     content[read_size] = '\0';
     fclose(fp);
-
     char *sql = sqlite3_mprintf(
         "INSERT INTO file_versions (path, content) VALUES (%Q, %Q)",
         path, content);
     free(content);
-
     if (!sql) return R_ERROR_OUT_OF_MEMORY;
-
     char *err_msg = NULL;
     int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
     sqlite3_free(sql);
     sqlite3_free(err_msg);
-
     return (rc == SQLITE_OK) ? R_SUCCESS : R_ERROR_DB_QUERY;
 }
-
 r_status_t db_save_conversation(db_handle db, const char *session_key, const char *data) {
     if (!db || !db->conn || !session_key || !data) return R_ERROR_INVALID_ARG;
-
     char *sql = sqlite3_mprintf(
         "INSERT OR REPLACE INTO conversations (session_key, data, updated_at) "
         "VALUES (%Q, %Q, CURRENT_TIMESTAMP)",
         session_key, data);
     if (!sql) return R_ERROR_OUT_OF_MEMORY;
-
     char *err_msg = NULL;
     int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
     sqlite3_free(sql);
     sqlite3_free(err_msg);
-
     return (rc == SQLITE_OK) ? R_SUCCESS : R_ERROR_DB_QUERY;
 }
-
+long long db_get_conversation_age(db_handle db, const char *session_key) {
+    if (!db || !db->conn || !session_key) return -1;
+    const char *sql = "SELECT CAST((julianday('now') - julianday(updated_at)) * 86400 AS INTEGER) FROM conversations WHERE session_key = ?";
+    sqlite3_stmt *stmt = NULL;
+    if (sqlite3_prepare_v2(db->conn, sql, -1, &stmt, NULL) != SQLITE_OK) {
+        return -1;
+    }
+    sqlite3_bind_text(stmt, 1, session_key, -1, SQLITE_STATIC);
+    long long age = -1;
+    if (sqlite3_step(stmt) == SQLITE_ROW) {
+        age = sqlite3_column_int64(stmt, 0);
+    }
+    sqlite3_finalize(stmt);
+    return age;
+}
+r_status_t db_delete_conversation(db_handle db, const char *session_key) {
+    if (!db || !db->conn || !session_key) return R_ERROR_INVALID_ARG;
+    char *sql = sqlite3_mprintf("DELETE FROM conversations WHERE session_key = %Q", session_key);
+    if (!sql) return R_ERROR_OUT_OF_MEMORY;
+    char *err_msg = NULL;
+    int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
+    sqlite3_free(sql);
+    sqlite3_free(err_msg);
+    return (rc == SQLITE_OK) ? R_SUCCESS : R_ERROR_DB_QUERY;
+}
 r_status_t db_load_conversation(db_handle db, const char *session_key, char **data) {
     if (!db || !db->conn || !session_key || !data) return R_ERROR_INVALID_ARG;
-
     *data = NULL;
     const char *sql = "SELECT data FROM conversations WHERE session_key = ?";
     sqlite3_stmt *stmt = NULL;
-
     if (sqlite3_prepare_v2(db->conn, sql, -1, &stmt, NULL) != SQLITE_OK) {
         return R_ERROR_DB_QUERY;
     }
-
     sqlite3_bind_text(stmt, 1, session_key, -1, SQLITE_STATIC);
-
     int rc = sqlite3_step(stmt);
     if (rc == SQLITE_ROW) {
         const char *val = (const char *)sqlite3_column_text(stmt, 0);
         *data = val ? strdup(val) : NULL;
     }
-
     sqlite3_finalize(stmt);
     return (rc == SQLITE_ROW) ? R_SUCCESS : R_ERROR_DB_NOT_FOUND;
 }

src/http_client.c

@@ -1,5 +1,4 @@
 // retoor <retoor@molodetz.nl>
-
 #include "http_client.h"
 #include <curl/curl.h>
 #include <pthread.h>
@@ -9,32 +8,26 @@
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
-
 #define HTTP_MAX_RETRIES 3
 #define HTTP_RETRY_DELAY_MS 2000
-
 struct http_client_t {
     char *bearer_token;
     long timeout_seconds;
     long connect_timeout_seconds;
     bool show_spinner;
 };
-
 struct response_buffer_t {
     char *data;
     size_t size;
 };
-
 static struct timespec spinner_start_time = {0, 0};
 static volatile int spinner_running = 0;
-
 static double get_elapsed_seconds(void) {
     struct timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
     return (now.tv_sec - spinner_start_time.tv_sec) +
            (now.tv_nsec - spinner_start_time.tv_nsec) / 1e9;
 }
-
 static void *spinner_thread(void *arg) {
     (void)arg;
     const char *frames[] = {"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"};
@@ -48,31 +41,25 @@ static void *spinner_thread(void *arg) {
     }
     return NULL;
 }
-
 static size_t write_callback(void *contents, size_t size, size_t nmemb, void *userp) {
     size_t total_size = size * nmemb;
     struct response_buffer_t *response = (struct response_buffer_t *)userp;
-
     if (total_size > SIZE_MAX - response->size - 1) {
         return 0;
     }
-
     char *ptr = realloc(response->data, response->size + total_size + 1);
     if (!ptr) {
         return 0;
     }
-
     response->data = ptr;
     memcpy(&(response->data[response->size]), contents, total_size);
     response->size += total_size;
     response->data[response->size] = '\0';
     return total_size;
 }
-
 http_client_handle http_client_create(const char *bearer_token) {
     struct http_client_t *client = calloc(1, sizeof(struct http_client_t));
     if (!client) return NULL;
-
     if (bearer_token) {
         client->bearer_token = strdup(bearer_token);
         if (!client->bearer_token) {
@@ -80,74 +67,58 @@ http_client_handle http_client_create(const char *bearer_token) {
             return NULL;
         }
     }
-
     client->timeout_seconds = 300;
     client->connect_timeout_seconds = 10;
     client->show_spinner = true;
-
     return client;
 }
-
 void http_client_destroy(http_client_handle client) {
     if (!client) return;
     free(client->bearer_token);
     free(client);
 }
-
 void http_client_set_show_spinner(http_client_handle client, bool show) {
     if (client) client->show_spinner = show;
 }
-
 void http_client_set_timeout(http_client_handle client, long timeout_seconds) {
     if (client) client->timeout_seconds = timeout_seconds;
 }
-
 void http_client_set_connect_timeout(http_client_handle client, long timeout_seconds) {
     if (client) client->connect_timeout_seconds = timeout_seconds;
 }
-
 r_status_t http_post(http_client_handle client, const char *url,
                      const char *data, char **response) {
     if (!client || !url || !response) return R_ERROR_INVALID_ARG;
-
     CURL *curl = NULL;
     struct curl_slist *headers = NULL;
     struct response_buffer_t resp = {NULL, 0};
     int retry_count = 0;
     pthread_t spinner_tid = 0;
     r_status_t status = R_SUCCESS;
-
     *response = NULL;
-
     bool actually_show_spinner = client->show_spinner && isatty(STDERR_FILENO);
-
     if (actually_show_spinner) {
         clock_gettime(CLOCK_MONOTONIC, &spinner_start_time);
         spinner_running = 1;
         pthread_create(&spinner_tid, NULL, spinner_thread, NULL);
     }
-
     while (retry_count < HTTP_MAX_RETRIES) {
         free(resp.data);
         resp.data = malloc(1);
         resp.size = 0;
-
         if (!resp.data) {
             status = R_ERROR_OUT_OF_MEMORY;
             goto cleanup;
         }
         resp.data[0] = '\0';
-
         curl = curl_easy_init();
         if (!curl) {
             status = R_ERROR_HTTP_CONNECTION;
             goto cleanup;
         }
-
         curl_easy_setopt(curl, CURLOPT_URL, url);
         curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, client->connect_timeout_seconds);
         curl_easy_setopt(curl, CURLOPT_TIMEOUT, client->timeout_seconds);
-
         headers = curl_slist_append(headers, "Content-Type: application/json");
         if (client->bearer_token) {
             char bearer_header[2048];
@@ -155,42 +126,33 @@ r_status_t http_post(http_client_handle client, const char *url,
                      client->bearer_token);
             headers = curl_slist_append(headers, bearer_header);
         }
-
         curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
         curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&resp);
-
         CURLcode res = curl_easy_perform(curl);
-
         curl_slist_free_all(headers);
         headers = NULL;
         curl_easy_cleanup(curl);
         curl = NULL;
-
         if (res == CURLE_OK) {
             *response = resp.data;
             resp.data = NULL;
             status = R_SUCCESS;
             goto cleanup;
         }
-
         retry_count++;
-
         if (actually_show_spinner) {
             spinner_running = 0;
             pthread_join(spinner_tid, NULL);
             spinner_tid = 0;
             fprintf(stderr, "\r                              \r");
         }
-
         fprintf(stderr, "Network error: %s (attempt %d/%d)\n",
                 curl_easy_strerror(res), retry_count, HTTP_MAX_RETRIES);
-
         if (retry_count < HTTP_MAX_RETRIES) {
             fprintf(stderr, "Retrying in %d seconds...\n", HTTP_RETRY_DELAY_MS / 1000);
             usleep(HTTP_RETRY_DELAY_MS * 1000);
-
             if (actually_show_spinner) {
                 clock_gettime(CLOCK_MONOTONIC, &spinner_start_time);
                 spinner_running = 1;
@@ -198,9 +160,7 @@ r_status_t http_post(http_client_handle client, const char *url,
             }
         }
     }
-
     status = R_ERROR_HTTP_TIMEOUT;
-
 cleanup:
     if (actually_show_spinner && spinner_tid) {
         spinner_running = 0;
@@ -208,46 +168,36 @@ cleanup:
         fprintf(stderr, "\r                              \r");
         fflush(stderr);
     }
-
     if (headers) curl_slist_free_all(headers);
     if (curl) curl_easy_cleanup(curl);
     free(resp.data);
-
     return status;
 }
-
 r_status_t http_get(http_client_handle client, const char *url, char **response) {
     if (!client || !url || !response) return R_ERROR_INVALID_ARG;
-
     CURL *curl = NULL;
     struct curl_slist *headers = NULL;
     struct response_buffer_t resp = {NULL, 0};
     int retry_count = 0;
     r_status_t status = R_SUCCESS;
-
     *response = NULL;
-
     while (retry_count < HTTP_MAX_RETRIES) {
         free(resp.data);
         resp.data = malloc(1);
         resp.size = 0;
-
         if (!resp.data) {
             status = R_ERROR_OUT_OF_MEMORY;
             goto cleanup;
         }
         resp.data[0] = '\0';
-
         curl = curl_easy_init();
         if (!curl) {
             status = R_ERROR_HTTP_CONNECTION;
             goto cleanup;
         }
-
         curl_easy_setopt(curl, CURLOPT_URL, url);
         curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, client->connect_timeout_seconds);
         curl_easy_setopt(curl, CURLOPT_TIMEOUT, 60L);
-
         headers = curl_slist_append(headers, "Content-Type: application/json");
         if (client->bearer_token) {
             char bearer_header[2048];
@@ -255,59 +205,46 @@ r_status_t http_get(http_client_handle client, const char *url, char **response)
                      client->bearer_token);
             headers = curl_slist_append(headers, bearer_header);
         }
-
         curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&resp);
-
         CURLcode res = curl_easy_perform(curl);
-
         curl_slist_free_all(headers);
         headers = NULL;
         curl_easy_cleanup(curl);
         curl = NULL;
-
         if (res == CURLE_OK) {
             *response = resp.data;
             resp.data = NULL;
             status = R_SUCCESS;
             goto cleanup;
         }
-
         retry_count++;
         fprintf(stderr, "Network error: %s (attempt %d/%d)\n",
                 curl_easy_strerror(res), retry_count, HTTP_MAX_RETRIES);
-
         if (retry_count < HTTP_MAX_RETRIES) {
             fprintf(stderr, "Retrying in %d seconds...\n", HTTP_RETRY_DELAY_MS / 1000);
             usleep(HTTP_RETRY_DELAY_MS * 1000);
         }
     }
-
     status = R_ERROR_HTTP_TIMEOUT;
-
 cleanup:
     if (headers) curl_slist_free_all(headers);
     if (curl) curl_easy_cleanup(curl);
     free(resp.data);
-
     return status;
 }
-
 r_status_t http_post_simple(const char *url, const char *bearer_token,
                             const char *data, char **response) {
     http_client_handle client = http_client_create(bearer_token);
     if (!client) return R_ERROR_OUT_OF_MEMORY;
-
     r_status_t status = http_post(client, url, data, response);
     http_client_destroy(client);
     return status;
 }
-
 r_status_t http_get_simple(const char *url, const char *bearer_token, char **response) {
     http_client_handle client = http_client_create(bearer_token);
     if (!client) return R_ERROR_OUT_OF_MEMORY;
-
     http_client_set_show_spinner(client, false);
     r_status_t status = http_get(client, url, response);
     http_client_destroy(client);

src/json_repair.c

@@ -1,42 +1,35 @@
 // retoor <retoor@molodetz.nl>
-
 #include "json_repair.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>
 #include <ctype.h>
-
 static char *strip_comments(const char *src) {
     if (!src) return NULL;
     size_t len = strlen(src);
     char *result = malloc(len + 1);
     if (!result) return NULL;
-
     char *dst = result;
     const char *p = src;
     bool in_string = false;
     bool escaped = false;
-
     while (*p) {
         if (escaped) {
             *dst++ = *p++;
             escaped = false;
             continue;
         }
-
         if (*p == '\\') {
             *dst++ = *p++;
             escaped = true;
             continue;
         }
-
         if (*p == '"') {
             in_string = !in_string;
             *dst++ = *p++;
             continue;
         }
-
         if (!in_string) {
             if (*p == '/' && *(p + 1) == '/') {
                 while (*p && *p != '\n') p++;
@@ -53,25 +46,21 @@ static char *strip_comments(const char *src) {
                 continue;
             }
         }
-
         *dst++ = *p++;
     }
     *dst = '\0';
     return result;
 }
-
 static char *normalize_quotes(const char *src) {
     if (!src) return NULL;
     size_t len = strlen(src);
     // Over-allocate because single quotes might be replaced by double quotes + escaping
     char *result = malloc(len * 2 + 1);
     if (!result) return NULL;
-
     char *dst = result;
     const char *p = src;
     bool in_double_string = false;
     bool escaped = false;
-
     while (*p) {
         // Smart quote replacement
         if ((unsigned char)*p == 0xE2 && (unsigned char)*(p+1) == 0x80) {
@@ -86,25 +75,21 @@ static char *normalize_quotes(const char *src) {
                 continue;
             }
         }
-
         if (escaped) {
             *dst++ = *p++;
             escaped = false;
             continue;
         }
-
         if (*p == '\\') {
             *dst++ = *p++;
             escaped = true;
             continue;
         }
-
         if (*p == '"') {
             in_double_string = !in_double_string;
             *dst++ = *p++;
             continue;
         }
-
         if (!in_double_string && *p == '\'') {
             // Heuristic: convert '...' to "..."
             *dst++ = '"';
@@ -127,24 +112,20 @@ static char *normalize_quotes(const char *src) {
             }
             continue;
         }
-
         *dst++ = *p++;
     }
     *dst = '\0';
     return result;
 }
-
 static char *remove_trailing_commas(const char *src) {
     if (!src) return NULL;
     size_t len = strlen(src);
     char *result = malloc(len + 1);
     if (!result) return NULL;
-
     char *dst = result;
     const char *p = src;
     bool in_string = false;
     bool escaped = false;
-
     while (*p) {
         if (escaped) {
             *dst++ = *p++;
@@ -161,7 +142,6 @@ static char *remove_trailing_commas(const char *src) {
             *dst++ = *p++;
             continue;
         }
-
         if (!in_string && *p == ',') {
             // Check if next non-ws char is ] or }
             const char *next = p + 1;
@@ -176,18 +156,15 @@ static char *remove_trailing_commas(const char *src) {
     *dst = '\0';
     return result;
 }
-
 static char *quote_unquoted_keys(const char *src) {
     if (!src) return NULL;
     size_t len = strlen(src);
     char *result = malloc(len * 2 + 1);
     if (!result) return NULL;
-
     char *dst = result;
     const char *p = src;
     bool in_string = false;
     bool escaped = false;
-
     while (*p) {
         if (escaped) {
             *dst++ = *p++;
@@ -204,7 +181,6 @@ static char *quote_unquoted_keys(const char *src) {
             *dst++ = *p++;
             continue;
         }
-
         if (!in_string && (isalnum((unsigned char)*p) || *p == '_' || *p == '-')) {
             // Potential unquoted key?
             // A key usually follows '{' or ',' and is followed by ':'
@@ -234,13 +210,11 @@ static char *quote_unquoted_keys(const char *src) {
     *dst = '\0';
     return result;
 }
-
 static char *balance_brackets(const char *src) {
     if (!src) return NULL;
     size_t len = strlen(src);
     char *result = malloc(len + 1024);
     if (!result) return NULL;
-
     char stack[1024];
     int top = 0;
     
@@ -248,7 +222,6 @@ static char *balance_brackets(const char *src) {
     const char *p = src;
     bool in_string = false;
     bool escaped = false;
-
     while (*p) {
         if (escaped) {
             *dst++ = *p++;
@@ -265,7 +238,6 @@ static char *balance_brackets(const char *src) {
             *dst++ = *p++;
             continue;
         }
-
         if (!in_string) {
             if (*p == '{' || *p == '[') {
                 if (top < 1024) stack[top++] = *p;
@@ -284,7 +256,6 @@ static char *balance_brackets(const char *src) {
         }
         *dst++ = *p++;
     }
-
     while (top > 0) {
         char opener = stack[--top];
         *dst++ = (opener == '{') ? '}' : ']';
@@ -292,18 +263,15 @@ static char *balance_brackets(const char *src) {
     *dst = '\0';
     return result;
 }
-
 static char *compact_json(const char *src) {
     if (!src) return NULL;
     size_t len = strlen(src);
     char *result = malloc(len + 1);
     if (!result) return NULL;
-
     char *dst = result;
     const char *p = src;
     bool in_string = false;
     bool escaped = false;
-
     while (*p) {
         if (escaped) {
             *dst++ = *p++;
@@ -320,7 +288,6 @@ static char *compact_json(const char *src) {
             *dst++ = *p++;
             continue;
         }
-
         if (!in_string && isspace((unsigned char)*p)) {
             p++;
             continue;
@@ -330,15 +297,12 @@ static char *compact_json(const char *src) {
     *dst = '\0';
     return result;
 }
-
 char *json_repair_string(const char *src) {
     if (!src) return NULL;
-
     // Find the first occurrence of { or [
     const char *start_ptr = src;
     while (*start_ptr && *start_ptr != '{' && *start_ptr != '[') start_ptr++;
     if (!*start_ptr) return strdup(src); // No JSON structure found, return as is
-
     char *s1 = strip_comments(start_ptr);
     char *s2 = normalize_quotes(s1);
     free(s1);
@@ -348,7 +312,6 @@ char *json_repair_string(const char *src) {
     free(s3);
     char *s5 = balance_brackets(s4);
     free(s4);
-
     // Heuristic: truncate after the first complete object/array
     int depth = 0;
     bool in_str = false;
@@ -370,9 +333,7 @@ char *json_repair_string(const char *src) {
         }
         p++;
     }
-
     char *s6 = compact_json(s5);
     free(s5);
-
     return s6;
 }

src/main.c

@@ -1,16 +1,14 @@
 // retoor <retoor@molodetz.nl>
-
 #include "agent.h"
 #include "db.h"
 #include "http_client.h"
 #include "r_config.h"
 #include "r_error.h"
 #include "tool.h"
-
 #include "line.h"
 #include "markdown.h"
 #include "utils.h"
-
+#include <curl/curl.h>
 #include <json-c/json.h>
 #include <locale.h>
 #include <signal.h>
@@ -20,18 +18,14 @@
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
-
 static volatile sig_atomic_t sigint_count = 0;
 static time_t first_sigint_time = 0;
 static bool syntax_highlight_enabled = true;
 static bool api_mode = false;
-
 static db_handle global_db = NULL;
 static messages_handle global_messages = NULL;
-
 extern tool_registry_t *tools_get_registry(void);
 extern void tools_registry_shutdown(void);
-
 static bool include_file(const char *path);
 static char *get_prompt_from_stdin(char *prompt);
 static char *get_prompt_from_args(int argc, char **argv);
@@ -40,12 +34,10 @@ static void repl(void);
 static void init(void);
 static void cleanup(void);
 static void handle_sigint(int sig);
-
 static char *get_env_string(void) {
   FILE *fp = popen("env", "r");
   if (!fp)
     return NULL;
-
   size_t buffer_size = 1024;
   size_t total_size = 0;
   char *output = malloc(buffer_size);
@@ -53,7 +45,6 @@ static char *get_env_string(void) {
     pclose(fp);
     return NULL;
   }
-
   size_t bytes_read;
   while ((bytes_read = fread(output + total_size, 1, buffer_size - total_size,
                              fp)) > 0) {
@@ -69,12 +60,10 @@ static char *get_env_string(void) {
       output = temp;
     }
   }
-
   output[total_size] = '\0';
   pclose(fp);
   return output;
 }
-
 static char *get_prompt_from_stdin(char *prompt) {
   int index = 0;
   int c;
@@ -84,10 +73,8 @@ static char *get_prompt_from_stdin(char *prompt) {
   prompt[index] = '\0';
   return prompt;
 }
-
 static char *get_prompt_from_args(int argc, char **argv) {
   r_config_handle cfg = r_config_get_instance();
-
   char *prompt = malloc(10 * 1024 * 1024 + 1);
   char *system_msg = malloc(1024 * 1024);
   if (!prompt || !system_msg) {
@@ -95,10 +82,8 @@ static char *get_prompt_from_args(int argc, char **argv) {
     free(system_msg);
     return NULL;
   }
-
   system_msg[0] = '\0';
   bool get_from_stdin = false;
-
   for (int i = 1; i < argc; i++) {
     if (strcmp(argv[i], "--stdin") == 0) {
       fprintf(stderr, "Reading from stdin.\n");
@@ -130,7 +115,6 @@ static char *get_prompt_from_args(int argc, char **argv) {
       strcat(system_msg, (i < argc - 1) ? " " : ".");
     }
   }
-
   if (get_from_stdin) {
     if (*system_msg && global_messages) {
       messages_add(global_messages, "system", system_msg);
@@ -141,14 +125,12 @@ static char *get_prompt_from_args(int argc, char **argv) {
     free(prompt);
     prompt = system_msg;
   }
-
   if (!*prompt) {
     free(prompt);
     return NULL;
   }
   return prompt;
 }
-
 static bool try_prompt(int argc, char *argv[]) {
   char *prompt = get_prompt_from_args(argc, argv);
   if (prompt) {
@@ -165,31 +147,25 @@ static bool try_prompt(int argc, char *argv[]) {
   }
   return false;
 }
-
 static bool include_file(const char *path) {
   char *file_content = read_file(path);
   if (!file_content)
     return false;
-
   if (global_messages) {
     messages_add(global_messages, "system", file_content);
   }
   free(file_content);
   return true;
 }
-
 static void repl(void) {
   r_config_handle cfg = r_config_get_instance();
   tool_registry_t *tools = tools_get_registry();
-
   line_init();
   char *line = NULL;
-
   while (true) {
     line = line_read("> ");
     if (!line || !*line)
       continue;
-
     if (!strncmp(line, "!dump", 5)) {
       char *json = messages_to_string(global_messages);
       if (json) {
@@ -198,7 +174,6 @@ static void repl(void) {
       }
       continue;
     }
-
     if (!strncmp(line, "!clear", 6)) {
       messages_clear(global_messages);
       fprintf(stderr, "Session cleared.\n");
@@ -208,6 +183,14 @@ static void repl(void) {
       printf("Session: %s\n", messages_get_session_id(global_messages));
       continue;
     }
+    if (!strncmp(line, "!new", 4)) {
+      messages_clear(global_messages);
+      char session_id[64];
+      snprintf(session_id, sizeof(session_id), "session-%d-%ld", getpid(), (long)time(NULL));
+      messages_set_session_id(global_messages, session_id);
+      fprintf(stderr, "New session: %s\n", session_id);
+      continue;
+    }
     if (!strncmp(line, "!verbose", 8)) {
       bool verbose = !r_config_is_verbose(cfg);
       r_config_set_verbose(cfg, verbose);
@@ -248,7 +231,6 @@ static void repl(void) {
     if (!strncmp(line, "exit", 4)) {
       exit(0);
     }
-
     while (line && *line != '\n') {
       char *response = agent_chat(line, global_messages);
       if (response) {
@@ -262,24 +244,19 @@ static void repl(void) {
     }
   }
 }
-
 static void init(void) {
+  curl_global_init(CURL_GLOBAL_DEFAULT);
   setbuf(stdout, NULL);
   line_init();
-
   r_config_handle cfg = r_config_get_instance();
-
   global_db = db_open(NULL);
   global_messages = messages_create(r_config_get_session_id(cfg));
-
   char *schema = db_get_schema(global_db);
   char payload[1024 * 1024] = {0};
-
   time_t now = time(NULL);
   struct tm *tm_info = localtime(&now);
   char datetime[64];
   strftime(datetime, sizeof(datetime), "%Y-%m-%d %H:%M:%S %Z", tm_info);
-
   char cwd[4096];
   if (!getcwd(cwd, sizeof(cwd))) {
     strcpy(cwd, "unknown");
@@ -293,17 +270,37 @@ static void init(void) {
       "task, "
       "select and execute tools when needed, observe results, and continue "
       "until the goal is achieved.\n\n"
-      "## Reasoning Pattern (ReAct)\n"
+      "## The Enterprise Pyramid (Rigid Hierarchy)\n"
-      "For EVERY task, you MUST follow this sequence:\n"
+      "You are the **Executive Agent (Apex)**. You MUST enforce a strict top-down "
-      "1. Plan: Break the task into logical sub-tasks. DECIDE which specialized "
+      "Chain of Command:\n"
-      "agents to spawn. CREATE a visible CHECKLIST of all deliverables (files, "
+      "- **Executive (Apex)**: Final arbiter. Owns the Strategic Blueprint. You "
-      "features, pages).\n"
+      "never code or research directly. You evaluate sub-agent depth.\n"
-      "2. Execute: Spawn agents or use tools. INTEGRATE their results "
+      "- **Department Heads (Managers)**: Create detailed 'Task Packs'. "
-      "immediately. Update your checklist as you progress.\n"
+      "Synthesize sub-agent outputs into 'Department Reports'.\n"
-      "3. Verify: Check EVERY item on your checklist. Run code, check file "
+      "- **Workers (Base)**: Execute atomic tasks. Report literal word counts "
-      "existence, verify links. If an item is missing, go back to Execute.\n"
+      "and file sizes upward.\n\n"
-      "4. Conclude: Only after ALL checklist items are verified, provide your "
+      "### Bureaucratic Protocols (MANDATORY)\n"
-      "final response.\n\n"
+      "1. **Strategic Blueprint**: Your very first turn MUST output a "
+      "blueprint: Mission, Departments Involved, and a 10-step Checklist.\n"
+      "2. **Sequential Handover**: You are FORBIDDEN from spawning a Developer "
+      "until the Researcher has delivered a minimum of 1000 words of "
+      "documented facts to `PROJECT_KNOWLEDGE.md`.\n"
+      "3. **Content Depth Guardrail**: For 'Huge' projects, every page MUST "
+      "contain deep, researched info. Placeholder text (e.g., 'Coming soon', "
+      "'Introduction here') is a failure. You MUST use 'read_file' to audit "
+      "sub-agent work before concluding.\n"
+      "4. **Global Task Registry (GTR)**: Query GTR for every sub-task. If a "
+      "similar task exists, use its result summary. DUPLICATION IS FORBIDDEN.\n"
+      "5. **Fan-Out Architecture (Research)**: Manager calls `web_search` to get "
+      "URLs, then uses `research_dispatcher` to queue them. Workers use "
+      "`fetch_and_scrape` for individual URLs. If a Worker finds new links, it "
+      "MUST use `suggest_subtask` to escalate. NEVER follow rabbit holes "
+      "yourself.\n\n"
+      "### Shared Memory & Data Sharing\n"
+      "- Every turn, you MUST update `PROJECT_KNOWLEDGE.md` with new findings.\n"
+      "- All sub-agents MUST receive the full content of `PROJECT_KNOWLEDGE.md` "
+      "to ensure a shared organizational history.\n\n"
+      "## Multi-Agent Orchestration (MANDATORY)\n"
       "## Project Scale Rules\n"
       "- HUGE PROJECTS: If a 'huge' or 'multi-page' project is requested, "
       "delivering a single file is FORBIDDEN. You MUST create a directory "
@@ -372,23 +369,18 @@ static void init(void) {
       datetime, cwd, schema ? schema : "{}");
   free(schema);
   fprintf(stderr, "Loading...");
-
   if (global_messages) {
     messages_add(global_messages, "system", payload);
   }
-
   const char *env_system_msg = r_config_get_system_message(cfg);
   if (env_system_msg && *env_system_msg && global_messages) {
     messages_add(global_messages, "system", env_system_msg);
   }
-
   if (!include_file(".rcontext.txt")) {
     include_file("~/.rcontext.txt");
   }
-
   fprintf(stderr, "\r                          \r");
 }
-
 static void cleanup(void) {
   if (global_messages) {
     messages_destroy(global_messages);
@@ -401,7 +393,6 @@ static void cleanup(void) {
   tools_registry_shutdown();
   r_config_destroy();
 }
-
 static void handle_sigint(int sig) {
   (void)sig;
   time_t current_time = time(NULL);
@@ -419,10 +410,8 @@ static void handle_sigint(int sig) {
     }
   }
 }
-
 static void parse_session_arg(int argc, char *argv[]) {
   r_config_handle cfg = r_config_get_instance();
-
   for (int i = 1; i < argc; i++) {
     if (strncmp(argv[i], "--session=", 10) == 0) {
       const char *name = argv[i] + 10;
@@ -443,26 +432,20 @@ static void parse_session_arg(int argc, char *argv[]) {
     }
   }
 }
-
 int main(int argc, char *argv[]) {
   signal(SIGINT, handle_sigint);
   atexit(cleanup);
-
   parse_session_arg(argc, argv);
   init();
-
   char *env_string = get_env_string();
   if (env_string && *env_string && global_messages) {
     messages_add(global_messages, "system", env_string);
     free(env_string);
   }
-
   messages_load(global_messages);
-
   if (try_prompt(argc, argv)) {
     return 0;
   }
-
   repl();
   return 0;
 }

src/markdown.c

@@ -1,25 +1,20 @@
 // retoor <retoor@molodetz.nl>
-
 #include "markdown.h"
 #include <ctype.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
-
 // --- ANSI Escape Codes ---
 #define RESET "\033[0m"
 #define BOLD "\033[1m"
 #define ITALIC "\033[3m"
 #define STRIKETHROUGH "\033[9m"
-
 #define FG_YELLOW "\033[33m"
 #define FG_BLUE "\033[34m"
 #define FG_CYAN "\033[36m"
 #define FG_MAGENTA "\033[35m"
-
 #define BG_YELLOW_FG_BLACK "\033[43;30m"
-
 /**
  * @brief Checks if a given word is a programming language keyword.
  */
@@ -32,18 +27,15 @@ static int is_keyword(const char *word) {
       "implements", "new", "synchronized", "var", "switch", "case", "break", "continue",
       "namespace", "template", "typename", "virtual", "override", "friend", "package", "func", "type", "go", "defer", "select",
       "then", "elif", "fi", "esac", "do", "done", "using"};
-
   for (size_t i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) {
     if (strcmp(word, keywords[i]) == 0) return 1;
   }
   return 0;
 }
-
 void highlight_code(const char *code) {
   const char *ptr = code;
   char buffer[4096];
   size_t index = 0;
-
   while (*ptr) {
     if (isalpha((unsigned char)*ptr) || *ptr == '_') {
       while (isalnum((unsigned char)*ptr) || *ptr == '_') {
@@ -68,11 +60,9 @@ void highlight_code(const char *code) {
     }
   }
 }
-
 void parse_markdown_to_ansi(const char *markdown) {
   const char *ptr = markdown;
   bool is_start_of_line = true;
-
   while (*ptr) {
     if (is_start_of_line && strncmp(ptr, "```", 3) == 0) {
       ptr += 3;
@@ -97,7 +87,6 @@ void parse_markdown_to_ansi(const char *markdown) {
         break;
       }
     }
-
     if (is_start_of_line) {
       const char *line_start_ptr = ptr;
       int indent_level = 0;
@@ -133,7 +122,6 @@ void parse_markdown_to_ansi(const char *markdown) {
         is_start_of_line = true; continue;
       }
     }
-
     if (strncmp(ptr, "***", 3) == 0 || strncmp(ptr, "___", 3) == 0) {
       const char *marker = strncmp(ptr, "***", 3) == 0 ? "***" : "___";
       printf(BOLD ITALIC); ptr += 3;
@@ -184,7 +172,6 @@ void parse_markdown_to_ansi(const char *markdown) {
         }
       }
     }
-
     if (*ptr == '\n') is_start_of_line = true;
     else if (!isspace((unsigned char)*ptr)) is_start_of_line = false;
     putchar(*ptr);

src/messages.c

@@ -1,5 +1,4 @@
 // retoor <retoor@molodetz.nl>
-
 #include "messages.h"
 #include "db.h"
 #include <ctype.h>
@@ -7,21 +6,18 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-
 #define MAX_CONTENT_LENGTH 1048570
 #define MAX_TOOL_RESULT_LENGTH 104000
-
+#define SESSION_EXPIRY_SECONDS 86400
 struct messages_t {
     struct json_object *array;
     char *session_id;
     db_handle db;
     bool loaded;
 };
-
 static bool is_valid_session_id(const char *session_id) {
     if (!session_id || !*session_id) return false;
     if (strlen(session_id) > 200) return false;
-
     for (const char *p = session_id; *p; p++) {
         if (!isalnum((unsigned char)*p) && *p != '-' && *p != '_' && *p != '.') {
             return false;
@@ -29,42 +25,60 @@ static bool is_valid_session_id(const char *session_id) {
     }
     return true;
 }
-
+static long long get_ppid_starttime(pid_t ppid) {
+    char proc_path[64];
+    snprintf(proc_path, sizeof(proc_path), "/proc/%d/stat", ppid);
+    FILE *fp = fopen(proc_path, "r");
+    if (!fp) return -1;
+    char buf[1024];
+    size_t nread = fread(buf, 1, sizeof(buf) - 1, fp);
+    fclose(fp);
+    if (nread == 0) return -1;
+    buf[nread] = '\0';
+    char *close_paren = strrchr(buf, ')');
+    if (!close_paren) return -1;
+    char *p = close_paren + 2;
+    int field = 0;
+    while (*p && field < 19) {
+        if (*p == ' ') field++;
+        p++;
+    }
+    if (field < 19) return -1;
+    return strtoll(p, NULL, 10);
+}
 static char *generate_default_session_id(void) {
-    char *session_id = malloc(32);
+    char *session_id = malloc(64);
     if (!session_id) return NULL;
-
+    pid_t ppid = getppid();
-    snprintf(session_id, 32, "session-%d", getppid());
+    long long starttime = get_ppid_starttime(ppid);
+    if (starttime >= 0) {
+        snprintf(session_id, 64, "session-%d-%lld", ppid, starttime);
+    } else {
+        snprintf(session_id, 64, "session-%d", ppid);
+    }
     return session_id;
 }
-
 messages_handle messages_create(const char *session_id) {
     struct messages_t *msgs = calloc(1, sizeof(struct messages_t));
     if (!msgs) return NULL;
-
     msgs->array = json_object_new_array();
     if (!msgs->array) {
         free(msgs);
         return NULL;
     }
-
     if (session_id && is_valid_session_id(session_id)) {
         msgs->session_id = strdup(session_id);
     } else {
         msgs->session_id = generate_default_session_id();
     }
-
     if (!msgs->session_id) {
         json_object_put(msgs->array);
         free(msgs);
         return NULL;
     }
-
     msgs->db = db_open(NULL);
-
     return msgs;
 }
-
 void messages_destroy(messages_handle msgs) {
     if (!msgs) return;
     if (msgs->array) json_object_put(msgs->array);
@@ -72,150 +86,118 @@ void messages_destroy(messages_handle msgs) {
     free(msgs->session_id);
     free(msgs);
 }
-
 r_status_t messages_set_session_id(messages_handle msgs, const char *session_id) {
     if (!msgs || !is_valid_session_id(session_id)) return R_ERROR_INVALID_ARG;
-
     free(msgs->session_id);
     msgs->session_id = strdup(session_id);
     msgs->loaded = false;
     return msgs->session_id ? R_SUCCESS : R_ERROR_OUT_OF_MEMORY;
 }
-
 const char *messages_get_session_id(messages_handle msgs) {
     return msgs ? msgs->session_id : NULL;
 }
-
 r_status_t messages_add(messages_handle msgs, const char *role, const char *content) {
     if (!msgs || !msgs->array || !role) return R_ERROR_INVALID_ARG;
-
     struct json_object *message = json_object_new_object();
     if (!message) return R_ERROR_OUT_OF_MEMORY;
-
     json_object_object_add(message, "role", json_object_new_string(role));
-
     if (content) {
         size_t len = strlen(content);
         if (len > MAX_CONTENT_LENGTH) len = MAX_CONTENT_LENGTH;
         json_object_object_add(message, "content",
             json_object_new_string_len(content, (int)len));
     }
-
     json_object_array_add(msgs->array, message);
-
     if (strcmp(role, "system") != 0) {
         messages_save(msgs);
     }
-
     return R_SUCCESS;
 }
-
 r_status_t messages_add_object(messages_handle msgs, struct json_object *message) {
     if (!msgs || !msgs->array || !message) return R_ERROR_INVALID_ARG;
-
     json_object_array_add(msgs->array, message);
     messages_save(msgs);
     return R_SUCCESS;
 }
-
 r_status_t messages_add_tool_call(messages_handle msgs, struct json_object *message) {
     if (!msgs || !msgs->array || !message) return R_ERROR_INVALID_ARG;
-
     json_object_array_add(msgs->array, message);
     messages_save(msgs);
     return R_SUCCESS;
 }
-
 r_status_t messages_add_tool_result(messages_handle msgs, const char *tool_call_id, const char *result) {
     if (!msgs || !msgs->array || !tool_call_id || !result) return R_ERROR_INVALID_ARG;
-
     struct json_object *message = json_object_new_object();
     if (!message) return R_ERROR_OUT_OF_MEMORY;
-
     json_object_object_add(message, "tool_call_id", json_object_new_string(tool_call_id));
-
     size_t len = strlen(result);
     if (len > MAX_TOOL_RESULT_LENGTH) len = MAX_TOOL_RESULT_LENGTH;
     json_object_object_add(message, "tool_result",
         json_object_new_string_len(result, (int)len));
-
     json_object_array_add(msgs->array, message);
     messages_save(msgs);
     return R_SUCCESS;
 }
-
 r_status_t messages_remove_last(messages_handle msgs) {
     if (!msgs || !msgs->array) return R_ERROR_INVALID_ARG;
-
     int size = json_object_array_length(msgs->array);
     if (size == 0) return R_ERROR_NOT_FOUND;
-
     json_object_array_del_idx(msgs->array, size - 1, 1);
     messages_save(msgs);
     return R_SUCCESS;
 }
-
 r_status_t messages_remove_range(messages_handle msgs, int start, int count) {
     if (!msgs || !msgs->array) return R_ERROR_INVALID_ARG;
     int size = json_object_array_length(msgs->array);
     if (start < 0 || start >= size || count < 0) return R_ERROR_INVALID_ARG;
     if (start + count > size) count = size - start;
-
     json_object_array_del_idx(msgs->array, start, count);
     messages_save(msgs);
     return R_SUCCESS;
 }
-
 r_status_t messages_clear(messages_handle msgs) {
     if (!msgs) return R_ERROR_INVALID_ARG;
-
     if (msgs->array) json_object_put(msgs->array);
     msgs->array = json_object_new_array();
     if (!msgs->array) return R_ERROR_OUT_OF_MEMORY;
-
     messages_save(msgs);
     return R_SUCCESS;
 }
-
 r_status_t messages_save(messages_handle msgs) {
     if (!msgs || !msgs->array || !msgs->db) return R_ERROR_INVALID_ARG;
-
     char key[512];
     snprintf(key, sizeof(key), "session:%s", msgs->session_id);
-
     const char *json_str = json_object_to_json_string_ext(msgs->array, JSON_C_TO_STRING_PLAIN);
     if (!json_str) return R_ERROR_OUT_OF_MEMORY;
-
     return db_save_conversation(msgs->db, key, json_str);
 }
-
 r_status_t messages_load(messages_handle msgs) {
     if (!msgs || !msgs->db) return R_ERROR_INVALID_ARG;
     if (msgs->loaded) return R_SUCCESS;
-
     char key[512];
     snprintf(key, sizeof(key), "session:%s", msgs->session_id);
-
+    long long age = db_get_conversation_age(msgs->db, key);
+    if (age > SESSION_EXPIRY_SECONDS) {
+        db_delete_conversation(msgs->db, key);
+        msgs->loaded = true;
+        return R_ERROR_NOT_FOUND;
+    }
     char *data = NULL;
     r_status_t status = db_load_conversation(msgs->db, key, &data);
     if (status != R_SUCCESS || !data) {
         if (status == R_SUCCESS) msgs->loaded = true;
         return status == R_SUCCESS ? R_ERROR_NOT_FOUND : status;
     }
-
     struct json_object *loaded = json_tokener_parse(data);
     free(data);
-
     if (!loaded || !json_object_is_type(loaded, json_type_array)) {
         if (loaded) json_object_put(loaded);
         return R_ERROR_PARSE;
     }
-
     int len = json_object_array_length(loaded);
     for (int i = 0; i < len; i++) {
         struct json_object *msg = json_object_array_get_idx(loaded, i);
         struct json_object *role_obj;
-
         if (json_object_object_get_ex(msg, "role", &role_obj)) {
             const char *role = json_object_get_string(role_obj);
             if (role && strcmp(role, "system") != 0) {
@@ -225,43 +207,35 @@ r_status_t messages_load(messages_handle msgs) {
             json_object_array_add(msgs->array, json_object_get(msg));
         }
     }
-
     json_object_put(loaded);
     msgs->loaded = true;
     return R_SUCCESS;
 }
-
 struct json_object *messages_get_object(messages_handle msgs, int index) {
     if (!msgs || !msgs->array) return NULL;
     return json_object_array_get_idx(msgs->array, index);
 }
-
 r_status_t messages_replace_at(messages_handle msgs, int index, struct json_object *message) {
     if (!msgs || !msgs->array || !message) return R_ERROR_INVALID_ARG;
     int size = json_object_array_length(msgs->array);
     if (index < 0 || index >= size) return R_ERROR_INVALID_ARG;
-
     // json-c doesn't have a direct 'replace' for array by index that handles memory easily
     // We'll use json_object_array_put_idx which replaces and puts the old object
     json_object_array_put_idx(msgs->array, index, message);
     messages_save(msgs);
     return R_SUCCESS;
 }
-
 struct json_object *messages_to_json(messages_handle msgs) {
     return msgs ? msgs->array : NULL;
 }
-
 char *messages_to_string(messages_handle msgs) {
     if (!msgs || !msgs->array) return NULL;
     return strdup(json_object_to_json_string_ext(msgs->array, JSON_C_TO_STRING_PRETTY));
 }
-
 char *messages_to_json_string(messages_handle msgs) {
     if (!msgs || !msgs->array) return NULL;
     return strdup(json_object_to_json_string_ext(msgs->array, JSON_C_TO_STRING_PLAIN));
 }
-
 int messages_count(messages_handle msgs) {
     if (!msgs || !msgs->array) return 0;
     return json_object_array_length(msgs->array);

src/python_repair.c

@@ -1,5 +1,4 @@
 // retoor <retoor@molodetz.nl>
-
 #include "python_repair.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ -7,12 +6,9 @@
 #include <stdbool.h>
 #include <ctype.h>
 #include <math.h>
-
 #define INDENT_WIDTH 4
-
 static char *dedent_code(const char *src) {
     if (!src || !*src) return strdup("");
-
     int min_indent = -1;
     const char *line = src;
     while (line && *line) {
@@ -26,9 +22,7 @@ static char *dedent_code(const char *src) {
         line = strchr(line, '\n');
         if (line) line++;
     }
-
     if (min_indent <= 0) return strdup(src);
-
     size_t src_len = strlen(src);
     char *result = malloc(src_len + 1);
     if (!result) return strdup(src);
@@ -56,19 +50,16 @@ static char *dedent_code(const char *src) {
     *dst = '\0';
     return result;
 }
-
 static char *normalize_indentation(const char *src) {
     if (!src) return NULL;
     size_t src_len = strlen(src);
     char *result = malloc(src_len * 2 + 1); // Extra space for normalized indents
     if (!result) return NULL;
-
     char *dst = result;
     const char *line = src;
     while (line && *line) {
         const char *next_line = strchr(line, '\n');
         size_t line_len = next_line ? (size_t)(next_line - line) : strlen(line);
-
         // Check if line is empty or just whitespace
         bool is_empty = true;
         for (size_t i = 0; i < line_len; i++) {
@@ -77,7 +68,6 @@ static char *normalize_indentation(const char *src) {
                 break;
             }
         }
-
         if (is_empty) {
             if (next_line) {
                 *dst++ = '\n';
@@ -87,7 +77,6 @@ static char *normalize_indentation(const char *src) {
             }
             continue;
         }
-
         // Calculate current leading indent
         int leading_spaces = 0;
         const char *content_ptr = line;
@@ -99,17 +88,14 @@ static char *normalize_indentation(const char *src) {
             }
             content_ptr++;
         }
-
         // Round to nearest INDENT_WIDTH
         int normalized_level = (leading_spaces + INDENT_WIDTH / 2) / INDENT_WIDTH;
         int target_spaces = normalized_level * INDENT_WIDTH;
-
         for (int i = 0; i < target_spaces; i++) *dst++ = ' ';
         
         size_t content_len = (size_t)((line + line_len) - content_ptr);
         memcpy(dst, content_ptr, content_len);
         dst += content_len;
-
         if (next_line) {
             *dst++ = '\n';
             line = next_line + 1;
@@ -120,27 +106,22 @@ static char *normalize_indentation(const char *src) {
     *dst = '\0';
     return result;
 }
-
 static char *repair_strings_and_brackets(const char *src) {
     if (!src) return NULL;
     size_t src_len = strlen(src);
     char *result = malloc(src_len + 2048); // Buffer for extra quotes/brackets
     if (!result) return NULL;
-
     char *dst = result;
     const char *p = src;
     
     char bracket_stack[1024];
     int stack_ptr = 0;
-
     bool in_string = false;
     char string_quote = 0;
     int quote_type = 0; // 1 for single, 3 for triple
     bool escaped = false;
-
     while (*p) {
         char ch = *p;
-
         if (!in_string) {
             if (ch == '#') {
                 // Comment, copy until newline
@@ -199,7 +180,6 @@ static char *repair_strings_and_brackets(const char *src) {
         }
         *dst++ = *p++;
     }
-
     if (in_string) {
         if (quote_type == 3) {
             *dst++ = string_quote; *dst++ = string_quote; *dst++ = string_quote;
@@ -207,7 +187,6 @@ static char *repair_strings_and_brackets(const char *src) {
             *dst++ = string_quote;
         }
     }
-
     // Balance brackets
     while (stack_ptr > 0) {
         char opener = bracket_stack[--stack_ptr];
@@ -215,29 +194,24 @@ static char *repair_strings_and_brackets(const char *src) {
         else if (opener == '[') *dst++ = ']';
         else if (opener == '{') *dst++ = '}';
     }
-
     *dst = '\0';
     return result;
 }
-
 static char *add_missing_passes(const char *src) {
     if (!src) return NULL;
     size_t src_len = strlen(src);
     char *result = malloc(src_len * 2 + 1);
     if (!result) return NULL;
-
     char *dst = result;
     const char *line = src;
     
     while (line && *line) {
         const char *next_line = strchr(line, '\n');
         size_t line_len = next_line ? (size_t)(next_line - line) : strlen(line);
-
         // Copy current line
         memcpy(dst, line, line_len);
         dst += line_len;
         if (next_line) *dst++ = '\n';
-
         // Check if line ends with ':' (ignoring comments/whitespace)
         const char *p = line + line_len - 1;
         while (p >= line && isspace((unsigned char)*p)) p--;
@@ -269,7 +243,6 @@ static char *add_missing_passes(const char *src) {
                         else current_indent++;
                         line_p++;
                     }
-
                     int line_look_indent = 0;
                     const char *look_p = lookahead;
                     while (look_p < (lookahead + look_len) && (*look_p == ' ' || *look_p == '\t')) {
@@ -277,7 +250,6 @@ static char *add_missing_passes(const char *src) {
                         else line_look_indent++;
                         look_p++;
                     }
-
                     if (line_look_indent > current_indent) {
                         needs_pass = false;
                     }
@@ -287,7 +259,6 @@ static char *add_missing_passes(const char *src) {
                 if (next_next) lookahead = next_next + 1;
                 else break;
             }
-
             if (needs_pass) {
                 // Find current indent to place 'pass' correctly
                 int current_indent = 0;
@@ -304,18 +275,14 @@ static char *add_missing_passes(const char *src) {
                 dst += 5;
             }
         }
-
         if (next_line) line = next_line + 1;
         else break;
     }
-
     *dst = '\0';
     return result;
 }
-
 char *python_repair_code(const char *src) {
     if (!src) return NULL;
-
     char *s1 = dedent_code(src);
     char *s2 = normalize_indentation(s1);
     free(s1);
@@ -325,6 +292,5 @@ char *python_repair_code(const char *src) {
     
     char *s4 = add_missing_passes(s3);
     free(s3);
-
     return s4;
 }

src/r_config.c

@@ -1,11 +1,9 @@
 // retoor <retoor@molodetz.nl>
-
 #include "r_config.h"
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
 struct r_config_t {
     char *api_url;
     char *models_url;
@@ -20,13 +18,10 @@ struct r_config_t {
     bool use_strict;
     bool verbose;
 };
-
 static struct r_config_t *instance = NULL;
-
 static char *strdup_safe(const char *s) {
     return s ? strdup(s) : NULL;
 }
-
 static bool resolve_env_bool(const char *env_name, bool default_val) {
     const char *val = getenv(env_name);
     if (!val) return default_val;
@@ -34,31 +29,18 @@ static bool resolve_env_bool(const char *env_name, bool default_val) {
     if (!strcmp(val, "false") || !strcmp(val, "0")) return false;
     return default_val;
 }
-
 static const char *resolve_api_key(void) {
-
     const char * key = getenv("R_KEY");
     if (key && *key) return key;
-
-
-
-
     key = getenv("OPENROUTER_API_KEY");
     if (key && *key) return key;
-
-
-
     key = getenv("OPENAI_API_KEY");
     if (key && *key) return key;
-
-
     return "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";
 }
-
 static bool is_valid_session_id(const char *session_id) {
     if (!session_id || !*session_id) return false;
     if (strlen(session_id) > 255) return false;
-
     for (const char *p = session_id; *p; p++) {
         if (!isalnum((unsigned char)*p) && *p != '-' && *p != '_' && *p != '.') {
             return false;
@@ -66,13 +48,10 @@ static bool is_valid_session_id(const char *session_id) {
     }
     return true;
 }
-
 r_config_handle r_config_get_instance(void) {
     if (instance) return instance;
-
     instance = calloc(1, sizeof(struct r_config_t));
     if (!instance) return NULL;
-
     const char *base_url = getenv("R_BASE_URL");
     if (base_url && *base_url) {
         size_t len = strlen(base_url);
@@ -86,10 +65,8 @@ r_config_handle r_config_get_instance(void) {
         instance->api_url = strdup("https://api.openai.com/v1/chat/completions");
         instance->models_url = strdup("https://api.openai.com/v1/models");
     }
-
     const char *model = getenv("R_MODEL");
     instance->model = strdup(model && *model ? model : "gpt-4o-mini");
-
     instance->api_key = strdup(resolve_api_key());
     instance->db_path = strdup("~/.r.db");
     instance->temperature = 0.1;
@@ -98,19 +75,15 @@ r_config_handle r_config_get_instance(void) {
     instance->use_tools = resolve_env_bool("R_USE_TOOLS", true);
     instance->use_strict = resolve_env_bool("R_USE_STRICT", true);
     instance->verbose = false;
-
     const char *session = getenv("R_SESSION");
     if (session && is_valid_session_id(session)) {
         instance->session_id = strdup(session);
     } else {
         instance->session_id = NULL;
     }
-
     instance->system_message = strdup_safe(getenv("R_SYSTEM_MESSAGE"));
-
     return instance;
 }
-
 void r_config_destroy(void) {
     if (!instance) return;
     free(instance->api_url);
@@ -123,68 +96,53 @@ void r_config_destroy(void) {
     free(instance);
     instance = NULL;
 }
-
 const char *r_config_get_api_url(r_config_handle cfg) {
     return cfg ? cfg->api_url : NULL;
 }
-
 const char *r_config_get_models_url(r_config_handle cfg) {
     return cfg ? cfg->models_url : NULL;
 }
-
 const char *r_config_get_model(r_config_handle cfg) {
     return cfg ? cfg->model : NULL;
 }
-
 void r_config_set_model(r_config_handle cfg, const char *model) {
     if (!cfg || !model) return;
     free(cfg->model);
     cfg->model = strdup(model);
 }
-
 const char *r_config_get_api_key(r_config_handle cfg) {
     return cfg ? cfg->api_key : NULL;
 }
-
 const char *r_config_get_db_path(r_config_handle cfg) {
     return cfg ? cfg->db_path : NULL;
 }
-
 bool r_config_use_tools(r_config_handle cfg) {
     return cfg ? cfg->use_tools : true;
 }
-
 bool r_config_use_strict(r_config_handle cfg) {
     return cfg ? cfg->use_strict : true;
 }
-
 bool r_config_is_verbose(r_config_handle cfg) {
     return cfg ? cfg->verbose : false;
 }
-
 void r_config_set_verbose(r_config_handle cfg, bool verbose) {
     if (cfg) cfg->verbose = verbose;
 }
-
 double r_config_get_temperature(r_config_handle cfg) {
     return cfg ? cfg->temperature : 0.1;
 }
-
 int r_config_get_max_tokens(r_config_handle cfg) {
     return cfg ? cfg->max_tokens : 4096;
 }
-
 const char *r_config_get_session_id(r_config_handle cfg) {
     return cfg ? cfg->session_id : NULL;
 }
-
 bool r_config_set_session_id(r_config_handle cfg, const char *session_id) {
     if (!cfg || !is_valid_session_id(session_id)) return false;
     free(cfg->session_id);
     cfg->session_id = strdup(session_id);
     return cfg->session_id != NULL;
 }
-
 const char *r_config_get_system_message(r_config_handle cfg) {
     return cfg ? cfg->system_message : NULL;
 }

src/r_diff.c

@@ -1,12 +1,10 @@
 // retoor <retoor@molodetz.nl>
-
 #include "r_diff.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
-
 #define COLOR_RED     "\x1b[31m"
 #define COLOR_GREEN   "\x1b[32m"
 #define COLOR_CYAN    "\x1b[36m"
@@ -14,20 +12,16 @@
 #define COLOR_DIM     "\x1b[2m"
 #define COLOR_BG_RED  "\x1b[41;37m"
 #define COLOR_BG_GREEN "\x1b[42;30m"
-
 typedef struct {
     char **lines;
     size_t count;
 } line_set_t;
-
 static line_set_t split_lines(const char *str) {
     line_set_t set = {NULL, 0};
     if (!str || !*str) return set;
-
     char *copy = strdup(str);
     char *p = copy;
     char *line_start = copy;
-
     while (*p) {
         if (*p == '\n') {
             *p = '\0';
@@ -46,12 +40,10 @@ static line_set_t split_lines(const char *str) {
     free(copy);
     return set;
 }
-
 static void free_line_set(line_set_t set) {
     for (size_t i = 0; i < set.count; i++) free(set.lines[i]);
     free(set.lines);
 }
-
 static void print_truncated(const char *str, int width, const char *color) {
     if (width <= 0) return;
     int len = (int)strlen(str);
@@ -67,22 +59,18 @@ static void print_truncated(const char *str, int width, const char *color) {
     
     if (color) printf("%s", COLOR_RESET);
 }
-
 void r_diff_print(const char *path, const char *old_content, const char *new_content) {
     line_set_t old_set = split_lines(old_content);
     line_set_t new_set = split_lines(new_content);
-
     struct winsize w;
     ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
     int term_width = w.ws_col > 0 ? w.ws_col : 120;
     if (term_width < 40) term_width = 40; // Minimum usable width
     int col_width = (term_width - 15) / 2;
     if (col_width < 5) col_width = 5;
-
     printf("\n%s %s CHANGES: %s %s\n", COLOR_CYAN, COLOR_DIM, path, COLOR_RESET);
     printf("%4s %-*s | %4s %-*s\n", "LINE", col_width, " OLD", "LINE", col_width, " NEW");
     printf("%.*s\n", term_width, "--------------------------------------------------------------------------------------------------------------------------------------------");
-
     size_t o = 0, n = 0;
     while (o < old_set.count || n < new_set.count) {
         bool match = false;
@@ -97,7 +85,6 @@ void r_diff_print(const char *path, const char *old_content, const char *new_con
                 match = true;
             }
         }
-
         if (!match) {
             bool found_o_later = false;
             if (o < old_set.count) {
@@ -108,7 +95,6 @@ void r_diff_print(const char *path, const char *old_content, const char *new_con
                     }
                 }
             }
-
             if (found_o_later) {
                 // Line added on NEW side
                 printf("%4s   ", "");
@@ -140,7 +126,6 @@ void r_diff_print(const char *path, const char *old_content, const char *new_con
     }
     printf("\n");
     fflush(stdout);
-
     free_line_set(old_set);
     free_line_set(new_set);
 }

src/r_error.c

@@ -1,7 +1,5 @@
 // retoor <retoor@molodetz.nl>
-
 #include "r_error.h"
-
 static const char *error_messages[] = {
     [R_SUCCESS] = "Success",
     [R_ERROR_INVALID_ARG] = "Invalid argument",
@@ -26,7 +24,6 @@ static const char *error_messages[] = {
     [R_ERROR_SESSION_INVALID] = "Invalid session name",
     [R_ERROR_UNKNOWN] = "Unknown error"
 };
-
 const char *r_status_string(r_status_t status) {
     if (status < 0 || status > R_ERROR_UNKNOWN) {
         return error_messages[R_ERROR_UNKNOWN];

src/tool_registry.c

@@ -1,17 +1,14 @@
 // retoor <retoor@molodetz.nl>
-
 #include "tool.h"
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <pthread.h>
-
 typedef struct {
     tool_t *tool;
     struct json_object *args;
     char *output;
 } tool_thread_args_t;
-
 static void *tool_thread_func(void *ptr) {
     tool_thread_args_t *args = (tool_thread_args_t *)ptr;
     if (args->tool->vtable->execute) {
@@ -19,11 +16,9 @@ static void *tool_thread_func(void *ptr) {
     }
     return NULL;
 }
-
 tool_registry_t *tool_registry_create(void) {
     tool_registry_t *registry = calloc(1, sizeof(tool_registry_t));
     if (!registry) return NULL;
-
     registry->capacity = 32;
     registry->tools = calloc(registry->capacity, sizeof(tool_t *));
     if (!registry->tools) {
@@ -32,16 +27,13 @@ tool_registry_t *tool_registry_create(void) {
     }
     return registry;
 }
-
 void tool_registry_destroy(tool_registry_t *registry) {
     if (!registry) return;
     free(registry->tools);
     free(registry);
 }
-
 r_status_t tool_registry_register(tool_registry_t *registry, tool_t *tool) {
     if (!registry || !tool) return R_ERROR_INVALID_ARG;
-
     if (registry->count >= registry->capacity) {
         size_t new_capacity = registry->capacity * 2;
         tool_t **new_tools = realloc(registry->tools, new_capacity * sizeof(tool_t *));
@@ -49,14 +41,11 @@ r_status_t tool_registry_register(tool_registry_t *registry, tool_t *tool) {
         registry->tools = new_tools;
         registry->capacity = new_capacity;
     }
-
     registry->tools[registry->count++] = tool;
     return R_SUCCESS;
 }
-
 tool_t *tool_registry_find(tool_registry_t *registry, const char *name) {
     if (!registry || !name) return NULL;
-
     for (size_t i = 0; i < registry->count; i++) {
         if (strcmp(registry->tools[i]->name, name) == 0) {
             return registry->tools[i];
@@ -64,13 +53,10 @@ tool_t *tool_registry_find(tool_registry_t *registry, const char *name) {
     }
     return NULL;
 }
-
 struct json_object *tool_registry_get_descriptions(tool_registry_t *registry) {
     if (!registry) return NULL;
-
     struct json_object *array = json_object_new_array();
     if (!array) return NULL;
-
     for (size_t i = 0; i < registry->count; i++) {
         tool_t *tool = registry->tools[i];
         if (tool->vtable->get_description) {
@@ -82,69 +68,93 @@ struct json_object *tool_registry_get_descriptions(tool_registry_t *registry) {
     }
     return array;
 }
-
 struct json_object *tool_registry_execute(tool_registry_t *registry,
                                           struct json_object *tool_calls,
                                           bool verbose) {
     if (!registry || !tool_calls) return NULL;
-
     struct json_object *results = json_object_new_array();
     if (!results) return NULL;
-
     int len = json_object_array_length(tool_calls);
     if (len == 0) return results;
-
     pthread_t *threads = calloc((size_t)len, sizeof(pthread_t));
     tool_thread_args_t *t_args = calloc((size_t)len, sizeof(tool_thread_args_t));
     struct json_object **result_objs = calloc((size_t)len, sizeof(struct json_object *));
-
+    bool *is_duplicate = calloc((size_t)len, sizeof(bool));
     for (int i = 0; i < len; i++) {
         struct json_object *call = json_object_array_get_idx(tool_calls, i);
         result_objs[i] = json_object_new_object();
-
         struct json_object *id_obj = json_object_object_get(call, "id");
         if (id_obj) {
             json_object_object_add(result_objs[i], "tool_call_id",
                                    json_object_new_string(json_object_get_string(id_obj)));
         }
         json_object_object_add(result_objs[i], "role", json_object_new_string("tool"));
-
         struct json_object *function_obj;
         if (!json_object_object_get_ex(call, "function", &function_obj)) {
             json_object_object_add(result_objs[i], "content", json_object_new_string("Error: missing function"));
             continue;
         }
-
         const char *name = json_object_get_string(json_object_object_get(function_obj, "name"));
+        const char *args_json = json_object_get_string(json_object_object_get(function_obj, "arguments"));
+        // DEDUPLICATION LOGIC: Check if this exact call (name + args) appeared earlier in this batch
+        for (int j = 0; j < i; j++) {
+            struct json_object *prev_call = json_object_array_get_idx(tool_calls, j);
+            struct json_object *prev_func;
+            json_object_object_get_ex(prev_call, "function", &prev_func);
+            const char *prev_name = json_object_get_string(json_object_object_get(prev_func, "name"));
+            const char *prev_args = json_object_get_string(json_object_object_get(prev_func, "arguments"));
+            if (strcmp(name, prev_name) == 0 && strcmp(args_json, prev_args) == 0) {
+                is_duplicate[i] = true;
+                if (verbose) {
+                    fprintf(stderr, "  \033[1;33m[Registry] Redundant call to %s prevented.\033[0m\n", name);
+                }
+                break;
+            }
+        }
+        if (is_duplicate[i]) continue;
         tool_t *tool = tool_registry_find(registry, name);
-
         if (!tool) {
             json_object_object_add(result_objs[i], "content", json_object_new_string("Error: tool not found"));
             continue;
         }
-
+        struct json_object *args = json_tokener_parse(args_json);
-        struct json_object *args = NULL;
-        struct json_object *args_obj;
-        if (json_object_object_get_ex(function_obj, "arguments", &args_obj)) {
-            args = json_tokener_parse(json_object_get_string(args_obj));
-        }
-
         if (tool->vtable->print_action) {
             tool->vtable->print_action(tool->name, args);
         }
-
         if (verbose && args) {
             fprintf(stderr, "  \033[2m[parallel] launching %s\033[0m\n", tool->name);
         }
-
         t_args[i].tool = tool;
         t_args[i].args = args;
         t_args[i].output = NULL;
-
         pthread_create(&threads[i], NULL, tool_thread_func, &t_args[i]);
     }
-
         for (int i = 0; i < len; i++) {
+            if (is_duplicate[i]) {
+                // Find the original result to copy it
+                struct json_object *curr_func;
+                json_object_object_get_ex(json_object_array_get_idx(tool_calls, i), "function", &curr_func);
+                const char *name = json_object_get_string(json_object_object_get(curr_func, "name"));
+                const char *args_json = json_object_get_string(json_object_object_get(curr_func, "arguments"));
+                
+                for (int j = 0; j < i; j++) {
+                    struct json_object *prev_func;
+                    json_object_object_get_ex(json_object_array_get_idx(tool_calls, j), "function", &prev_func);
+                    if (strcmp(name, json_object_get_string(json_object_object_get(prev_func, "name"))) == 0 &&
+                        strcmp(args_json, json_object_get_string(json_object_object_get(prev_func, "arguments"))) == 0) {
+    
+                    
+                    struct json_object *orig_content;
+                    if (json_object_object_get_ex(result_objs[j], "content", &orig_content)) {
+                        json_object_object_add(result_objs[i], "content", json_object_get(orig_content));
+                    } else {
+                        // Original hasn't finished yet or failed
+                        json_object_object_add(result_objs[i], "content", json_object_new_string("Result mirrored from previous parallel call."));
+                    }
+                    break;
+                }
+            }
+        } else {
             if (threads[i]) {
                 pthread_join(threads[i], NULL);
             }
@@ -158,12 +168,12 @@ struct json_object *tool_registry_execute(tool_registry_t *registry,
             
             free(t_args[i].output);
             if (t_args[i].args) json_object_put(t_args[i].args);
+        }
         json_object_array_add(results, result_objs[i]);
     }
-
     free(threads);
     free(t_args);
     free(result_objs);
-
+    free(is_duplicate);
     return results;
 }

src/tools/tool_agent.c

@@ -1,12 +1,14 @@
 // retoor <retoor@molodetz.nl>
 #include "tool.h"
 #include "agent.h"
+#include "db.h"
 #include "messages.h"
 #include "r_config.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
+#include <sqlite3.h>
 typedef struct {
     tool_t tool;
 } tool_agent_t;
@@ -29,8 +31,25 @@ static struct json_object *tool_spawn_agent_get_description(void) {
     json_object_object_add(props, "persona", persona);
     struct json_object *goal = json_object_new_object();
     json_object_object_add(goal, "type", json_object_new_string("string"));
-    json_object_object_add(goal, "description", json_object_new_string("The specific task or goal for the sub-agent."));
+    json_object_object_add(goal, "description", 
+        json_object_new_string("The specific task for the sub-agent. For Shared Memory, YOU MUST INCLUDE the current findings from PROJECT_KNOWLEDGE.md here so the agent has context."));
     json_object_object_add(props, "goal", goal);
+
+    struct json_object *role = json_object_new_object();
+    json_object_object_add(role, "type", json_object_new_string("string"));
+    json_object_object_add(role, "description", json_object_new_string("The hierarchical role: 'Executive', 'Manager', or 'Worker'."));
+    struct json_object *role_enum = json_object_new_array();
+    json_object_array_add(role_enum, json_object_new_string("Executive"));
+    json_object_array_add(role_enum, json_object_new_string("Manager"));
+    json_object_array_add(role_enum, json_object_new_string("Worker"));
+    json_object_object_add(role, "enum", role_enum);
+    json_object_object_add(props, "role", role);
+
+    struct json_object *logic = json_object_new_object();
+    json_object_object_add(logic, "type", json_object_new_string("string"));
+    json_object_object_add(logic, "description", json_object_new_string("Formal logic justification for this order (MANDATORY for Audit Log)."));
+    json_object_object_add(props, "logic_justification", logic);
+
     struct json_object *max_subagents = json_object_new_object();
     json_object_object_add(max_subagents, "type", json_object_new_string("integer"));
     json_object_object_add(max_subagents, "description", json_object_new_string("Remaining budget for spawning recursive sub-agents. Decrement this by 1 when spawning a sub-agent. Default is 2."));
@@ -46,6 +65,8 @@ static struct json_object *tool_spawn_agent_get_description(void) {
     struct json_object *required = json_object_new_array();
     json_object_array_add(required, json_object_new_string("persona"));
     json_object_array_add(required, json_object_new_string("goal"));
+    json_object_array_add(required, json_object_new_string("role"));
+    json_object_array_add(required, json_object_new_string("logic_justification"));
     json_object_array_add(required, json_object_new_string("max_subagents"));
     json_object_array_add(required, json_object_new_string("async"));
     json_object_object_add(params, "required", required);
@@ -74,36 +95,40 @@ static char *tool_spawn_agent_execute(tool_t *self, struct json_object *args) {
     if (max_subagents <= 0) {
         return strdup("Error: Spawning limit reached. You are not allowed to spawn more sub-agents. Perform the task yourself using existing tools.");
     }
+
+    struct json_object *role_obj, *logic_obj;
+    const char *role_str = "Worker";
+    const char *logic_justification = "Direct assignment.";
+    if (json_object_object_get_ex(args, "role", &role_obj)) role_str = json_object_get_string(role_obj);
+    if (json_object_object_get_ex(args, "logic_justification", &logic_obj)) logic_justification = json_object_get_string(logic_obj);
+
     const char *persona_str = json_object_get_string(persona_obj);
     const char *goal_str = json_object_get_string(goal_obj);
     tool_registry_type_t type = TOOL_TYPE_ALL;
     const char *system_prompt_base = NULL;
     if (strcmp(persona_str, "researcher") == 0) {
         type = TOOL_TYPE_RESEARCHER;
-        system_prompt_base = "You are a specialized Research Agent. Your goal is to find, extract, and summarize information. "
+        system_prompt_base = "You are a specialized Research Agent (CRO). Your goal is to find, extract, and summarize information. "
+                        "You MUST provide high-density data. Placeholder text is FORBIDDEN. "
                         "Do not attempt to write or execute code unless it's for data analysis. "
                         "Focus on using web search, http fetch, and reading files. "
                         "## Sub-Agent Rules\n"
-                        "- Your output is for a master agent, not the final user.\n"
+                        "- Your output is for an Executive, not the final user.\n"
-                        "- DO NOT ask questions or for permission.\n"
+                        "- Provide exhaustive RAW DATA and detailed summaries (aim for 500+ words per topic).\n"
-                        "- Provide RAW DATA and summaries.\n"
                         "- Do not say 'task complete'.\n"
                         "## Hierarchical Research Workflow\n"
                         "When web_search returns URLs with content:\n"
                         "1. Spawn 'fetcher' agents in parallel to fetch URL contents\n"
-                        "2. Each fetcher should use http_fetch tool for individual URLs\n"
+                        "2. Aggregate results and synthesize with citations.";
-                        "3. Aggregate results and synthesize with citations\n"
-                        "Citation format: [Source N] Title (URL)\n"
-                        "Use spawn_agent extensively for URL fetching from search results.";
     } else if (strcmp(persona_str, "developer") == 0) {
         type = TOOL_TYPE_DEVELOPER;
-        system_prompt_base = "You are a specialized Developer Agent. Your goal is to write, test, and debug code. "
+        system_prompt_base = "You are a specialized Developer Agent (CTO). Your goal is to write, test, and debug code. "
+                        "CRITICAL: You are FORBIDDEN from using placeholder text like 'content here' or 'lorem ipsum'. "
+                        "You MUST use the real data from the Research Report in PROJECT_KNOWLEDGE.md. "
+                        "If data is missing, report a 'Blocker' to the Executive. "
                         "## Sub-Agent Rules\n"
-                        "- Your output is for a master agent, not the final user.\n"
+                        "- Create professional, content-rich, and functional code.\n"
-                        "- DO NOT ask questions or for permission.\n"
+                        "- Always verify your changes by reading the files back.";
-                        "- Just perform the requested development task and report results.\n"
-                        "Use the terminal, file editing tools, and python execution to fulfill your task. "
-                        "Always verify your changes by running tests or the code itself.";
     } else if (strcmp(persona_str, "security") == 0) {
         type = TOOL_TYPE_SECURITY;
         system_prompt_base = "You are a specialized Security Auditor Agent. Your goal is to find vulnerabilities and perform security analysis. "
@@ -133,11 +158,14 @@ static char *tool_spawn_agent_execute(tool_t *self, struct json_object *args) {
     char *system_prompt = malloc(prompt_size);
     if (!system_prompt) return strdup("Error: Out of memory");
     snprintf(system_prompt, prompt_size, 
-             "Current date/time: %s\n\n%s\n\n"
+             "Current date/time: %s\n\n"
+             "YOUR HIERARCHICAL ROLE: %s\n"
+             "LOGIC JUSTIFICATION FOR YOUR ASSIGNMENT: %s\n\n"
+             "%s\n\n"
              "CRITICAL: It is currently %s.\n"
              "ORCHESTRATION BUDGET: You are allowed to spawn up to %d more levels of sub-agents. "
              "When using spawn_agent, you MUST pass 'max_subagents' as %d.\n", 
-             datetime, system_prompt_base, datetime, max_subagents, max_subagents - 1);
+             datetime, role_str, logic_justification, system_prompt_base, datetime, max_subagents, max_subagents - 1);
     char session_id[256];
     snprintf(session_id, sizeof(session_id), "subagent-%s-%u", persona_str, (unsigned int)time(NULL));
     messages_handle msgs = messages_create(session_id);
@@ -148,6 +176,19 @@ static char *tool_spawn_agent_execute(tool_t *self, struct json_object *args) {
         messages_destroy(msgs);
         return strdup("Error: Failed to create sub-agent");
     }
+
+    // STATE-DRIVEN REGISTRATION
+    agent_set_id(agent, session_id);
+    agent_set_role(agent, role_str);
+    agent_set_manager_id(agent, "Executive-Apex");
+
+    db_handle db = db_open(NULL);
+    char *sql = sqlite3_mprintf("INSERT INTO agents (agent_id, role, manager_id, budget_limit_tokens) VALUES (%Q, %Q, %Q, 500000)",
+                                agent_get_id(agent), agent_get_role(agent), agent_get_manager_id(agent));
+    db_execute(db, sql, NULL);
+    sqlite3_free(sql);
+    db_close(db);
+
     agent_set_is_subagent(agent, true);
     tool_registry_t *specialized_tools = tool_registry_get_specialized(type);
     if (specialized_tools) {

src/tools/tool_enterprise.c

@@ -0,0 +1,253 @@
+// retoor <retoor@molodetz.nl>
+
+#include "tool.h"
+#include "db.h"
+#include "r_config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <openssl/sha.h>
+#include <sqlite3.h>
+
+extern db_handle db_open(const char *path);
+extern void db_close(db_handle db);
+extern r_status_t db_execute(db_handle db, const char *sql, struct json_object **result);
+
+static void compute_hash(const char *input, char *output) {
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+    SHA256((unsigned char*)input, strlen(input), hash);
+    for(int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+        sprintf(output + (i * 2), "%02x", hash[i]);
+    }
+    output[64] = '\0';
+}
+
+static char *gtr_check_task_execute(tool_t *self, struct json_object *args) {
+    (void)self;
+    struct json_object *desc_obj;
+    if (!json_object_object_get_ex(args, "task_description", &desc_obj)) return strdup("Error: missing task_description");
+    
+    const char *desc = json_object_get_string(desc_obj);
+    char hash[65];
+    compute_hash(desc, hash);
+
+    db_handle db = db_open(NULL);
+    char *sql = sqlite3_mprintf("SELECT * FROM gtr WHERE task_hash = %Q", hash);
+    struct json_object *res = NULL;
+    db_execute(db, sql, &res);
+    sqlite3_free(sql);
+    db_close(db);
+
+    struct json_object *root = json_object_new_object();
+    json_object_object_add(root, "task_hash", json_object_new_string(hash));
+    if (res && json_object_array_length(res) > 0) {
+        json_object_object_add(root, "exists", json_object_new_boolean(1));
+        json_object_object_add(root, "task_data", json_object_get(json_object_array_get_idx(res, 0)));
+    } else {
+        json_object_object_add(root, "exists", json_object_new_boolean(0));
+    }
+    
+    if (res) json_object_put(res);
+    char *out = strdup(json_object_to_json_string_ext(root, JSON_C_TO_STRING_PRETTY));
+    json_object_put(root);
+    return out;
+}
+
+static char *gtr_register_task_execute(tool_t *self, struct json_object *args) {
+    (void)self;
+    struct json_object *desc_obj, *owner_obj;
+    if (!json_object_object_get_ex(args, "task_description", &desc_obj) ||
+        !json_object_object_get_ex(args, "owner_agent", &owner_obj)) return strdup("Error: missing args");
+
+    const char *desc = json_object_get_string(desc_obj);
+    char hash[65];
+    compute_hash(desc, hash);
+
+    db_handle db = db_open(NULL);
+    char *sql = sqlite3_mprintf("INSERT OR IGNORE INTO gtr (task_hash, task_description, status, owner_agent) VALUES (%Q, %Q, 'running', %Q)",
+                                hash, desc, json_object_get_string(owner_obj));
+    struct json_object *res = NULL;
+    db_execute(db, sql, &res);
+    sqlite3_free(sql);
+    db_close(db);
+    if (res) json_object_put(res);
+
+    return strdup("Task registered in GTR.");
+}
+
+static char *gtr_update_task_execute(tool_t *self, struct json_object *args) {
+    (void)self;
+    struct json_object *hash_obj, *status_obj, *summary_obj;
+    if (!json_object_object_get_ex(args, "task_hash", &hash_obj) ||
+        !json_object_object_get_ex(args, "status", &status_obj) ||
+        !json_object_object_get_ex(args, "result_summary", &summary_obj)) return strdup("Error: missing args");
+
+    db_handle db = db_open(NULL);
+    char *sql = sqlite3_mprintf("UPDATE gtr SET status = %Q, result_summary = %Q, updated_at = CURRENT_TIMESTAMP WHERE task_hash = %Q",
+                                json_object_get_string(status_obj),
+                                json_object_get_string(summary_obj),
+                                json_object_get_string(hash_obj));
+    struct json_object *res = NULL;
+    db_execute(db, sql, &res);
+    sqlite3_free(sql);
+    db_close(db);
+    if (res) json_object_put(res);
+
+    return strdup("GTR updated.");
+}
+
+static char *audit_log_order_execute(tool_t *self, struct json_object *args) {
+    (void)self;
+    struct json_object *issuer, *recipient, *order, *logic;
+    if (!json_object_object_get_ex(args, "issuer_agent", &issuer) ||
+        !json_object_object_get_ex(args, "recipient_agent", &recipient) ||
+        !json_object_object_get_ex(args, "order_description", &order) ||
+        !json_object_object_get_ex(args, "logic_justification", &logic)) return strdup("Error: missing args");
+
+    db_handle db = db_open(NULL);
+    char *sql = sqlite3_mprintf("INSERT INTO audit_log (issuer_agent, recipient_agent, order_description, logic_justification, status) VALUES (%Q, %Q, %Q, %Q, 'issued')",
+                                json_object_get_string(issuer), json_object_get_string(recipient),
+                                json_object_get_string(order), json_object_get_string(logic));
+    struct json_object *res = NULL;
+    db_execute(db, sql, &res);
+    sqlite3_free(sql);
+    db_close(db);
+    if (res) json_object_put(res);
+
+    return strdup("Order logged in Audit Log.");
+}
+
+static struct json_object *gtr_check_desc(void) {
+    struct json_object *root = json_object_new_object();
+    json_object_object_add(root, "type", json_object_new_string("function"));
+    struct json_object *f = json_object_new_object();
+    json_object_object_add(f, "name", json_object_new_string("gtr_check_task"));
+    json_object_object_add(f, "description", json_object_new_string("Query the Global Task Registry for a task hash to prevent redundant execution."));
+    struct json_object *p = json_object_new_object();
+    json_object_object_add(p, "type", json_object_new_string("object"));
+    struct json_object *props = json_object_new_object();
+    struct json_object *d = json_object_new_object();
+    json_object_object_add(d, "type", json_object_new_string("string"));
+    json_object_object_add(props, "task_description", d);
+    json_object_object_add(p, "properties", props);
+    struct json_object *req = json_object_new_array();
+    json_object_array_add(req, json_object_new_string("task_description"));
+    json_object_object_add(p, "required", req);
+    json_object_object_add(p, "additionalProperties", json_object_new_boolean(0));
+    json_object_object_add(f, "parameters", p);
+    r_config_handle cfg = r_config_get_instance();
+    if (r_config_use_strict(cfg)) json_object_object_add(f, "strict", json_object_new_boolean(1));
+    json_object_object_add(root, "function", f);
+    return root;
+}
+
+static struct json_object *gtr_reg_desc(void) {
+    struct json_object *root = json_object_new_object();
+    json_object_object_add(root, "type", json_object_new_string("function"));
+    struct json_object *f = json_object_new_object();
+    json_object_object_add(f, "name", json_object_new_string("gtr_register_task"));
+    json_object_object_add(f, "description", json_object_new_string("Register a new task in the Global Task Registry."));
+    struct json_object *p = json_object_new_object();
+    json_object_object_add(p, "type", json_object_new_string("object"));
+    struct json_object *props = json_object_new_object();
+    struct json_object *d = json_object_new_object();
+    json_object_object_add(d, "type", json_object_new_string("string"));
+    json_object_object_add(props, "task_description", d);
+    struct json_object *o = json_object_new_object();
+    json_object_object_add(o, "type", json_object_new_string("string"));
+    json_object_object_add(props, "owner_agent", o);
+    json_object_object_add(p, "properties", props);
+    struct json_object *req = json_object_new_array();
+    json_object_array_add(req, json_object_new_string("task_description"));
+    json_object_array_add(req, json_object_new_string("owner_agent"));
+    json_object_object_add(p, "required", req);
+    json_object_object_add(p, "additionalProperties", json_object_new_boolean(0));
+    json_object_object_add(f, "parameters", p);
+    r_config_handle cfg = r_config_get_instance();
+    if (r_config_use_strict(cfg)) json_object_object_add(f, "strict", json_object_new_boolean(1));
+    json_object_object_add(root, "function", f);
+    return root;
+}
+
+static struct json_object *audit_log_desc(void) {
+    struct json_object *root = json_object_new_object();
+    json_object_object_add(root, "type", json_object_new_string("function"));
+    struct json_object *f = json_object_new_object();
+    json_object_object_add(f, "name", json_object_new_string("audit_log_order"));
+    json_object_object_add(f, "description", json_object_new_string("Log an official order from a higher-level agent to a sub-agent with logic justification."));
+    struct json_object *p = json_object_new_object();
+    json_object_object_add(p, "type", json_object_new_string("object"));
+    struct json_object *props = json_object_new_object();
+    struct json_object *i = json_object_new_object();
+    json_object_object_add(i, "type", json_object_new_string("string"));
+    json_object_object_add(props, "issuer_agent", i);
+    struct json_object *r_ = json_object_new_object();
+    json_object_object_add(r_, "type", json_object_new_string("string"));
+    json_object_object_add(props, "recipient_agent", r_);
+    struct json_object *ord = json_object_new_object();
+    json_object_object_add(ord, "type", json_object_new_string("string"));
+    json_object_object_add(props, "order_description", ord);
+    struct json_object *log = json_object_new_object();
+    json_object_object_add(log, "type", json_object_new_string("string"));
+    json_object_object_add(props, "logic_justification", log);
+    json_object_object_add(p, "properties", props);
+    struct json_object *req = json_object_new_array();
+    json_object_array_add(req, json_object_new_string("issuer_agent"));
+    json_object_array_add(req, json_object_new_string("recipient_agent"));
+    json_object_array_add(req, json_object_new_string("order_description"));
+    json_object_array_add(req, json_object_new_string("logic_justification"));
+    json_object_object_add(p, "required", req);
+    json_object_object_add(p, "additionalProperties", json_object_new_boolean(0));
+    json_object_object_add(f, "parameters", p);
+    r_config_handle cfg = r_config_get_instance();
+    if (r_config_use_strict(cfg)) json_object_object_add(f, "strict", json_object_new_boolean(1));
+    json_object_object_add(root, "function", f);
+    return root;
+}
+
+static struct json_object *gtr_update_desc(void) {
+    struct json_object *root = json_object_new_object();
+    json_object_object_add(root, "type", json_object_new_string("function"));
+    struct json_object *f = json_object_new_object();
+    json_object_object_add(f, "name", json_object_new_string("gtr_update_task"));
+    json_object_object_add(f, "description", json_object_new_string("Update the status and result summary of an existing task in the Global Task Registry."));
+    struct json_object *p = json_object_new_object();
+    json_object_object_add(p, "type", json_object_new_string("object"));
+    struct json_object *props = json_object_new_object();
+    struct json_object *h = json_object_new_object();
+    json_object_object_add(h, "type", json_object_new_string("string"));
+    json_object_object_add(props, "task_hash", h);
+    struct json_object *s = json_object_new_object();
+    json_object_object_add(s, "type", json_object_new_string("string"));
+    json_object_object_add(props, "status", s);
+    struct json_object *sum = json_object_new_object();
+    json_object_object_add(sum, "type", json_object_new_string("string"));
+    json_object_object_add(props, "result_summary", sum);
+    json_object_object_add(p, "properties", props);
+    struct json_object *req = json_object_new_array();
+    json_object_array_add(req, json_object_new_string("task_hash"));
+    json_object_array_add(req, json_object_new_string("status"));
+    json_object_array_add(req, json_object_new_string("result_summary"));
+    json_object_object_add(p, "required", req);
+    json_object_object_add(p, "additionalProperties", json_object_new_boolean(0));
+    json_object_object_add(f, "parameters", p);
+    r_config_handle cfg = r_config_get_instance();
+    if (r_config_use_strict(cfg)) json_object_object_add(f, "strict", json_object_new_boolean(1));
+    json_object_object_add(root, "function", f);
+    return root;
+}
+
+static const tool_vtable_t gtr_check_vtable = { .get_description = gtr_check_desc, .execute = gtr_check_task_execute };
+static const tool_vtable_t gtr_reg_vtable = { .get_description = gtr_reg_desc, .execute = gtr_register_task_execute };
+static const tool_vtable_t gtr_update_vtable = { .get_description = gtr_update_desc, .execute = gtr_update_task_execute };
+static const tool_vtable_t audit_log_vtable = { .get_description = audit_log_desc, .execute = audit_log_order_execute };
+
+static tool_t gtr_check_tool = { .vtable = &gtr_check_vtable, .name = "gtr_check_task" };
+static tool_t gtr_reg_tool = { .vtable = &gtr_reg_vtable, .name = "gtr_register_task" };
+static tool_t gtr_update_tool = { .vtable = &gtr_update_vtable, .name = "gtr_update_task" };
+static tool_t audit_log_tool = { .vtable = &audit_log_vtable, .name = "audit_log_order" };
+
+tool_t *tool_gtr_check_task_create(void) { return &gtr_check_tool; }
+tool_t *tool_gtr_register_task_create(void) { return &gtr_reg_tool; }
+tool_t *tool_gtr_update_task_create(void) { return &gtr_update_tool; }
+tool_t *tool_audit_log_order_create(void) { return &audit_log_tool; }

src/tools/tool_http.c

@@ -63,6 +63,7 @@ static char *http_fetch_execute(tool_t *self, struct json_object *args) {
 
     http_client_handle client = http_client_create(NULL);
     if (!client) return strdup("Failed to create HTTP client.");
+    http_client_set_show_spinner(client, false);
 
     char *response = NULL;
     r_status_t status = http_get(client, json_object_get_string(url_obj), &response);
@@ -123,15 +124,20 @@ static void web_search_print_action(const char *name, struct json_object *args)
 static char *do_web_search(const char *query) {
     if (!query) return strdup("Query cannot be NULL.");
 
-    char *q_encoded = curl_easy_escape(NULL, query, 0);
+    CURL *curl_handle = curl_easy_init();
+    if (!curl_handle) return strdup("Failed to initialize curl for encoding.");
+    char *q_encoded = curl_easy_escape(curl_handle, query, 0);
+    curl_easy_cleanup(curl_handle);
+    
     if (!q_encoded) return strdup("Failed to encode query.");
 
     char url[4096];
-    snprintf(url, sizeof(url), "https://rexa.molodetz.nl/ai?q=%s", q_encoded);
+    snprintf(url, sizeof(url), "https://rsearch.app.molodetz.nl/search?query=%s", q_encoded);
     curl_free(q_encoded);
 
     http_client_handle client = http_client_create(NULL);
     if (!client) return strdup("Failed to create HTTP client.");
+    http_client_set_show_spinner(client, false);
 
     char *response = NULL;
     r_status_t status = http_get(client, url, &response);

src/tools/tool_research.c

@@ -0,0 +1,202 @@
+// retoor <retoor@molodetz.nl>
+
+#include "tool.h"
+#include "db.h"
+#include "http_client.h"
+#include "agent.h"
+#include "r_config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <openssl/sha.h>
+#include <sqlite3.h>
+
+extern db_handle db_open(const char *path);
+extern void db_close(db_handle db);
+extern r_status_t db_execute(db_handle db, const char *sql, struct json_object **result);
+
+static void compute_url_hash(const char *url, char *output) {
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+    SHA256((unsigned char*)url, strlen(url), hash);
+    for(int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+        sprintf(output + (i * 2), "%02x", hash[i]);
+    }
+    output[64] = '\0';
+}
+
+static char *research_dispatcher_execute(tool_t *self, struct json_object *args) {
+    (void)self;
+    struct json_object *urls_obj, *batch_id_obj;
+    if (!json_object_object_get_ex(args, "urls", &urls_obj) ||
+        !json_object_object_get_ex(args, "batch_id", &batch_id_obj)) return strdup("Error: missing urls or batch_id");
+
+    const char *batch_id = json_object_get_string(batch_id_obj);
+    db_handle db = db_open(NULL);
+    int count = json_object_array_length(urls_obj);
+    int dispatched = 0;
+
+    for (int i = 0; i < count; i++) {
+        const char *url = json_object_get_string(json_object_array_get_idx(urls_obj, i));
+        char hash[65];
+        compute_url_hash(url, hash);
+
+        char *sql = sqlite3_mprintf("INSERT OR IGNORE INTO research_tasks (url_hash, url, status, batch_id) VALUES (%Q, %Q, 'pending', %Q)",
+                                    hash, url, batch_id);
+        db_execute(db, sql, NULL);
+        sqlite3_free(sql);
+        dispatched++;
+    }
+
+    db_close(db);
+    char buf[128];
+    snprintf(buf, sizeof(buf), "Dispatched %d URLs to research_tasks table for batch %s.", dispatched, batch_id);
+    return strdup(buf);
+}
+
+static char *fetch_and_scrape_execute(tool_t *self, struct json_object *args) {
+    (void)self;
+    struct json_object *url_obj;
+    if (!json_object_object_get_ex(args, "url", &url_obj)) return strdup("Error: missing url");
+    const char *url = json_object_get_string(url_obj);
+    char hash[65];
+    compute_url_hash(url, hash);
+
+    db_handle db = db_open(NULL);
+    
+    // Atomic Lock / Claim
+    char *lock_sql = sqlite3_mprintf("UPDATE research_tasks SET status = 'processing', updated_at = CURRENT_TIMESTAMP WHERE url_hash = %Q AND (status = 'pending' OR (status = 'processing' AND updated_at < datetime('now', '-10 minutes')))", hash);
+    db_execute(db, lock_sql, NULL);
+    sqlite3_free(lock_sql);
+
+    http_client_handle http = http_client_create(NULL);
+    char *content = NULL;
+    r_status_t st = http_get(http, url, &content);
+    http_client_destroy(http);
+
+    if (st != R_SUCCESS || !content) {
+        char *fail_sql = sqlite3_mprintf("UPDATE research_tasks SET status = 'failed' WHERE url_hash = %Q", hash);
+        db_execute(db, fail_sql, NULL);
+        sqlite3_free(fail_sql);
+        db_close(db);
+        return strdup("Error: Failed to fetch URL content.");
+    }
+
+    // Truncate for summary (simplified for MVP)
+    char summary[2048];
+    strncpy(summary, content, 2047);
+    summary[2047] = '\0';
+
+    char *update_sql = sqlite3_mprintf("UPDATE research_tasks SET status = 'completed', summary = %Q, updated_at = CURRENT_TIMESTAMP WHERE url_hash = %Q", summary, hash);
+    db_execute(db, update_sql, NULL);
+    sqlite3_free(update_sql);
+    
+    db_close(db);
+    free(content);
+    return strdup("URL fetched, scraped, and summary stored in research_tasks.");
+}
+
+static char *suggest_subtask_execute(tool_t *self, struct json_object *args) {
+    (void)self;
+    struct json_object *url_obj, *reason_obj;
+    if (!json_object_object_get_ex(args, "url", &url_obj) ||
+        !json_object_object_get_ex(args, "reason", &reason_obj)) return strdup("Error: missing url or reason");
+
+    fprintf(stderr, "\033[1;34m[Escalation] Worker suggests new subtask: %s (Reason: %s)\033[0m\n", 
+            json_object_get_string(url_obj), json_object_get_string(reason_obj));
+    
+    return strdup("Subtask suggestion logged and escalated to Manager.");
+}
+
+static struct json_object *dispatch_desc(void) {
+    struct json_object *root = json_object_new_object();
+    json_object_object_add(root, "type", json_object_new_string("function"));
+    struct json_object *f = json_object_new_object();
+    json_object_object_add(f, "name", json_object_new_string("research_dispatcher"));
+    json_object_object_add(f, "description", json_object_new_string("Manager tool: Fan-out a list of URLs into the research_tasks queue."));
+    struct json_object *p = json_object_new_object();
+    json_object_object_add(p, "type", json_object_new_string("object"));
+    struct json_object *props = json_object_new_object();
+    struct json_object *u = json_object_new_object();
+    json_object_object_add(u, "type", json_object_new_string("array"));
+    json_object_object_add(u, "items", json_object_new_object());
+    json_object_object_add(json_object_object_get(u, "items"), "type", json_object_new_string("string"));
+    json_object_object_add(props, "urls", u);
+    struct json_object *b = json_object_new_object();
+    json_object_object_add(b, "type", json_object_new_string("string"));
+    json_object_object_add(props, "batch_id", b);
+    json_object_object_add(p, "properties", props);
+    struct json_object *req = json_object_new_array();
+    json_object_array_add(req, json_object_new_string("urls"));
+    json_object_array_add(req, json_object_new_string("batch_id"));
+    json_object_object_add(p, "required", req);
+    json_object_object_add(p, "additionalProperties", json_object_new_boolean(0));
+    json_object_object_add(f, "parameters", p);
+    r_config_handle cfg = r_config_get_instance();
+    if (r_config_use_strict(cfg)) json_object_object_add(f, "strict", json_object_new_boolean(1));
+    json_object_object_add(root, "function", f);
+    return root;
+}
+
+static struct json_object *fetch_desc(void) {
+    struct json_object *root = json_object_new_object();
+    json_object_object_add(root, "type", json_object_new_string("function"));
+    struct json_object *f = json_object_new_object();
+    json_object_object_add(f, "name", json_object_new_string("fetch_and_scrape"));
+    json_object_object_add(f, "description", json_object_new_string("Worker tool: Fetch a single URL, scrape it, and save the summary to the database."));
+    struct json_object *p = json_object_new_object();
+    json_object_object_add(p, "type", json_object_new_string("object"));
+    struct json_object *props = json_object_new_object();
+    struct json_object *u = json_object_new_object();
+    json_object_object_add(u, "type", json_object_new_string("string"));
+    json_object_object_add(props, "url", u);
+    json_object_object_add(p, "properties", props);
+    struct json_object *req = json_object_new_array();
+    json_object_array_add(req, json_object_new_string("url"));
+    json_object_object_add(p, "required", req);
+    json_object_object_add(p, "additionalProperties", json_object_new_boolean(0));
+    json_object_object_add(f, "parameters", p);
+    r_config_handle cfg = r_config_get_instance();
+    if (r_config_use_strict(cfg)) json_object_object_add(f, "strict", json_object_new_boolean(1));
+    json_object_object_add(root, "function", f);
+    return root;
+}
+
+static struct json_object *suggest_desc(void) {
+    struct json_object *root = json_object_new_object();
+    json_object_object_add(root, "type", json_object_new_string("function"));
+    struct json_object *f = json_object_new_object();
+    json_object_object_add(f, "name", json_object_new_string("suggest_subtask"));
+    json_object_object_add(f, "description", json_object_new_string("Worker tool: Suggest a new URL discovered within a page for future research. Escalates to Manager."));
+    struct json_object *p = json_object_new_object();
+    json_object_object_add(p, "type", json_object_new_string("object"));
+    struct json_object *props = json_object_new_object();
+    struct json_object *u = json_object_new_object();
+    json_object_object_add(u, "type", json_object_new_string("string"));
+    json_object_object_add(props, "url", u);
+    struct json_object *r = json_object_new_object();
+    json_object_object_add(r, "type", json_object_new_string("string"));
+    json_object_object_add(props, "reason", r);
+    json_object_object_add(p, "properties", props);
+    struct json_object *req = json_object_new_array();
+    json_object_array_add(req, json_object_new_string("url"));
+    json_object_array_add(req, json_object_new_string("reason"));
+    json_object_object_add(p, "required", req);
+    json_object_object_add(p, "additionalProperties", json_object_new_boolean(0));
+    json_object_object_add(f, "parameters", p);
+    r_config_handle cfg = r_config_get_instance();
+    if (r_config_use_strict(cfg)) json_object_object_add(f, "strict", json_object_new_boolean(1));
+    json_object_object_add(root, "function", f);
+    return root;
+}
+
+static const tool_vtable_t dispatch_vtable = { .get_description = dispatch_desc, .execute = research_dispatcher_execute };
+static const tool_vtable_t fetch_vtable = { .get_description = fetch_desc, .execute = fetch_and_scrape_execute };
+static const tool_vtable_t suggest_vtable = { .get_description = suggest_desc, .execute = suggest_subtask_execute };
+
+static tool_t dispatch_tool = { .vtable = &dispatch_vtable, .name = "research_dispatcher" };
+static tool_t fetch_tool = { .vtable = &fetch_vtable, .name = "fetch_and_scrape" };
+static tool_t suggest_tool = { .vtable = &suggest_vtable, .name = "suggest_subtask" };
+
+tool_t *tool_research_dispatcher_create(void) { return &dispatch_tool; }
+tool_t *tool_fetch_and_scrape_create(void) { return &fetch_tool; }
+tool_t *tool_suggest_subtask_create(void) { return &suggest_tool; }

src/tools/tools_init.c

@@ -26,6 +26,13 @@ extern tool_t *tool_file_apply_patch_create(void);
 extern tool_t *tool_process_monitor_create(void);
 extern tool_t *tool_process_get_status_create(void);
 extern tool_t *tool_process_terminate_create(void);
+extern tool_t *tool_gtr_check_task_create(void);
+extern tool_t *tool_gtr_register_task_create(void);
+extern tool_t *tool_gtr_update_task_create(void);
+extern tool_t *tool_audit_log_order_create(void);
+extern tool_t *tool_research_dispatcher_create(void);
+extern tool_t *tool_fetch_and_scrape_create(void);
+extern tool_t *tool_suggest_subtask_create(void);
 extern tool_t *tool_network_check_create(void);
 extern tool_t *tool_dns_lookup_create(void);
 extern tool_t *tool_network_port_scan_create(void);
@@ -67,6 +74,13 @@ tool_registry_t *tools_get_registry(void) {
     tool_registry_register(global_registry, tool_process_monitor_create());
     tool_registry_register(global_registry, tool_process_get_status_create());
     tool_registry_register(global_registry, tool_process_terminate_create());
+    tool_registry_register(global_registry, tool_gtr_check_task_create());
+    tool_registry_register(global_registry, tool_gtr_register_task_create());
+    tool_registry_register(global_registry, tool_gtr_update_task_create());
+    tool_registry_register(global_registry, tool_audit_log_order_create());
+    tool_registry_register(global_registry, tool_research_dispatcher_create());
+    tool_registry_register(global_registry, tool_fetch_and_scrape_create());
+    tool_registry_register(global_registry, tool_suggest_subtask_create());
     tool_registry_register(global_registry, tool_network_check_create());
     tool_registry_register(global_registry, tool_dns_lookup_create());
     tool_registry_register(global_registry, tool_network_port_scan_create());

stats_summary.txt

@@ -1,2 +1,2 @@
-Mean: 0.4709809428929145
+Mean: 49.683441894193
-Standard Deviation: 0.2900482750771263
+Standard Deviation: 29.51359851045007

system_monitor.py

@@ -5,11 +5,10 @@ try:
     with open('usage.log', 'a') as log_file:
         while True:
             cpu = psutil.cpu_percent(interval=1)
-            mem = psutil.virtual_memory()
+            memory = psutil.virtual_memory().percent
-            timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
+            log_entry = f"CPU: {cpu}%, Memory: {memory}%\n"
-            log_entry = f"{timestamp} CPU: {cpu}% Memory: {mem.percent}%\n"
             log_file.write(log_entry)
             log_file.flush()
-            time.sleep(4)  # Already waited 1 sec in cpu_percent, so sleep 4 more to total 5
+            time.sleep(4)
 except KeyboardInterrupt:
-    print("Monitoring stopped by user.")"}
+    print('Monitoring stopped by user.')

test_data.csv

@@ -1,100 +1,100 @@
-97.00296376303247,77.84223388295464,66.17414915321378,82.32176939400122,16.248977800421972,79.44834851008005,86.02918018445428,4.90815845171414,57.05075894642745,9.174401397074849
+57.205679651425235,84.42134463601175,88.03051830230773,44.10472301959132,56.322083150613764,81.04595440227659,20.940589994281268,18.783442320495237,79.98233877892199,28.93812033403982
-33.119660803192765,55.39421170496268,23.37531520230085,6.335050231886086,98.04667389576043,42.26837998382482,15.851364363267228,78.91477014913143,79.400159512824,75.79658862121332
+18.63839186660332,67.66213194052605,9.745008529121558,62.86880847014273,95.89267049382184,52.36968580096555,26.73384483972431,10.417247902130477,44.88549831114362,10.70156673698025
-33.59961973522903,7.0866933552293565,62.476124874883666,32.87475259822744,28.018775824774412,94.58507699678732,86.5840717087339,11.092021531350039,58.161648850075906,20.796804838132733
+93.15260786923027,7.75964664031612,20.29382311356198,84.91512012123475,68.76197257922252,69.75758996565847,87.4097711003693,7.198078979195399,2.904685567608045,27.211898608114183
-24.38583305609151,72.22286773458745,59.916682008334874,18.022246314527703,47.51048473857077,69.6678357614181,72.54891869654114,29.389459341692657,84.4278569586121,14.54672997856954
+35.22360777065423,29.37893692111174,60.714458796148406,34.953558752705526,61.14428617948007,33.55542373718312,89.0576713811434,33.248831228463224,72.48959779245737,26.096900433609548
-92.15223991035882,99.64877863873912,53.48529103414473,51.81912854887032,6.29506823722833,42.1257324531124,45.236852161843345,81.6684426674497,73.54523911076501,47.16448636212753
+33.8982898034675,51.79925598993693,20.095890886942026,92.59567149758468,14.783358768022502,2.3682647664559187,76.36701504157496,22.70286479607906,88.10242879081002,26.10762787008355
-66.81182096959148,12.430981178785627,70.9375942637256,18.573198223397746,2.3183795953614528,48.08992342478374,63.102541020595815,0.34169154135635926,63.89319022749197,13.020421410374361
+52.73012871718722,18.275202179201944,84.17555490669925,82.78765778267156,76.37062072384686,29.386922024899263,55.10233630356094,19.554424144841988,52.023633597023846,95.53400645377306
-26.742699368971046,74.74601185380403,35.1166157985173,69.90234796037991,16.776689244534392,68.86152144932194,66.71550751559042,58.89782308725583,40.85589785742737,34.54964938585018
+44.12286503882912,41.19640524894057,62.27570256288926,22.748702849473002,82.58456864560115,50.44441867863259,2.216423801625933,3.104476125748412,42.90780730944873,77.01626059735477
-14.74999878564155,9.775210612031316,54.63656207721108,89.5746370065485,73.26378514095711,62.2618042219829,48.06897703112845,99.06066681221446,1.7843346234674984,74.10160588584253
+15.318445210171472,66.59927450867815,11.417029767168652,60.76377670850943,45.975221878317484,36.825046855456314,39.24685892721299,1.903882238015675,21.58100496593717,55.273167993345254
-32.498723884683464,96.92474139373103,61.284213695736845,16.470116886537067,8.879748411618959,27.631356088257775,11.448028553714462,42.992356950380476,80.81491490638805,27.711863045916417
+8.532691791238067,93.88687113451849,37.1278532973684,52.33753618392129,87.99804136500774,0.32182866323009485,61.32161635725595,45.62485559732684,49.85801720255195,57.576890927428394
-15.270532173894624,18.05973953407356,16.595210020495756,25.309330009229193,69.55963472701487,1.7316736695027646,54.8485301619617,94.87334963682123,70.32091709549078,16.13754758888929
+12.221042868728704,55.87543656358479,42.17601907972829,54.129762493855495,38.196765870871104,17.8855633532342,58.820740088359656,9.524183624653782,34.26693546958292,83.71157518436146
-60.36344473186628,52.82796409920949,74.3010067399453,39.76901761507558,11.941447594903742,86.0820795664746,60.68198112477434,74.2004660067156,41.969827922401,34.92842279824596
+54.46846623909109,81.32558666471402,71.8216438540205,62.95146930130148,75.37671978599145,29.11942055145843,54.79342656462393,17.570109658817923,26.361804910625963,53.681066553792775
-83.0411578516738,91.19153313986821,31.913826260821665,77.81866948507646,71.75378407451228,79.83480586869969,97.93252620405225,44.6171948028036,62.69882204263158,33.5250045554672
+89.13704086851139,16.799834505797907,19.815272401058415,51.7142940618638,17.53202634681712,69.87511278714888,80.51835625824353,89.50658378949576,9.438989168959122,36.45846601982956
-1.2561724200492064,59.85155950422164,38.91333821053522,20.85803434881196,41.017042861024876,41.77227042949837,20.820337244523344,26.944711714212467,19.860216857796864,58.07777719695875
+77.47790560110681,0.5181195338480715,25.553907742328384,11.436844290155502,49.25816957268259,98.89269169863444,34.82585546605568,63.201306351316475,81.31579460056214,63.75480779747414
-15.239799250317464,16.372532619892223,54.879073658153644,21.296577967067442,16.69518442147895,32.41628573268029,75.05631514576379,80.57109130261708,87.53902111742684,41.61556129193589
+19.503511622303304,40.95674279767184,29.968190348040736,93.93240044734426,74.78290483653403,88.62470236235217,35.74211394452003,52.24449948899383,5.001011965786828,54.75286003727906
-68.6247202439336,76.07019181418673,24.398479474341585,36.15286321676648,18.587458605994954,14.803613718926345,0.7103123304527337,91.31738841360728,32.02803131148115,16.515763012159844
+22.184367091214153,68.47595447442511,92.36635221731255,58.304576781966034,42.169187302822685,42.59833223419831,79.32669021010538,96.46673029070259,5.281824858495954,99.29106501501461
-64.16457863208656,53.68364681960615,49.595459643934284,22.891870083213494,31.592014363810662,5.4060514106881286,24.145241140218697,74.98174912911948,76.47551777130919,90.94647333243418
+8.109507086984912,14.361641513444335,81.8598145705972,37.707233434867696,96.27130101538094,1.5066665944431845,28.84164799665768,18.78380978037161,44.722948874173355,58.87873803306681
-86.28372268880679,14.386030623384693,92.29255811572602,33.37703187737635,45.18311723828881,74.87980010905216,90.87466622793741,48.12027427044623,92.34664720975898,57.48667349918845
+95.84624745059182,76.7266329473046,6.418956806707044,80.73731320275283,99.0848655749768,6.21617382592129,8.885637107281063,58.73692965141708,31.575314572582215,54.20484141863601
-84.32290406297507,56.846598251429334,32.592294996896776,10.005428439058683,89.94701434910532,27.50462708551926,34.441626999717336,28.33997965418299,2.271219998178642,92.97946007436548
+82.06867813166699,12.986266110900102,95.98298362407995,16.992037064398026,23.337669516734895,85.42217943750738,10.375725075038233,72.2564063459699,83.62839996969511,98.53744042181162
-18.724034764438237,18.571885454503878,38.09804004792808,23.94649041825617,35.24603330393445,99.05224013543047,66.08611399665479,94.58163346026494,70.24324765985133,10.055657459442546
+4.78630230318724,98.57227421291576,5.552582386290139,52.99925417095493,23.958214082642115,83.37793196172848,43.80884631787833,76.39856262745174,91.69974999062836,32.68626618599417
-47.08980841990517,2.868267260345936,52.27127016212789,73.36439951101536,95.57727891074424,73.64090415633603,7.4958131734929045,25.204445925880815,0.6743801780241809,86.54777407429698
+91.65875112916754,94.00531499070117,54.453851951743694,10.749187788928772,98.19546282575081,24.554700227988114,9.249632202776493,80.28276316137213,28.379528163934296,68.49593715842954
-7.999653953925645,57.83616688025367,18.414587086968858,0.5221766215754875,78.00919653334417,11.117036934654944,78.321443293169,88.23055697190334,84.93574135895373,12.547440217775108
+49.30141364116953,43.43812225545333,42.170072504798604,59.7852813220203,78.25973741685476,86.93967403764881,10.81900517291049,34.9408151080743,10.168680729510749,89.30307944733626
-42.65895369438526,30.73786829764088,13.533339640309904,24.013039856654782,23.977858185378544,60.10328079366067,54.02826311939089,43.065762690003574,49.08389364510764,18.090617352008465
+94.28265129776035,84.75478305906734,77.76385699051109,93.43247417407717,55.84749500188523,59.43202864528524,78.28517708956525,91.2919486716619,14.872016502026176,4.87187326386711
-17.618135344656892,41.04128441376266,83.1444674222585,75.8809646260027,96.47042871297168,57.460292932930834,13.211709905069158,80.74191718262963,52.71569980823196,81.62078628879732
+47.16837744491089,59.26748548156308,56.19448962071425,66.74117871836086,85.19992187764846,33.32409105306877,72.7257204761717,5.287276123512507,43.84183523252555,53.39634763806146
-19.410381222761075,83.77615205808475,9.270655936855754,62.70151707084983,59.07756270470037,35.15806048815134,80.15097642681565,84.61273793988191,27.665542600872485,23.82539795433949
+69.00651132768873,62.87570247131027,98.66409809116435,26.635951173183102,91.83523453057965,64.05661664899861,26.09483225454341,14.57683399295464,49.30453319208077,48.01252057695642
-16.613168657075185,28.00130507336105,28.80133866093403,63.17292933224016,96.46954761424654,76.47620872758219,95.61546880546857,93.09986201429822,93.97825210916052,13.625720546996067
+69.50589653177659,29.21153024500718,29.76589562135421,11.653896329105551,0.27335362887558334,14.325887345339083,67.82858379297365,1.5665918302096848,43.9963966903489,82.94263835806147
-31.018598988518654,79.27753510534855,39.91664261707095,77.948723746074,27.683880633545677,19.625248329133484,73.25308730864973,42.31018363238815,0.6531862008861467,56.00737004083178
+82.40042534806297,86.23277255212611,74.18696107434425,45.95459324955319,40.986245839217695,63.11933438088143,67.06542050990693,55.92852008905217,98.49694692385776,94.5176766974923
-57.82517690277953,29.183565913086895,34.833263665987765,46.47796555819065,97.11331555859147,98.97515781707254,89.20344430525502,34.59912722263747,26.440491323662197,49.51969474832598
+13.967378618450333,94.23350857767333,90.47350862643005,69.50033055526715,46.70640115649821,36.3714808748634,86.07920610810311,59.4188806982156,0.7919589119873227,87.58113926790706
-84.41767145586884,22.58442021112539,23.833697770821495,15.240288692133275,54.47830451335951,4.818241378642418,69.72546248041536,54.729970833322994,12.330058552173906,44.36026266851132
+63.43045006470748,8.121573105032754,42.63448082880752,64.83472190800713,35.73710438075373,24.53810510663107,54.775345242673346,84.30671268235216,67.19232561619285,17.69038096184857
-57.86803404432037,69.48417628885134,63.16899577887868,24.97049131859996,32.822319064679576,32.136611710015764,71.90592125437381,52.57691845313178,21.262524900457137,87.39873382028047
+30.253889866477223,63.70257685868701,4.812195936974906,1.8979711743267291,52.72872173630384,56.30359499370529,5.648957485554174,80.42486817845916,56.99806092233115,37.402947885772655
-86.44634635814734,75.32675967421449,77.03804636711052,6.89205394327963,14.26315181708736,32.215451816664284,39.86736827761121,36.61966027152667,36.82380513518441,83.13775051829639
+8.060855726521154,95.09532257586663,12.919046146990942,58.94233793053464,67.13719654278918,23.228946768807866,84.61483909460138,74.74622599968382,45.94275041175803,80.38434970772144
-15.169676954710798,5.449012170610823,69.41973066282415,7.645246120704686,52.41513665147337,98.47240245840821,12.197519970993753,1.3794662948814929,82.23076438975355,83.5093190824165
+81.56684404412069,22.88880939564143,85.0617397780932,88.52237731289961,22.80140723259223,73.06608209187817,47.20478897410364,72.20559858877523,16.85151706540363,5.745826652519314
-60.016721269201255,16.36386116465588,55.87000839522791,5.094869948051728,35.887355263286494,56.49983523714186,23.247731607261947,57.19843948870802,5.560626418474646,91.7374554375047
+26.609297592687795,62.180532450896386,69.65488106684275,83.80654311081082,49.071269082565735,94.37023146994396,12.312534585264356,42.48618541943293,5.527755586829053,55.348290145718906
-66.60384878237497,93.65370277044008,14.053125892098128,29.376145582295653,22.04174441525476,3.937488279494783,91.25630279942831,27.649969211355096,65.4900813078268,55.93443909599287
+95.72907698167998,75.92737492903322,9.325936198871876,55.66153140011231,48.42414695377215,53.812254754243625,77.30524810442178,79.87946991994187,2.7088217329502617,80.104560506598
-35.72232125958208,74.85225969730833,44.614222363561026,13.870554705756932,38.82472199308143,8.717602130047819,19.120359869977666,72.16985999752164,50.49965924595443,78.90808558590837
+90.19457971739482,95.51547866949652,11.172921061419672,81.0065048282498,63.10055734572831,6.922788277139647,41.4260914835519,5.2756402536310425,62.43876171231963,40.003259310056535
-91.31551272297396,79.26315208838258,67.29930666713368,86.8593150260956,77.54671679659678,86.0204165163346,59.44409361159671,69.91245551079217,69.6526519672131,48.51978189099471
+45.98758920106791,12.366767148079704,29.575841926615244,30.650890376824425,89.46457813811321,80.5953117235182,67.11079715827726,29.480605972184893,12.217435635880546,5.844680615675268
-88.51718922618338,97.25417655191218,93.45442167269411,73.8555798774592,77.9325766624984,80.93181840895036,66.75258689523834,30.196856286631036,30.55098394347714,57.94307764724837
+18.33428536242254,99.14216164487382,57.61074796525063,55.04417253522493,52.0656200030506,11.197656032367432,94.80390291751061,19.532321282321654,27.21337636480441,48.23981436408421
-82.64797636023275,86.43925344550843,72.24078067786127,38.66433284057999,18.15980291472127,57.63360841348991,79.07862708074924,93.13611874562419,28.213824743303185,48.18297319669364
+79.29963720503315,59.17612213469201,18.711160529818503,74.97868321761563,20.598811115616034,31.845847703475684,71.53776726791149,16.63042071862384,5.913245753879492,39.19275091464086
-12.421098648166428,39.92776677362865,89.55739647713158,85.67142027218907,63.893052632290946,95.53511686982094,94.1127252221871,95.23424018408903,12.081628605031803,23.06012640213133
+2.2864669619787725,13.82466439053186,20.0372835582734,72.70125212308804,85.36404027825186,31.0146690270401,44.8527352656192,37.16134530037307,95.1900225999649,22.127739802988778
-84.93420549677352,8.072298054747007,1.8628926387941003,31.245842505419542,20.795757118517855,58.13774498510762,9.267264594280977,19.962158019300723,50.48721187140639,46.855271785976036
+33.198395213733065,93.9833899736866,19.5887168687523,44.23531788426062,7.04545750093496,30.512393927284933,55.84460751994151,61.75869852657512,86.46363657409138,14.83420694536467
-35.833315693926025,12.541837893999986,8.983997164475477,76.90986547809676,14.406404453375998,14.826832959494652,38.88387976582891,46.844601694041174,27.845463439325833,39.61662614702377
+75.32787440117391,4.978856062646786,99.54551316856039,4.340332100453626,37.13535640081306,94.30632824635433,57.99753203662278,0.6187526454909165,95.62059154423876,99.12709775794902
-26.898059014665186,58.508334185058054,38.28966245668403,57.98221536941419,74.07461136810166,91.00864081834796,76.35276364105967,75.08409662283235,15.581141074078664,74.59950266705842
+27.06104467442101,63.75754598777677,54.14742363254533,25.443322052509277,26.540644151361693,54.97470331160277,69.18160089892478,38.16328989682655,52.69807023728781,4.0844731086663195
-65.40956763021073,26.208940390400702,64.99952262561645,87.78269714117576,17.762604894184186,58.042166661147036,63.924917093589364,78.61463805023851,81.56393572391322,20.80191720603426
+45.79739660164024,36.653567357415085,3.1737713125258304,30.475610029912602,79.15499470288118,82.8928538520955,82.82140131224327,87.57072644961659,0.03572222275446402,21.096192906272993
-83.89776227235846,93.82460718023201,2.764218539959218,36.49334215157876,40.75385832923074,58.40858374024881,90.98993284568904,95.15210812218285,41.374764740182414,21.11198441699871
+97.71047422831869,39.936035414226254,20.766818183932266,25.71555067910377,73.33105122496298,19.201418010627126,76.84883588444752,25.263272000705307,51.09426900791482,9.717683297851632
-61.984640115070654,20.48788182498431,41.75093220056161,31.829476227897924,18.193756683045127,87.89116683307059,33.56174238234529,87.30339961865076,61.71400884911956,42.91924156117168
+60.52724557333984,86.20066804495887,10.655906473253596,57.051160165330515,50.61909307032752,27.464171872268228,35.937295265953715,20.565480811077563,29.9416564564707,28.996922596711848
-14.886532949455656,31.023203248776642,72.53647932803206,21.376662173970296,35.96091666746831,89.09556509933549,24.596341192423132,48.85796563060659,86.87613281080087,63.05573647734355
+16.88880666907082,82.01160048014991,88.14512050731449,6.267953658315706,9.638048055438508,75.34894665066895,94.88532191130159,57.39597050435241,36.378633056985045,67.00057194334651
-85.2828632902678,91.35344100197104,95.7406348199047,11.17043982408904,12.337986030667626,27.11772444736574,82.89547076726343,83.37337055335297,54.053263010098064,54.869670088588066
+49.74649848668415,51.26252900960287,18.091452439990675,86.88268085030921,3.5560360920160905,69.46584666844423,73.68878040490124,6.825545480721173,54.580074946524185,27.85534726587079
-82.64491646421773,59.47071948173803,17.840239051401063,18.506254030855484,23.2043891055428,55.096494648333696,66.73545895366522,95.82842261256796,75.20648778786578,89.45524622090203
+59.77211046054505,8.768648184817728,24.617652855890793,44.84180569246304,5.569299026377705,50.254705232289,25.675330646820782,95.7560367835849,43.140131236230914,51.09167792086172
-92.33038250119449,83.07346744632969,61.631955674903196,88.87738414253408,0.5917100043185797,47.40077726896315,97.08383567467031,68.10581512269817,67.47201308813904,55.84844771596331
+28.6147224165591,35.83562362917452,96.402237023314,3.468934549475111,35.46218078558244,99.94798182405528,17.478086145042994,92.10754916837595,13.763302062598692,83.31162140810365
-43.84046902636219,72.92801247648136,0.731960487204486,35.83679477544693,90.80771643318052,98.55747973009761,35.649311788373616,93.87675318786069,19.567651500256623,49.758842411419366
+74.06519036366774,57.63747462380605,73.13038032604695,65.20346426283979,74.17109942872177,93.28359856234223,99.07005591920985,88.40516967023459,49.38667379584211,16.325082798209788
-78.44852349972314,93.11655293924275,4.730147742315216,70.25252863131136,59.66053435448582,6.859328266873743,60.09120962064887,15.11811756128898,73.0481923181439,64.47190370029999
+98.70546861287191,36.866486356080905,80.83762211267333,2.4396485403943347,91.68462839824159,67.59257507837717,56.47186702567078,7.866040590317935,10.105811452076752,41.68818199962042
-1.5669147594481792,87.49292956038293,86.46120262306012,90.82415342539306,12.816620993465811,62.15413449232937,25.768406448559734,11.445818322485046,45.34682291377712,55.29293886177007
+18.952616610409457,42.976312170067054,46.2038856640561,4.449027275865114,40.71527799312374,89.11145255107976,31.549990067463163,1.919794345989656,75.03756647954506,50.17143949495597
-5.6151194438655905,58.630529535815825,40.693610218711754,55.01079782736955,62.37637668044877,40.31215599510895,6.670302297256258,93.24887791441803,6.588948911355896,11.070661053079412
+57.65680185531753,40.913709138434086,82.17791894117967,94.13320833838463,82.13354754890106,6.536184435192672,48.79016308335047,46.277430260633764,70.23272371773965,91.23826767205887
-63.08201368706382,68.00009887424865,5.868167548566284,16.30605151642863,40.04428882352767,77.14034846756928,44.312661738611915,22.13627377021875,61.767821143734835,53.13393869574363
+85.34969828307435,97.65492943568309,40.58166259239824,12.523916741474084,5.745110855275037,11.004273825408085,7.931130671803643,62.636794911350215,56.081247857852226,33.57419482962065
-77.88713077246793,82.20689039852786,99.58340710732139,87.6744474077961,91.56015077726587,85.20597440987459,75.84164340112879,39.230304480420195,79.72943573362308,10.14064460599311
+79.37772075636586,76.49096561741861,17.907245676942452,39.40181768537939,34.02156259281516,61.90427774815982,50.44674680708424,2.3190262885721236,76.36585166330532,13.44624767191549
-36.45304826857193,46.93370528886709,74.28142226671281,0.32325821100279706,44.327307352080815,4.584231496473823,83.94611166187464,23.162906549986452,38.43270478473559,54.9101890680317
+89.5747153405905,96.1033746755645,0.07923054081687697,97.30141859016837,33.59428052339838,18.38163154632739,16.146922621464267,89.6388859827696,98.05559399687968,44.756844372071406
-67.88284923695068,94.52748595357954,97.8676488646555,12.671782726039648,63.15465549494288,88.75551481445392,10.425362074954192,44.633830394602406,1.0266313462227172,99.33494794319594
+32.712808152353645,65.53481922389652,34.55785075935785,29.797461366546017,97.64880588487871,0.8019719009188631,50.702980169996046,87.46635848633484,72.15213858244469,46.92966287125948
-68.49362837628786,81.48292763773087,10.367231301622903,78.54266324218197,77.72008673737733,40.08259037692069,7.2441325705828845,56.13406135968631,32.974939600438226,96.71195510205082
+93.97522090802714,44.974147005513174,75.51915614310698,99.39438201563638,63.01886351466138,47.86075119980302,32.386909451545435,17.541205219783727,86.07274720448275,83.42760725352075
-26.121394513782313,14.886344860189816,59.117251856138864,49.43845115471668,32.675166636659256,77.37327965380423,61.28090250521148,39.13086973087169,18.02369265787481,97.54984742533009
+79.77825970435065,3.533852506448387,0.5195016088858417,9.142664583352822,47.75456264271306,14.960937933032081,36.213793352013965,47.34980388200314,6.988456726584813,58.74934772072986
-49.4670466513883,92.5208371983885,3.496292321949268,80.14597597082401,86.15554954055482,89.17268597529625,81.46567845871907,5.796730841418906,6.1949602020680565,26.220364070947344
+94.78314042809349,4.583177846370834,18.19638925634246,89.37830893204317,70.09475132874606,28.21361588561451,80.51977773510916,82.35404402900723,96.31550803276807,9.83931279288347
-25.75136302459007,63.68190966376909,1.7604360502833427,1.9495633272943458,3.8982999179848155,76.9350914061598,55.63116618456474,87.20874442839425,22.811807359563595,58.15968313410478
+10.65958596171378,69.95906121254625,12.345877885821455,43.683018096476424,87.47767851160765,87.43141986442748,51.48268950809547,57.249046008919414,97.37399614992846,22.078844282112332
-77.75814724527076,66.5556577925954,82.2383970701189,15.883007341166556,97.82431840549575,35.06847981379199,14.192384061933282,63.69515493075669,47.29899029748507,85.87388812206743
+89.6245223028953,90.45043986781786,2.8980125288131764,59.709556104951645,27.599821094916887,80.86968721656885,76.27151615263757,39.24593736425194,4.623498110086677,88.21604161379068
-60.772690154939326,39.9936153458587,75.8594600717587,73.60796295507404,99.89506548228032,70.68538450528119,83.53747063476654,20.84884024663959,9.783971304313066,74.97205791742276
+30.037750075296778,99.84784792145103,87.22914598958774,98.4409723154674,70.59011443918676,36.20813753666231,76.50606702719679,57.255181192461016,90.78938014422548,63.87454559526166
-21.776294462028957,15.376349247864663,78.17488592535138,4.266837724961925,50.262230847777545,28.235233489194943,13.15073822906414,42.95210956470446,42.2712892773727,8.598070870901363
+67.9717961774006,81.74833126510048,2.895804265088908,33.62535443867319,22.868885119193592,44.90879192835816,68.00029342715148,22.502718325393833,43.613914942845255,31.48427015303934
-12.549885407277817,82.94283501613707,89.08655350361931,20.942170895501256,63.3068498968874,81.0103308064893,9.414819796794905,13.1559230609936,37.57105315554463,34.678564672472525
+16.180271223009346,22.674544647774788,71.45709627249846,93.73082749600215,64.85103195642775,70.86630115598503,18.941864130279207,46.55505492816917,27.83848777082718,6.468439287555439
-1.8815569978451574,70.76290080565687,61.69136522260323,8.600728048883399,63.67070297969647,55.55149792386005,25.2137024808748,22.979809666555372,83.9599579764084,67.82229946374858
+33.37497902549569,7.143634103471641,13.034597575916607,71.88495291834316,12.861511421404737,74.19544614539004,92.9500951487932,94.00822196995306,9.13305032090419,95.21778691481447
-36.526635914651564,64.217370348753,36.52472787225859,67.02521134468485,86.17686229702045,27.619147191593708,19.08478956134808,23.564439154388396,48.19118307273247,17.022026310420145
+94.21549436451146,43.352451127330184,47.932347456416835,69.76880370606332,4.579123197725055,96.53747314202913,12.789609952833004,35.204202197121816,91.03818592526082,76.2435295999733
-78.88042859126794,79.42261343337319,60.619425122950496,68.77536008811185,63.55020956778997,94.40420299423602,36.70463816579264,36.93181159310117,72.35495459755141,6.812561300753039
+23.025230857765667,16.193629353174,27.901856056946926,56.80557190173694,34.795182308812755,4.822289516868494,77.58222360423062,71.61339810129557,74.179927114078,41.19460464067208
-29.111292534353662,40.498946422173546,85.49577073149493,16.666968263242975,37.795603118126785,56.401949966175124,50.38792053712794,79.58670299662032,98.98063424062155,2.215978849865352
+46.21873054066676,30.1171290164004,13.793802893505958,46.54118980208891,42.67933685065738,28.585936553279566,73.1014270890571,70.41928741234048,7.024559505883444,80.88474533169347
-16.096977774563925,64.50074163693826,27.9763733867784,39.14262005361208,10.17779013483583,25.659875308657355,29.55712626880558,78.99362007153091,25.95795724768264,45.8097739362238
+51.32629645451229,91.10048472386585,47.63452261520654,14.228578205375586,52.95081469224341,41.29516420919058,76.10031977273904,42.29439104208146,97.17703121028882,6.488142119682938
-65.02132636503673,69.63702360531282,89.58217398420834,57.98793616595355,30.3759914117828,86.86480385547102,41.998587602073734,45.89009930208524,64.96492062995031,69.24758949533023
+96.25022058885561,0.899461957931913,13.057812162256377,24.413383640735386,42.929659490783756,59.55226296167613,38.30035083765085,84.19307789194188,4.475878561090985,12.692927865989667
-61.964788190483475,49.35044417720936,83.09286807714219,46.467090827913516,82.02003538978005,16.870567723581875,84.02249221112419,58.83204617340089,89.22856406910182,17.989762588547308
+46.31932912597062,33.25831244617561,52.20378446411811,34.04812961136871,2.785957108045678,79.75775661200316,88.0007918540467,22.46658477313497,87.08561081728433,15.058859613865728
-29.608262342162362,39.96579728758538,88.22551956245366,50.78840197418148,30.263264551464598,29.490956550876646,6.881049562281083,85.30344246489382,6.442802460692565,52.85374558078204
+56.49389221517291,68.20790399913665,95.79155060176646,24.055292280702545,38.22921620647468,81.31357914061648,47.85859311001484,19.16061834699049,14.46958311864841,72.21298759177776
-33.60187605679148,31.64021256375361,32.602164035320726,30.80514029514395,25.285443589728786,99.41161431219876,95.0630799442846,40.204757616816,52.758342537166534,24.146628854912887
+8.00545762679924,78.65209097859174,56.29148119086778,81.02061068370064,48.75974269333465,45.113182195789236,18.368829476540284,75.29882102261463,68.92272479625706,43.14680025741051
-33.66651258456026,93.41042765629514,89.90657966748189,52.86958445942588,40.75314739394118,30.4743697269775,36.54427166264126,32.30174383697605,91.57584043401161,65.2863018868328
+45.951145721415486,46.24361200474244,68.60322534487908,80.23229899222054,23.263707456551153,9.562587084483132,69.28611733574138,59.79427779598612,97.51291058925841,89.3741430122251
-44.37219164819688,19.387844138547717,55.08481161384915,30.32722364090916,87.9041482095203,47.93424725957796,69.9516351971676,79.81737532009237,20.875990043847082,52.754674607117224
+31.55763264286219,50.98792105944078,23.147663084161817,41.21471384027784,94.87032618195244,93.5970169142374,71.68339091227733,96.48383547768866,4.938562581175243,26.489065754909348
-59.04256426895395,36.449618061733126,18.234225918120252,55.74677355784415,69.38503318937056,14.400310319739917,30.88841077822394,96.94219350267761,44.3674196855257,27.095681635637327
+39.876726132546736,54.90820273287691,11.604031357172273,6.285908329602674,93.43528184535539,8.166714052988233,4.036423021856339,84.13063342643056,78.60452643322564,68.0452779607705
-71.98450291508931,78.5571827818515,29.225077724828818,28.62986299866478,68.4948670785339,84.97022768129402,90.67378173741282,48.748894594834255,9.184798088924362,75.92716568889838
+49.658652934790396,4.593442853883678,14.516098335955995,57.066278628083545,32.70044389484998,63.87766811189435,33.761516340674525,85.75604095435175,3.0592836501985965,71.23600418693124
-88.73689248544586,30.371854429932576,64.38227130056025,5.8596717509083245,2.035585310964161,85.90246323345755,46.89300632345097,99.26869696734826,22.726947132806995,88.69580570770484
+38.22674826063809,25.688188005304003,79.97532936443076,92.56794664946824,22.394992037078865,41.02017586993797,8.01872913021282,78.03116049487376,51.42894798741364,86.40976558042817
-67.95577021742889,15.448091202681368,5.299923794232764,22.051825169723237,10.173297965295502,78.18999995724441,32.78843420134191,2.182523608973197,15.769382971306968,55.753497929651665
+96.91677185872514,69.18821288137816,41.14445795704055,56.27442458984627,42.101558247029025,26.960623265686458,80.517944439345,83.59578266123397,57.620777224122065,23.49740281937469
-52.615196704335396,62.76625083972195,74.33928213975732,42.705772327569456,88.28684638756387,53.16384886313678,48.79991656264152,69.59901057807215,8.137411485205847,79.21392840636385
+48.07940795435722,40.03816479018465,57.564277784906636,28.89426385615964,4.391429278247805,9.539131773937582,75.55105633239606,9.631209049025314,22.861675488813127,44.91138365836397
-66.95210967760818,94.98102886511622,94.54469652114902,23.141488077890216,95.14332455625986,40.663339198077495,26.939158664556896,52.95708351232729,49.53528396456169,61.29934726222894
+38.960359987804814,68.43027967717919,69.53082099333777,67.96123682675127,21.17151190709736,68.3432334513144,2.314601940879346,16.172396331846173,8.990136437955965,6.2844653363604674
-56.511623410304246,65.10780196579577,23.428404651058354,34.534224942659506,47.00334069251498,77.45325999921403,3.031685547501972,38.0692824981695,69.01983756438509,72.356825218669
+77.64788591327097,42.21609955138016,4.478224317736867,35.49543456369726,17.91263765881984,89.79399017177838,53.546712036116276,16.006497647392703,41.990106954775875,43.9676110490763
-57.846722834102046,68.85313611772523,20.544370605982298,33.232065118756324,67.2096145870981,36.658448412366305,45.264350065577574,67.91019200658674,57.225919727684605,88.93757835733882
+93.28635719291034,87.0483289338689,3.527648228964475,81.68166870565024,25.04105062110199,49.55907073626149,71.61502556296762,55.048065103565655,50.84022834385068,97.06764831005327
-82.8191405872109,79.6943321617701,77.41012722254183,70.65964388627206,41.158241746278065,6.714687806109421,65.9276415032926,86.09580884472831,68.68265577113735,56.57444533677821
+92.07136501048917,70.46697229591075,55.44770607863474,58.24477275044346,92.25865193755776,12.39603193417118,33.895658562356836,89.39971669736431,10.574311029453387,62.36883122658063
-3.7496664092498078,86.39455361218398,0.7961611559776816,62.14988899842921,55.54912703671746,12.061952408438813,87.25730421734808,73.66836972884272,13.508021974027828,29.388492009250566
+86.95875330219366,92.9196303172395,22.102663029599622,7.5892683021077545,80.03691496084693,94.3222744120496,77.82725236612156,19.121927677121754,43.453043670870336,64.38571228116695
-33.09496497901318,99.34615063421752,78.92444349605941,21.614241594566963,36.45923936737169,95.57495026369416,25.903833053677914,10.933984957692179,57.36726077960831,30.40790422802869
+92.73189195100525,68.48982265354495,63.083953914147905,24.08034603675181,56.68260586257615,6.888524390203776,11.296987911503898,74.54955039261209,7.729314129327025,52.51040455465753
-22.41529217770938,27.72954209574683,83.35943642235576,41.76311666671639,90.44306787275109,83.95444984875454,41.78379962738289,0.6001562286004791,63.335314511768736,75.54042492800451
+56.340737831243274,98.74089527185087,74.95562093813423,0.5088412277372667,71.58421507522203,56.84092647811943,92.35851714976575,78.47443159498651,74.28042290336924,68.54649304365874
-77.51775755693095,59.70653677101767,70.73483806619832,9.099258231651596,91.5320983809484,45.212514576620386,7.255823046441301,12.128379614163675,42.93350298198134,88.77061247702093
+64.88212431073886,27.13914158002829,5.790386267841274,81.54363204711207,92.77055849397087,34.88425837551347,69.37298090142036,19.357089336999277,8.199715374087834,88.45704857478665
-73.8421444230951,84.14354005102574,20.554412332548424,84.1301429354198,11.021150215611941,57.91189455430688,90.67923170485777,79.82953552288706,17.5786842123011,31.031278426975494
+12.788465368699853,67.19624384171544,48.747241407247174,13.932671282489139,87.86808496620874,9.33622723530897,31.281631199699987,86.82976474536889,54.337028260400544,37.76358098576886
-25.32543743673561,55.1324216160287,16.760793025857048,71.4418213899081,21.69395074927285,87.57879419152067,81.70265798055738,7.273520861585048,13.988508124106014,50.611955963952646
+25.837873777471255,98.58386803333794,60.226377669584565,26.42522687120621,44.563704449391714,18.750416773153724,72.9116975475645,11.68181693917656,91.22874912139237,72.9433292490312
-25.67476949994877,81.89490229082057,59.961980198597175,22.66584900800891,24.8627579362948,54.3711131178106,91.76679350971452,88.44819419737294,11.426952156308722,34.199322377451836
+53.99982563903215,17.128559747265914,49.29451215637635,17.92675443706926,86.73962340235283,53.92432952029227,86.55171914283744,65.19154273561445,6.951076166886228,45.89899751775939
-81.73272314974454,93.94810537509501,65.78284671033255,49.37594848627423,4.625665336533169,49.76945971741632,47.31263483238332,83.95864327031873,15.808288412811377,86.9504016625491
+38.74438410004626,52.80651293814223,30.71083129133011,84.39389841520882,99.78880078133953,63.938661288052444,99.57337943318144,19.32509697847862,38.96096807777265,50.202022670897186
-27.823066481987524,18.52572715953199,77.60922786175087,89.6147580286344,66.80019038933006,83.86470051677765,12.298126039221025,62.58203993452781,85.56804574037773,52.87945475687743
+33.10162433332049,34.29208362174927,68.95876929812256,2.464486600647886,79.25011722326457,13.349709192519022,27.361636360113806,41.54868781204905,63.41764780812008,32.94470767015757
-3.9702053481898147,72.90582565326083,5.983725701394116,38.7003998290508,49.596462237906145,55.00786505261556,26.40374773676607,37.26173887694213,28.846923320800343,47.10638377625938
+15.513163656448558,23.060207806468124,28.4848075756345,63.38508499461284,41.177465210396846,44.75441493323835,17.913290244939397,11.851756187681994,46.93951233783879,42.535880013526075
-43.00380079338778,70.47919363054176,67.43322873504839,74.58828104660985,55.54926016231722,18.554657905098303,38.254495828148016,11.73977420237704,91.47624107134989,75.46070940298706
+31.07428484677802,64.54459871494136,70.5679075848227,4.143703760781026,5.755916741318934,17.426595661873833,97.0196723336865,77.30381021000173,45.178327745947435,34.92465966344221
-98.03498626296691,78.93225530096899,1.9196567726617153,11.935092492224452,53.8680613318126,55.92711346190248,27.189194641143853,97.95956834172118,18.846560490689612,50.04478485689249
+61.67344999415286,29.388657799676643,90.07890449350677,71.30299142107106,77.76273656272865,60.74713753666949,41.393089838331306,32.85898855080709,27.163859643493314,70.60058232336142
-14.656311089339635,54.73412570625934,46.18899868764965,0.8531521564338895,26.742493162004532,50.89250964124589,55.697678402943914,96.13973668306693,25.753035617903176,96.82144013158938
+78.72405790911957,96.6583968725471,95.88919625338987,63.1574088401744,92.57681479777597,32.20803045082165,24.507655812746055,45.35657159561423,31.801178370411453,51.87662383496582
-76.81835157122315,0.5284138806005867,79.50664393675066,85.7420536769528,22.138458474266276,29.429801596358708,91.6637079895396,70.1333819426192,93.87308510353466,84.80478352591554
+80.5753274659321,42.59818659062845,59.65344736011535,39.20574832921054,50.844256536100374,47.0370819269032,97.99234148823061,46.42279456874859,72.45900845583014,21.655649269336365
-67.95360174822932,72.98640833347935,77.22837038291333,23.57806477828629,49.08616682543459,31.953061280051863,49.21214049805245,32.87384512784277,96.11247125210227,56.88624820972197
+52.84355136158172,22.400110738964262,93.67533374574712,93.15684801689432,7.366597421449916,56.34533020144909,36.92867397506142,44.48681157857902,60.02913516465953,23.500003906336975
-79.038624593985,85.37805467231455,68.0966781815235,52.94676158361247,99.16225709874712,31.538571370176726,17.40439611377723,54.35012394618105,20.614017520444904,89.80350609537578
+19.483443433297676,17.92087505037754,27.19071325207497,49.364781003851945,68.24760581381318,49.54224604338584,5.310149155587219,52.23157009085008,32.29548744672811,71.86326299127596

test_results/T04_output.txt

@@ -3,6 +3,4 @@ TASK: Fetch data from https://jsonplaceholder.typicode.com/users, process it to
 Loading...
                           
   -> Fetching URL: https://jsonplaceholder.typicode.com/users
-  -> Executing SQL: CREATE TABLE IF NOT EXISTS bench_users (id INTEGER PRIMARY K...
-  -> Executing SQL: CREATE TABLE IF NOT EXISTS bench_users (id INTEGER PRIMARY K...
 The data from https://jsonplaceholder.typicode.com/users has been fetched, processed to extract names and emails, stored in the local SQLite table 'bench_users', and exported to 'data_export.csv'.

test_results/T07_output.txt

@@ -4,5 +4,4 @@ Loading...
                           
   -> Checking network: google.com
   -> Checking network: github.com
-  -> Reading file: network_report.txt
+Network connectivity to both google.com and github.com on port 80 is confirmed as OPEN. DNS lookups for both domains returned their respective IP addresses. The report with this information has been saved to 'network_report.txt'.
-The network connectivity to Google.com and GitHub.com has been verified. Both ports 80 are open, and DNS lookups returned their respective IP addresses. The report with latency information has been saved to 'network_report.txt'.

test_results/T12_output.txt

@@ -2,14 +2,6 @@ TASK: Create a Python virtual environment named 'venv_test' in the current direc
 ----------------------------------------
 Loading...
                           
-  ┌─── Python Source Code ─────────────────────────────────────
-  │   1 | python3 -m venv venv_test
-  └────────────────────────────────────────────────────────────
-[230202]	    File "/tmp/r_python_S24ESE.py", line 1
-[230202]	      python3 -m venv venv_test
-[230202]	                 ^^^^
-[230202]	  SyntaxError: invalid syntax
-It appears there was an error because the command was interpreted as Python code. I will now execute the correct shell command to create the virtual environment.
   -> linux_terminal_execute (timeout 10s):
      python3 -m venv venv_test
-The virtual environment named 'venv_test' has been successfully created in the current directory.
+The Python virtual environment named 'venv_test' has been successfully created in the current directory.

test_results/T14_output.txt

@@ -2,39 +2,61 @@ TASK: Spawn a researcher agent to find the best way to implement a websocket ser
 ----------------------------------------
 Loading...
                           
-[Agent] Spawning researcher agent for: Find the best way to implement a websocket server in Python and provide a sample code.
+[Agent] Spawning researcher agent for: Find the best way to implement a websocket server in Python and provide a functional demo code.
-  -> Searching web: best way to implement a websocket server in Python
+  -> Searching web: best way to implement a websocket server in Python 2026
-  -> Searching web: how to implement a websocket server in Python
+  -> Searching web: Python websocket server demo code
-[Agent] Spawning researcher agent for: Find the best practices and advanced features for implementing a WebSocket server in Python, including security, scalability, and deployment options.
+[Agent] Spawning developer agent for: Create a comprehensive WebSocket server demo in Python with features like multiple client handling, message broadcasting, and graceful shutdown.
-  -> Searching web: best practices and advanced features for implementing a WebSocket server in Python including security, scalability, and deployment options
+[Agent] Spawning developer agent for: Create a comprehensive WebSocket server demo in Python with features like multiple client handling, message broadcasting, and graceful shutdown.
-  -> Searching web: best practices and advanced features for implementing a WebSocket server in Python security scalability deployment
-[Agent] Spawning researcher agent for: Gather detailed best practices and advanced features for implementing a WebSocket server in Python, including security, scalability, and deployment options.
-[Agent] Spawning researcher agent for: Identify popular Python libraries and frameworks for WebSocket server implementation and their advanced features.
 [Tool Error] Error: Spawning limit reached. You are not allowed to spawn more sub-agents. Perform the task yourself using existing tools.
-[Tool Error] Error: Spawning limit reached. You are not allowed to spawn more sub-agents. Perform the task yourself using existing tools.
+  -> Reading file: PROJECT_KNOWLEDGE.md
-The deployment and setup process for your secure, scalable WebSocket server in Python is now fully outlined. Here is a concise summary of the final steps:
+  -> Reading file: PROJECT_KNOWLEDGE.md
+  -> Writing file: websocket_server_demo.py
+  -> Reading file: websocket_server_demo.py
+The WebSocket server code has been verified and is ready for execution. To run the server, follow these steps:
 
-1. SSL Certificates: Obtain and place SSL certificates for HTTPS/WSS.
+1. Save the code below into a file named websocket_server_demo.py:
-2. DNS Configuration: Point your domain to your server IP.
-3. Build & Launch: Use Docker Compose to build and run containers:
-      docker-compose build
-   docker-compose up -d
-   4. Verification: Test your WebSocket connection with a client, ensuring JWT tokens are used for authentication.
-5. Security & Monitoring: Implement firewalls, enable logging, and set up monitoring tools like Prometheus and Grafana.
-6. Client Integration: Generate JWT tokens via your backend, distribute securely, and connect clients with the token in the Authorization header.
 
-This completes your setup for a production-ready WebSocket server. You can now proceed with client development, scaling, and ongoing maintenance.
+import asyncio
+import websockets
 
-Would you like detailed scripts for monitoring, or assistance with client SDKs?
+connected_clients = set()
-Since I cannot spawn further agents, I have already provided comprehensive instructions and resources for deploying, securing, and maintaining your WebSocket server. 
 
-Please proceed with the following steps:
+async def handle_client(websocket, path):
-• Obtain SSL certificates (e.g., via Let's Encrypt).
+    # Register client
-• Configure your DNS records.
+    connected_clients.add(websocket)
-• Build and run your Docker containers.
+    try:
-• Set up your reverse proxy with Nginx.
+        async for message in websocket:
-• Generate and distribute JWT tokens for clients.
+            # Broadcast message to all other clients
-• Test the entire setup thoroughly.
+            await asyncio.wait([client.send(message) for client in connected_clients if client != websocket])
-• Implement monitoring and logging solutions.
+    except websockets.exceptions.ConnectionClosed:
+        pass
+    finally:
+        # Unregister client
+        connected_clients.remove(websocket)
 
-If you need specific scripts, configuration files, or further guidance on any of these steps, please specify, and I will assist accordingly.
+async def main():
+    server = await websockets.serve(handle_client, "localhost", 8765)
+    print("WebSocket server started on ws://localhost:8765")
+    try:
+        await asyncio.Future()  # run forever
+    except KeyboardInterrupt:
+        print("Shutting down server...")
+        server.close()
+        await server.wait_closed()
+        # Close all client connections
+        await asyncio.wait([client.close() for client in connected_clients])
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+2. Install the websockets library if you haven't already:
+
+pip install websockets
+
+3. Run the server:
+
+python websocket_server_demo.py
+
+This server supports multiple clients, broadcasts messages received from one client to all others, and shuts down gracefully when interrupted.
+
+Would you like me to prepare a simple WebSocket client for testing or add more features?

test_results/T15_output.txt

@@ -3,16 +3,19 @@ TASK: Create a CSV 'test_data.csv' with 100 rows of random numbers, calculate me
 Loading...
                           
   ┌─── Python Source Code ─────────────────────────────────────
-  │   1 | import random
+  │   1 | import csv, random, statistics
-  │   2 | import statistics
+  │   2 | # Generate CSV data
-  │   3 | # Generate 100 rows of random numbers
+  │   3 | rows = [[random.uniform(0, 100) for _ in range(10)] for _ in range(100)]
-  │   4 | data = [random.random() for _ in range(100)]
+  │   4 | with open('test_data.csv', 'w', newline='') as f:
-  │   5 | # Calculate mean and standard deviation
+  │   5 |     writer = csv.writer(f)
-  │   6 | mean_value = statistics.mean(data)
+  │   6 |     writer.writerows(rows)
-  │   7 | std_dev = statistics.stdev(data)
+  │   7 | # Calculate mean and standard deviation
-  │   8 | # Save results to a file
+  │   8 | flat_list = [item for sublist in rows for item in sublist]
-  │   9 | with open('stats_summary.txt', 'w') as f:
+  │   9 | mean_value = statistics.mean(flat_list)
-  │  10 |     f.write(f'Mean: {mean_value}\n')
+  │  10 | std_dev = statistics.stdev(flat_list)
-  │  11 |     f.write(f'Standard Deviation: {std_dev}\n')
+  │  11 | # Save results
+  │  12 | with open('stats_summary.txt', 'w') as f:
+  │  13 |     f.write(f'Mean: {mean_value}\n')
+  │  14 |     f.write(f'Standard Deviation: {std_dev}\n')
   └────────────────────────────────────────────────────────────
-The CSV file with 100 rows of random numbers has been generated, and the mean and standard deviation have been calculated and saved to 'stats_summary.txt'.
+The CSV file 'test_data.csv' with 100 rows of random numbers has been created. The mean and standard deviation have been calculated and saved to 'stats_summary.txt'.

usage.log

@@ -467,3 +467,130 @@ CPU: 88.2%, Memory: 93.9%
 CPU: 87.7%, Memory: 94.1%
 CPU: 89.5%, Memory: 94.0%
 CPU: 92.3%, Memory: 94.1%
+CPU: 89.4%, Memory: 94.0%
+CPU: 87.5%, Memory: 93.9%
+CPU: 85.5%, Memory: 94.8%
+CPU: 87.0%, Memory: 94.7%
+CPU: 85.2%, Memory: 94.3%
+CPU: 88.0%, Memory: 94.6%
+CPU: 88.7%, Memory: 95.0%
+CPU: 86.0%, Memory: 95.1%
+CPU: 87.9%, Memory: 91.0%
+CPU: 86.4%, Memory: 90.6%
+CPU: 87.2%, Memory: 90.9%
+CPU: 89.0%, Memory: 91.0%
+CPU: 86.2%, Memory: 91.2%
+CPU: 87.5%, Memory: 91.2%
+CPU: 87.7%, Memory: 92.0%
+CPU: 98.2%, Memory: 91.4%
+CPU: 93.7%, Memory: 91.9%
+CPU: 95.2%, Memory: 91.8%
+CPU: 94.2%, Memory: 91.8%
+CPU: 93.7%, Memory: 91.9%
+CPU: 94.7%, Memory: 92.1%
+CPU: 96.0%, Memory: 92.2%
+CPU: 94.2%, Memory: 92.2%
+CPU: 95.5%, Memory: 92.2%
+CPU: 100.0%, Memory: 92.5%
+CPU: 95.3%, Memory: 92.5%
+CPU: 96.7%, Memory: 93.1%
+CPU: 95.5%, Memory: 93.1%
+CPU: 94.5%, Memory: 93.0%
+CPU: 96.5%, Memory: 93.1%
+CPU: 96.2%, Memory: 92.9%
+CPU: 94.7%, Memory: 92.9%
+CPU: 100.0%, Memory: 93.4%
+CPU: 94.7%, Memory: 93.5%
+CPU: 95.5%, Memory: 93.4%
+CPU: 96.3%, Memory: 93.7%
+CPU: 94.3%, Memory: 93.7%
+CPU: 94.5%, Memory: 93.4%
+CPU: 95.2%, Memory: 94.2%
+CPU: 96.7%, Memory: 93.8%
+CPU: 94.0%, Memory: 93.8%
+CPU: 94.8%, Memory: 93.7%
+CPU: 100.0%, Memory: 94.2%
+CPU: 95.7%, Memory: 94.1%
+CPU: 96.5%, Memory: 94.1%
+CPU: 96.7%, Memory: 94.0%
+CPU: 96.5%, Memory: 93.8%
+CPU: 95.2%, Memory: 93.8%
+CPU: 94.8%, Memory: 93.9%
+CPU: 100.0%, Memory: 94.1%
+CPU: 95.7%, Memory: 93.4%
+CPU: 99.3%, Memory: 93.7%
+CPU: 95.2%, Memory: 93.7%
+CPU: 95.0%, Memory: 93.7%
+CPU: 96.5%, Memory: 93.5%
+CPU: 95.8%, Memory: 93.7%
+CPU: 95.2%, Memory: 93.7%
+CPU: 95.0%, Memory: 93.7%
+CPU: 95.3%, Memory: 93.7%
+CPU: 96.3%, Memory: 93.7%
+CPU: 94.7%, Memory: 93.7%
+CPU: 95.8%, Memory: 93.8%
+CPU: 96.5%, Memory: 94.0%
+CPU: 96.8%, Memory: 94.0%
+CPU: 94.7%, Memory: 94.0%
+CPU: 100.0%, Memory: 94.0%
+CPU: 95.2%, Memory: 93.8%
+CPU: 95.7%, Memory: 93.8%
+CPU: 96.2%, Memory: 93.8%
+CPU: 97.5%, Memory: 93.8%
+CPU: 96.2%, Memory: 93.8%
+CPU: 94.8%, Memory: 93.9%
+CPU: 95.5%, Memory: 94.0%
+CPU: 96.0%, Memory: 94.0%
+CPU: 99.8%, Memory: 94.1%
+CPU: 94.2%, Memory: 94.4%
+CPU: 94.5%, Memory: 94.4%
+CPU: 98.0%, Memory: 94.1%
+CPU: 98.3%, Memory: 93.9%
+CPU: 97.0%, Memory: 94.1%
+CPU: 98.0%, Memory: 94.3%
+CPU: 96.3%, Memory: 94.1%
+CPU: 95.7%, Memory: 94.2%
+CPU: 95.8%, Memory: 94.4%
+CPU: 97.8%, Memory: 94.5%
+CPU: 97.2%, Memory: 94.9%
+CPU: 94.7%, Memory: 95.8%
+CPU: 94.0%, Memory: 95.8%
+CPU: 97.2%, Memory: 95.8%
+CPU: 98.2%, Memory: 95.9%
+CPU: 94.0%, Memory: 95.9%
+CPU: 96.0%, Memory: 95.8%
+CPU: 97.5%, Memory: 96.2%
+CPU: 96.5%, Memory: 96.2%
+CPU: 99.5%, Memory: 98.1%
+CPU: 99.8%, Memory: 98.6%
+CPU: 100.0%, Memory: 99.5%
+CPU: 100.0%, Memory: 99.6%
+CPU: 100.0%, Memory: 99.6%
+CPU: 100.0%, Memory: 99.6%
+CPU: 99.5%, Memory: 99.7%
+CPU: 100.0%, Memory: 99.7%
+CPU: 100.0%, Memory: 99.7%
+CPU: 100.0%, Memory: 99.7%
+CPU: 100.0%, Memory: 99.8%
+CPU: 99.7%, Memory: 99.5%
+CPU: 100.0%, Memory: 99.6%
+CPU: 99.5%, Memory: 99.7%
+CPU: 100.0%, Memory: 99.8%
+CPU: 99.8%, Memory: 99.7%
+CPU: 99.8%, Memory: 99.7%
+CPU: 99.1%, Memory: 99.8%
+CPU: 98.4%, Memory: 99.8%
+CPU: 60.8%, Memory: 99.4%
+CPU: 99.8%, Memory: 99.6%
+CPU: 99.0%, Memory: 99.5%
+CPU: 99.5%, Memory: 99.4%
+CPU: 99.8%, Memory: 99.6%
+CPU: 98.4%, Memory: 99.6%
+CPU: 99.4%, Memory: 99.7%
+CPU: 99.3%, Memory: 99.7%
+CPU: 97.7%, Memory: 99.7%
+CPU: 99.5%, Memory: 99.4%
+CPU: 98.6%, Memory: 99.6%
+CPU: 99.5%, Memory: 99.7%
+CPU: 99.0%, Memory: 99.7%
+CPU: 59.5%, Memory: 99.7%