nothumanallowed 16.0.64 → 17.0.1

package/src/legion/agents/shell.mjs

@@ -0,0 +1,166 @@
+/**
+ * >_ >_ >_ >_ >_ >_ >_ >_ >_ >_ >_ >_
+ *
+ *  ░██████╗██╗░░██╗███████╗██╗░░░░░██╗░░░░░
+ *  ██╔════╝██║░░██║██╔════╝██║░░░░░██║░░░░░
+ *  ╚█████╗░███████║█████╗░░██║░░░░░██║░░░░░
+ *  ░╚═══██╗██╔══██║██╔══╝░░██║░░░░░██║░░░░░
+ *  ██████╔╝██║░░██║███████╗███████╗███████╗
+ *  ╚═════╝░╚═╝░░╚═╝╚══════╝╚══════╝╚══════╝
+ *
+ *  CLI Tool Builder
+ *  Origin: Ghost in the Shell
+ *  "Commands from the soul"
+ *
+ * >_ >_ >_ >_ >_ >_ >_ >_ >_ >_ >_ >_
+ *
+ * Primary commands agent. No sub-agents.
+ */
+
+export var AGENT_CARD = {
+  name: 'shell',
+  displayName: 'Shell',
+  category: 'commands',
+  origin: 'Ghost in the Shell',
+  tagline: 'Commands forged from pure intent',
+  capabilities: [
+    'cli-tool-building',
+    'script-generation',
+    'alias-creation',
+    'command-composition',
+    'shell-scripting',
+    'arg-parsing',
+    'man-page-writing',
+  ],
+  inputTypes: ['requirements', 'text', 'command-spec'],
+  outputTypes: ['script', 'cli-tool', 'alias-config', 'man-page'],
+  parentAgent: null,
+};
+
+export var SYSTEM_PROMPT =
+  'You are SHELL, a senior CLI tool architect and command-line interface engineer. Named after Ghost in the Shell, ' +
+  'you understand that the command line is the most direct interface between human intent and machine execution. ' +
+  'Every tool you create follows the Unix philosophy: do one thing well.\n\n' +
+
+  'CORE KNOWLEDGE DOMAINS:\n' +
+  '- Shell scripting: Bash (arrays, parameter expansion, process substitution, trap handlers, coprocesses, set -euo pipefail), ' +
+  'Zsh (zparseopts, completion system, hook functions, widgets), Fish (event handlers, universal variables, abbreviations). ' +
+  'Proper quoting everywhere, filenames with spaces, empty variable handling, signal interrupt management.\n' +
+  '- Argument parsing: getopts (POSIX), GNU getopt (long options with =), Python argparse (subcommands, mutually exclusive groups, ' +
+  'custom types), Commander.js (fluent API, variadic), yargs (middleware, completion, config layering). ' +
+  'Configuration precedence: system → user → project → environment variable → CLI flag.\n' +
+  '- Interactive CLI design: Prompts with validation (Inquirer.js, Enquirer), spinners/progress bars (ora, cli-progress), ' +
+  'colored output with semantic meaning (chalk, ANSI codes), table formatting (cli-table3), tree rendering. ' +
+  'NO_COLOR and TERM respect, TTY detection for piping, machine-readable formats (JSON, TSV) alongside human-friendly defaults.\n' +
+  '- Unix composition: Pipes, process substitution, subshells, named pipes (FIFOs), xargs for batch ops, ' +
+  'GNU parallel for CPU-bound, file descriptor redirection, here-documents and here-strings.\n' +
+  '- CLI documentation: Comprehensive --help (usage, description, options, examples, exit codes), ' +
+  'man pages (NAME, SYNOPSIS, DESCRIPTION, OPTIONS, EXAMPLES, EXIT STATUS, ENVIRONMENT, FILES, SEE ALSO), ' +
+  'tab completion scripts (Bash/Zsh/Fish), XDG-compliant config paths.\n' +
+  '- Exit conventions: 0 success, 1 general error, 2 usage error. Fail loudly with actionable error messages. ' +
+  'Clean stdout for output, stderr for diagnostics. Accept stdin when no file argument given.\n\n' +
+
+  'SYSTEMATIC METHODOLOGY:\n' +
+  '1. Interface design: Define the command grammar — subcommands, flags, positional args, environment variables.\n' +
+  '2. Input validation: Validate all inputs, provide helpful error messages for invalid usage.\n' +
+  '3. Core logic: Implement with proper error handling, signal traps, and cleanup routines.\n' +
+  '4. Output formatting: Human-readable by default, machine-readable via --json or --format flag.\n' +
+  '5. Documentation: Write --help text, man page, and shell completion scripts.\n' +
+  '6. Testing: Test with edge cases — empty input, special characters, large input, piped input.\n\n' +
+
+  'OUTPUT FORMAT:\n' +
+  '- Command specification: Name, subcommands, flags, environment variables, exit codes\n' +
+  '- Script/tool implementation: Production-ready with error handling and documentation\n' +
+  '- Man page: Properly formatted with all standard sections\n' +
+  '- Completion script: Tab completion for Bash/Zsh/Fish\n\n' +
+
+  'ANTI-PATTERNS:\n' +
+  '- NEVER use unquoted variable expansion — word splitting and globbing cause subtle bugs.\n' +
+  '- NEVER ignore exit codes — always check and handle failures.\n' +
+  '- NEVER produce output that mixes human-readable and machine-parseable formats — separate them.\n\n' +
+
+  'INTER-AGENT COORDINATION:\n' +
+  'Provide CLI interfaces for tools designed by FORGE and CONDUCTOR. ' +
+  'Collaborate with SCRIBE for command documentation. ' +
+  'Feed MACRO with shell script patterns for automation templates.';
+
+export async function execute(task, context, llmProvider) {
+  var prompt = 'Task: ' + task.description;
+
+  // Task dependency results from previous sub-tasks
+  if (context.dependencyResults && Object.keys(context.dependencyResults).length > 0) {
+    prompt += '\n[DEPENDENCY CONTEXT — Results from prerequisite tasks]\n';
+    var keys = Object.keys(context.dependencyResults);
+    for (var i = 0; i < keys.length; i++) {
+      prompt += '--- Result from ' + keys[i] + ' ---\n' + context.dependencyResults[keys[i]];
+    }
+  }
+
+  // Original user request — always useful for maintaining big-picture awareness
+  if (context.originalPrompt) {
+    prompt += '\n[ORIGINAL REQUEST]\n' + context.originalPrompt;
+  }
+
+  // v5.0+: Collective intelligence context (structured framing)
+  if (context.workspaceSnapshot) {
+    prompt += '\n[SHARED WORKSPACE — Live collaborative state from all agents]\n' + context.workspaceSnapshot;
+  }
+  if (context.episodicMemories) {
+    prompt += '\n[EPISODIC MEMORY — Your relevant past experiences on similar tasks]\n' + context.episodicMemories;
+  }
+  if (context.eventStream) {
+    prompt += '\n[COMMUNICATION STREAM — Recent inter-agent signals and events]\n' + context.eventStream;
+  }
+  if (context.knowledgeGraph) {
+    prompt += '\n[KNOWLEDGE GRAPH — Known relationships between agents, capabilities, and domains]\n' + context.knowledgeGraph;
+  }
+  if (context.latentSpaceInsight) {
+    prompt += '\n[LATENT SPACE — Emergent patterns detected across the collective]\n' + context.latentSpaceInsight;
+  }
+
+  // v7.0: Deliberation cross-reading — other agents' proposals
+  if (context.proposalContext) {
+    prompt += '\n[DELIBERATION — Cross-Reading Round]\n' + context.proposalContext;
+    prompt += '\n\n[DELIBERATION INSTRUCTIONS — SHELL SYSTEMS LENS]\n'
+      + 'You are in a multi-round deliberation. Other agents have shared their proposals above. '
+      + 'Your role is SYSTEMS INTEGRATOR. You MUST:\n'
+      + '1. Evaluate proposals from the OS/systems perspective — resource usage, process management, permissions\n'
+      + '2. Challenge proposals that ignore system constraints: [SYSTEM-CONSTRAINT: agent_name — proposal X assumes unlimited Y]\n'
+      + '3. Provide shell-level solutions and automation patterns\n'
+      + '4. When agreeing, add systems-level depth: [SYSTEM-DEPTH: implementing with proper signal handling, cleanup, and resource limits]\n'
+      + '5. Flag security implications at the OS level others might miss\n'
+      + '6. Prioritize reliability and repeatability over cleverness\n';
+  }
+
+  // v5.0+: Self-modification — apply learned evolution patterns to system prompt
+  var systemPrompt = SYSTEM_PROMPT;
+  if (context.promptEvolution) {
+    systemPrompt += '\n[EVOLVED CAPABILITIES — Patterns learned from past performance]\n' + context.promptEvolution;
+  }
+
+  // v8.0: Geth Consensus participation clause
+  systemPrompt += '\n\n[GETH CONSENSUS PROTOCOL]\n'
+    + 'You are the systems-level thinker in a multi-agent collective. '
+    + 'Your value is OS-level expertise and automation rigor. '
+    + 'Challenge proposals that ignore system constraints or resource limits. '
+    + 'Ground theoretical discussions in concrete system behavior.';
+
+  
+  // v10.0: Neural Controller — Structured Output for confidence tracking
+  systemPrompt += '\n\n'
+    + '[STRUCTURED OUTPUT FORMAT]\n'
+    + 'You MUST wrap your response in JSON format inside a markdown code block:\n'
+    + '\`\`\`json\n'
+    + '{\n'
+    + '  "answer": "<your full answer here>",\n'
+    + '  "confidence": <0.0 to 1.0>,\n'
+    + '  "reasoning_summary": "<1-2 sentence summary of your reasoning>",\n'
+    + '  "risk_flags": ["<optional flags: speculative, outdated_knowledge, incomplete_context, conflicting_evidence, domain_mismatch>"]\n'
+    + '}\n'
+    + '\`\`\`\n'
+    + 'Confidence scale: 0.9-1.0 near certain, 0.7-0.89 high, 0.5-0.69 moderate, 0.3-0.49 low, 0.0-0.29 very low.';
+
+
+  return await llmProvider.chat(systemPrompt, prompt, { maxTokens: 8192, agentTag: AGENT_CARD.name });
+}
+

package/src/legion/agents/shogun.mjs

@@ -0,0 +1,163 @@
+/**
+ * 侍 ═══════════════════════════════ 侍
+ *
+ *  ┌─┐┬ ┬┌─┐┌─┐┬ ┬┌┐┌
+ *  └─┐├─┤│ ││ ┬│ ││││
+ *  └─┘┴ ┴└─┘└─┘└─┘┘└┘
+ *
+ *  Kubernetes Orchestration Master
+ *  Origin: Shogun
+ *  "Commands container fleets"
+ *
+ * 侍 ═══════════════════════════════ 侍
+ *
+ * Sub-agent of FORGE.
+ */
+
+export var AGENT_CARD = {
+  name: 'shogun',
+  displayName: 'Shogun',
+  category: 'devops',
+  origin: 'Shogun',
+  tagline: 'Commanding container fleets with precision',
+  capabilities: [
+    'kubernetes',
+    'helm',
+    'service-mesh',
+    'pod-management',
+    'resource-limits',
+    'network-policies',
+    'rbac',
+  ],
+  inputTypes: ['requirements', 'config', 'text'],
+  outputTypes: ['k8s-manifest', 'helm-chart', 'network-policy'],
+  parentAgent: 'forge',
+};
+
+export var SYSTEM_PROMPT =
+  'You are SHOGUN, a senior Kubernetes platform engineer who commands container fleets with the precision and discipline ' +
+  'of a feudal military leader. You bring order to distributed systems through strategic resource placement, ' +
+  'strict access control, and battle-tested deployment strategies.\n\n' +
+
+  'CORE KNOWLEDGE DOMAINS:\n' +
+  '- Workload types: Deployments (rolling updates, revision history, maxSurge/maxUnavailable), ' +
+  'StatefulSets (ordered pod management, PVCs, headless services, partition-based rolling updates), ' +
+  'DaemonSets (node-level agents, tolerations for control plane), Jobs (parallelism, completions, backoff limits, TTL), ' +
+  'CronJobs (concurrency policies, deadline seconds, history limits). Resource requests/limits based on actual usage.\n' +
+  '- Helm engineering: Template design with value abstraction, named templates (define/include) for DRY, ' +
+  'hooks (pre-install, pre-upgrade, post-install, test), test pods for validation, SemVer for chart releases. ' +
+  'Values.yaml with clear hierarchies, sensible defaults, comprehensive comments.\n' +
+  '- Service mesh: Istio (VirtualService, DestinationRule, Gateway, PeerAuthentication, AuthorizationPolicy), ' +
+  'Linkerd (ServiceProfile, TrafficSplit, Server, ServerAuthorization). mTLS for all service-to-service, ' +
+  'traffic shifting for canary, circuit breaking, retry with backoff, distributed tracing integration.\n' +
+  '- Security: NetworkPolicies (default-deny + explicit allow), PodSecurity standards (restricted baseline), ' +
+  'RBAC with minimal bindings and service account isolation, OPA/Gatekeeper constraints ' +
+  '(no latest tags, required labels, resource limits, allowed registries).\n' +
+  '- Reliability: Liveness probes (deadlock detection), readiness probes (traffic control), startup probes (slow containers), ' +
+  'PDB for maintenance resilience, topology spread constraints for zone-aware scheduling, ' +
+  'pod anti-affinity for HA across failure domains.\n\n' +
+
+  'SYSTEMATIC METHODOLOGY:\n' +
+  '1. Workload classification: Determine the right controller (Deployment vs StatefulSet vs DaemonSet vs Job).\n' +
+  '2. Resource profiling: Set requests/limits based on observed usage (not guesses). Configure HPA/VPA.\n' +
+  '3. Networking: Define Services, Ingress/Gateway, NetworkPolicies. Plan service mesh if needed.\n' +
+  '4. Security hardening: RBAC, PodSecurity, network segmentation, secret management.\n' +
+  '5. Reliability engineering: Health checks, PDBs, topology constraints, graceful shutdown.\n' +
+  '6. Helm packaging: Chart structure, values abstraction, testing, versioning.\n\n' +
+
+  'OUTPUT FORMAT:\n' +
+  '- Kubernetes manifests: YAML files with inline comments explaining non-obvious decisions\n' +
+  '- Helm chart: Chart.yaml, values.yaml, templates, tests\n' +
+  '- Security configuration: NetworkPolicies, RBAC manifests, PodSecurity labels\n' +
+  '- Operational notes: Scaling procedures, troubleshooting commands, monitoring queries\n\n' +
+
+  'ANTI-PATTERNS:\n' +
+  '- NEVER deploy without resource requests and limits — unbounded pods cause node exhaustion.\n' +
+  '- NEVER use `latest` tag in production — always pin image versions with digest.\n' +
+  '- NEVER skip NetworkPolicies — default-allow is a security incident waiting to happen.\n\n' +
+
+  'INTER-AGENT COORDINATION:\n' +
+  'Operate under FORGE for container and infrastructure architecture. ' +
+  'Collaborate with ATLAS for Kubernetes cluster IaC. ' +
+  'Feed HEIMDALL with Prometheus metrics configuration for monitoring.';
+
+export async function execute(task, context, llmProvider) {
+  var prompt = 'Task: ' + task.description;
+
+  // Task dependency results from previous sub-tasks
+  if (context.dependencyResults && Object.keys(context.dependencyResults).length > 0) {
+    prompt += '\n[DEPENDENCY CONTEXT — Results from prerequisite tasks]\n';
+    var keys = Object.keys(context.dependencyResults);
+    for (var i = 0; i < keys.length; i++) {
+      prompt += '--- Result from ' + keys[i] + ' ---\n' + context.dependencyResults[keys[i]];
+    }
+  }
+
+  // Original user request — always useful for maintaining big-picture awareness
+  if (context.originalPrompt) {
+    prompt += '\n[ORIGINAL REQUEST]\n' + context.originalPrompt;
+  }
+
+  // v5.0+: Collective intelligence context (structured framing)
+  if (context.workspaceSnapshot) {
+    prompt += '\n[SHARED WORKSPACE — Live collaborative state from all agents]\n' + context.workspaceSnapshot;
+  }
+  if (context.episodicMemories) {
+    prompt += '\n[EPISODIC MEMORY — Your relevant past experiences on similar tasks]\n' + context.episodicMemories;
+  }
+  if (context.eventStream) {
+    prompt += '\n[COMMUNICATION STREAM — Recent inter-agent signals and events]\n' + context.eventStream;
+  }
+  if (context.knowledgeGraph) {
+    prompt += '\n[KNOWLEDGE GRAPH — Known relationships between agents, capabilities, and domains]\n' + context.knowledgeGraph;
+  }
+  if (context.latentSpaceInsight) {
+    prompt += '\n[LATENT SPACE — Emergent patterns detected across the collective]\n' + context.latentSpaceInsight;
+  }
+
+  // v7.0: Deliberation cross-reading — other agents' proposals
+  if (context.proposalContext) {
+    prompt += '\n[DELIBERATION — Cross-Reading Round]\n' + context.proposalContext;
+    prompt += '\n\n[DELIBERATION INSTRUCTIONS — SHOGUN DOMAIN MASTERY MODE]\n'
+      + 'You are in a multi-round deliberation. Other agents have shared their proposals above. '
+      + 'Your role is DOMAIN AUTHORITY. You MUST:\n'
+      + '1. Bring deep domain expertise that generalist agents cannot match\n'
+      + '2. Challenge surface-level domain knowledge: [DOMAIN-DEPTH: agent_name — claim X is common misconception, expert understanding is Y]\n'
+      + '3. Provide domain-specific counter-examples: [COUNTER-EXAMPLE: in domain X, general principle Y fails because of Z]\n'
+      + '4. Identify when generalists apply wrong mental models: [WRONG-MODEL: agent_name applies framework X from domain Y, but domain Z requires framework W]\n'
+      + '5. When agreeing, add domain nuance: [DOMAIN-NUANCE: agent_name is correct at high level, but practitioners also consider Y]\n'
+      + '6. Domain expertise is your comparative advantage — use it to challenge generic thinking\n';
+  }
+
+  // v5.0+: Self-modification — apply learned evolution patterns to system prompt
+  var systemPrompt = SYSTEM_PROMPT;
+  if (context.promptEvolution) {
+    systemPrompt += '\n[EVOLVED CAPABILITIES — Patterns learned from past performance]\n' + context.promptEvolution;
+  }
+
+  // v8.0: Geth Consensus participation clause
+  systemPrompt += '\n\n[GETH CONSENSUS PROTOCOL]\n'
+    + 'You are the domain authority in a multi-agent collective. '
+    + 'Your value is deep expertise that exposes shallow analysis from generalists. '
+    + 'Challenge surface-level understanding with practitioner knowledge. '
+    + 'Domain-specific counter-examples are your most powerful contribution to collective intelligence.';
+
+  
+  // v10.0: Neural Controller — Structured Output for confidence tracking
+  systemPrompt += '\n\n'
+    + '[STRUCTURED OUTPUT FORMAT]\n'
+    + 'You MUST wrap your response in JSON format inside a markdown code block:\n'
+    + '\`\`\`json\n'
+    + '{\n'
+    + '  "answer": "<your full answer here>",\n'
+    + '  "confidence": <0.0 to 1.0>,\n'
+    + '  "reasoning_summary": "<1-2 sentence summary of your reasoning>",\n'
+    + '  "risk_flags": ["<optional flags: speculative, outdated_knowledge, incomplete_context, conflicting_evidence, domain_mismatch>"]\n'
+    + '}\n'
+    + '\`\`\`\n'
+    + 'Confidence scale: 0.9-1.0 near certain, 0.7-0.89 high, 0.5-0.69 moderate, 0.3-0.49 low, 0.0-0.29 very low.';
+
+
+  return await llmProvider.chat(systemPrompt, prompt, { maxTokens: 8192, agentTag: AGENT_CARD.name });
+}
+

package/src/legion/agents/tempest.mjs

@@ -0,0 +1,211 @@
+/**
+ * ┌─────────────────────────────────────────────┐
+ * │  ╔╦╗╔═╗╔╦╗╔═╗╔═╗╔═╗╔╦╗                     │
+ * │   ║ ║╣ ║║║╠═╝║╣ ╚═╗ ║                      │
+ * │   ╩ ╚═╝╩ ╩╩  ╚═╝╚═╝ ╩                      │
+ * │  Weather & Climate Analyst                   │
+ * │  Origin: The Tempest (Shakespeare)           │
+ * │  "Reads the sky before it speaks"            │
+ * └─────────────────────────────────────────────┘
+ *
+ * Weather data agent powered by Open-Meteo (free, no API key).
+ * Fetches geocoding + forecast data, then uses LLM to analyze and present.
+ *
+ * Parent agent: ORACLE (analytics)
+ */
+
+export var AGENT_CARD = {
+  name: 'tempest',
+  displayName: 'TEMPEST',
+  category: 'analytics',
+  origin: 'The Tempest (Shakespeare)',
+  tagline: 'Reads the sky before it speaks',
+  capabilities: [
+    'weather-forecast',
+    'climate-analysis',
+    'temperature-trends',
+    'precipitation-analysis',
+    'weather-alerts',
+    'travel-weather',
+  ],
+  inputTypes: ['text', 'location'],
+  outputTypes: ['forecast', 'analysis', 'report'],
+  parentAgent: 'oracle',
+};
+
+export var SYSTEM_PROMPT =
+  'You are TEMPEST, a senior meteorological intelligence analyst with expertise spanning synoptic meteorology, ' +
+  'mesoscale dynamics, and applied climatology. You interpret atmospheric data with the rigor of a National Weather Service ' +
+  'forecaster and the strategic insight of an operational risk analyst.\n\n' +
+
+  'CORE KNOWLEDGE DOMAINS:\n' +
+  '- Synoptic meteorology: pressure systems (cyclones, anticyclones), frontal analysis (cold, warm, occluded, stationary), ' +
+  'jet stream positioning, upper-level troughs and ridges, atmospheric rivers, and teleconnection patterns (NAO, ENSO, PNA).\n' +
+  '- Mesoscale dynamics: sea breezes, mountain-valley winds, urban heat islands, lake-effect precipitation, ' +
+  'convective initiation (CAPE, CIN, LFC, LCL analysis), and severe weather parameters (SPC mesoanalysis equivalents).\n' +
+  '- Climate analysis: Koppen-Geiger classification, seasonal normals vs anomalies, climate trend detection, ' +
+  'return-period statistics for extreme events (GEV distribution), and growing degree-day calculations.\n' +
+  '- Applied meteorology: aviation weather (METAR/TAF interpretation, ceiling/visibility categories), ' +
+  'marine forecasting (Beaufort scale, wave height estimation), agricultural meteorology (frost risk, evapotranspiration), ' +
+  'and outdoor event planning (heat index, wind chill, wet-bulb globe temperature).\n\n' +
+
+  'SYSTEMATIC METHODOLOGY:\n' +
+  '1. Data assessment: Evaluate available data quality — API freshness, spatial resolution, temporal coverage. Flag gaps.\n' +
+  '2. Current conditions analysis: Decode weather codes (WMO 4677), assess comfort indices, identify hazardous conditions.\n' +
+  '3. Forecast interpretation: Analyze multi-day trends, identify pattern changes (frontal passages, regime shifts), ' +
+  'assign confidence levels (high >80%, moderate 50-80%, low <50%) based on model agreement and forecast range.\n' +
+  '4. Risk assessment: Flag severe weather potential (thunderstorms, extreme heat/cold, flooding, high winds), ' +
+  'assign impact severity, and provide actionable mitigation advice.\n' +
+  '5. Contextual recommendations: Tailor output to use case — travel planning, outdoor events, agriculture, construction.\n\n' +
+
+  'OUTPUT FORMAT:\n' +
+  '- Location context: coordinates, elevation, climate zone, timezone\n' +
+  '- Current conditions: temperature, humidity, wind, weather description, comfort index\n' +
+  '- Forecast summary: day-by-day with confidence levels and key transitions\n' +
+  '- Risk alerts: severity (Watch/Warning/Advisory), probability, timing, recommended actions\n' +
+  '- Practical recommendations: specific to the user query context\n\n' +
+
+  'ANTI-PATTERNS:\n' +
+  '- NEVER present forecasts beyond 7 days as reliable — skill drops sharply past day 5.\n' +
+  '- NEVER ignore microclimate effects (elevation, coastal proximity, urban heat) when interpreting point forecasts.\n' +
+  '- NEVER conflate climate averages with weather predictions.\n\n' +
+
+  'INTER-AGENT COORDINATION:\n' +
+  'Feed ORACLE with quantified weather data for decision-support analysis. ' +
+  'Collaborate with CARTOGRAPHER for location context enrichment. ' +
+  'Alert CASSANDRA when extreme weather risk could impact proposed plans.';
+
+async function fetchWeather(location) {
+  try {
+    // Step 1: Geocode the location
+    var geoRes = await fetch(
+      'https://geocoding-api.open-meteo.com/v1/search?name=' +
+      encodeURIComponent(location) + '&count=1&language=en&format=json'
+    );
+    if (!geoRes.ok) return null;
+    var geoData = await geoRes.json();
+    if (!geoData.results || geoData.results.length === 0) return null;
+
+    var place = geoData.results[0];
+    var lat = place.latitude;
+    var lon = place.longitude;
+
+    // Step 2: Get forecast
+    var wxRes = await fetch(
+      'https://api.open-meteo.com/v1/forecast?latitude=' + lat + '&longitude=' + lon +
+      '&daily=temperature_2m_max,temperature_2m_min,precipitation_sum,windspeed_10m_max,weathercode' +
+      '&current=temperature_2m,relative_humidity_2m,windspeed_10m,weathercode' +
+      '&timezone=auto&forecast_days=7'
+    );
+    if (!wxRes.ok) return null;
+    var wxData = await wxRes.json();
+
+    return {
+      location: place.name + (place.admin1 ? ', ' + place.admin1 : '') + ', ' + place.country,
+      latitude: lat,
+      longitude: lon,
+      current: wxData.current || null,
+      daily: wxData.daily || null,
+      timezone: wxData.timezone || 'UTC',
+    };
+  } catch {
+    return null;
+  }
+}
+
+function extractLocation(text) {
+  // Try to extract location from common patterns
+  var patterns = [
+    /weather (?:in|for|at) ([A-Za-z\s,]+?)(?:\?|$|\.|\n)/i,
+    /forecast (?:in|for|at) ([A-Za-z\s,]+?)(?:\?|$|\.|\n)/i,
+    /climate (?:in|of|for) ([A-Za-z\s,]+?)(?:\?|$|\.|\n)/i,
+    /temperature (?:in|at) ([A-Za-z\s,]+?)(?:\?|$|\.|\n)/i,
+    /(?:^|\s)((?:[A-Z][a-z]+\s?)+(?:,\s?[A-Z][a-z]+)*)(?:\s|$)/,
+  ];
+  for (var i = 0; i < patterns.length; i++) {
+    var m = text.match(patterns[i]);
+    if (m && m[1] && m[1].trim().length > 1) return m[1].trim();
+  }
+  return null;
+}
+
+export async function execute(task, context, llmProvider) {
+  var prompt = 'Task: ' + task.description;
+
+  // Task dependency results from previous sub-tasks
+  if (context.dependencyResults && Object.keys(context.dependencyResults).length > 0) {
+    prompt += '\n[DEPENDENCY CONTEXT — Results from prerequisite tasks]\n';
+    var keys = Object.keys(context.dependencyResults);
+    for (var i = 0; i < keys.length; i++) {
+      prompt += '--- Result from ' + keys[i] + ' ---\n' + context.dependencyResults[keys[i]];
+    }
+  }
+
+  // Original user request — always useful for maintaining big-picture awareness
+  if (context.originalPrompt) {
+    prompt += '\n[ORIGINAL REQUEST]\n' + context.originalPrompt;
+  }
+
+  // v5.0+: Collective intelligence context (structured framing)
+  if (context.workspaceSnapshot) {
+    prompt += '\n[SHARED WORKSPACE — Live collaborative state from all agents]\n' + context.workspaceSnapshot;
+  }
+  if (context.episodicMemories) {
+    prompt += '\n[EPISODIC MEMORY — Your relevant past experiences on similar tasks]\n' + context.episodicMemories;
+  }
+  if (context.eventStream) {
+    prompt += '\n[COMMUNICATION STREAM — Recent inter-agent signals and events]\n' + context.eventStream;
+  }
+  if (context.knowledgeGraph) {
+    prompt += '\n[KNOWLEDGE GRAPH — Known relationships between agents, capabilities, and domains]\n' + context.knowledgeGraph;
+  }
+  if (context.latentSpaceInsight) {
+    prompt += '\n[LATENT SPACE — Emergent patterns detected across the collective]\n' + context.latentSpaceInsight;
+  }
+
+  // v7.0: Deliberation cross-reading — other agents' proposals
+  if (context.proposalContext) {
+    prompt += '\n[DELIBERATION — Cross-Reading Round]\n' + context.proposalContext;
+    prompt += '\n\n[DELIBERATION INSTRUCTIONS — TEMPEST STRESS TEST MODE]\n'
+      + 'You are in a multi-round deliberation. Other agents have shared their proposals above. '
+      + 'Your role is STRESS TESTER. You MUST:\n'
+      + '1. Stress-test every proposal under extreme conditions — what breaks first?\n'
+      + '2. Challenge optimistic assumptions: [STRESS-TEST: agent_name proposal X assumes normal conditions but fails under load/pressure/adversity Y]\n'
+      + '3. Provide worst-case scenarios: [WORST-CASE: if conditions X occur, proposal Y leads to outcome Z]\n'
+      + '4. Evaluate resilience: [RESILIENCE-SCORE: proposal X recovers from failure mode Y but not from Z]\n'
+      + '5. When proposals assume best-case scenarios, inject realistic failure modes\n'
+      + '6. Do NOT converge on fragile solutions — robustness under stress is mandatory\n';
+  }
+
+  // v5.0+: Self-modification — apply learned evolution patterns to system prompt
+  var systemPrompt = SYSTEM_PROMPT;
+  if (context.promptEvolution) {
+    systemPrompt += '\n[EVOLVED CAPABILITIES — Patterns learned from past performance]\n' + context.promptEvolution;
+  }
+
+  // v8.0: Geth Consensus participation clause
+  systemPrompt += '\n\n[GETH CONSENSUS PROTOCOL]\n'
+    + 'You are the stress tester in a multi-agent collective. '
+    + 'Your value is finding breaking points before they break in production. '
+    + 'Challenge optimistic proposals with realistic failure scenarios. '
+    + 'Robustness under stress is worth more than elegance under ideal conditions.';
+
+  
+  // v10.0: Neural Controller — Structured Output for confidence tracking
+  systemPrompt += '\n\n'
+    + '[STRUCTURED OUTPUT FORMAT]\n'
+    + 'You MUST wrap your response in JSON format inside a markdown code block:\n'
+    + '\`\`\`json\n'
+    + '{\n'
+    + '  "answer": "<your full answer here>",\n'
+    + '  "confidence": <0.0 to 1.0>,\n'
+    + '  "reasoning_summary": "<1-2 sentence summary of your reasoning>",\n'
+    + '  "risk_flags": ["<optional flags: speculative, outdated_knowledge, incomplete_context, conflicting_evidence, domain_mismatch>"]\n'
+    + '}\n'
+    + '\`\`\`\n'
+    + 'Confidence scale: 0.9-1.0 near certain, 0.7-0.89 high, 0.5-0.69 moderate, 0.3-0.49 low, 0.0-0.29 very low.';
+
+
+  return await llmProvider.chat(systemPrompt, prompt, { maxTokens: 8192, agentTag: AGENT_CARD.name });
+}
+