daemora 1.0.4 → 1.0.6

package/skills/webapp-testing/scripts/with_server.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+Start one or more servers, wait for them to be ready, run a command, then clean up.
+
+Usage:
+    # Single server
+    python scripts/with_server.py --server "npm run dev" --port 5173 -- python automation.py
+    python scripts/with_server.py --server "npm start" --port 3000 -- python test.py
+
+    # Multiple servers
+    python scripts/with_server.py \
+      --server "cd backend && python server.py" --port 3000 \
+      --server "cd frontend && npm run dev" --port 5173 \
+      -- python test.py
+"""
+
+import subprocess
+import socket
+import time
+import sys
+import argparse
+
+def is_server_ready(port, timeout=30):
+    """Wait for server to be ready by polling the port."""
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        try:
+            with socket.create_connection(('localhost', port), timeout=1):
+                return True
+        except (socket.error, ConnectionRefusedError):
+            time.sleep(0.5)
+    return False
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Run command with one or more servers')
+    parser.add_argument('--server', action='append', dest='servers', required=True, help='Server command (can be repeated)')
+    parser.add_argument('--port', action='append', dest='ports', type=int, required=True, help='Port for each server (must match --server count)')
+    parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds per server (default: 30)')
+    parser.add_argument('command', nargs=argparse.REMAINDER, help='Command to run after server(s) ready')
+
+    args = parser.parse_args()
+
+    # Remove the '--' separator if present
+    if args.command and args.command[0] == '--':
+        args.command = args.command[1:]
+
+    if not args.command:
+        print("Error: No command specified to run")
+        sys.exit(1)
+
+    # Parse server configurations
+    if len(args.servers) != len(args.ports):
+        print("Error: Number of --server and --port arguments must match")
+        sys.exit(1)
+
+    servers = []
+    for cmd, port in zip(args.servers, args.ports):
+        servers.append({'cmd': cmd, 'port': port})
+
+    server_processes = []
+
+    try:
+        # Start all servers
+        for i, server in enumerate(servers):
+            print(f"Starting server {i+1}/{len(servers)}: {server['cmd']}")
+
+            # Use shell=True to support commands with cd and &&
+            process = subprocess.Popen(
+                server['cmd'],
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            server_processes.append(process)
+
+            # Wait for this server to be ready
+            print(f"Waiting for server on port {server['port']}...")
+            if not is_server_ready(server['port'], timeout=args.timeout):
+                raise RuntimeError(f"Server failed to start on port {server['port']} within {args.timeout}s")
+
+            print(f"Server ready on port {server['port']}")
+
+        print(f"\nAll {len(servers)} server(s) ready")
+
+        # Run the command
+        print(f"Running: {' '.join(args.command)}\n")
+        result = subprocess.run(args.command)
+        sys.exit(result.returncode)
+
+    finally:
+        # Clean up all servers
+        print(f"\nStopping {len(server_processes)} server(s)...")
+        for i, process in enumerate(server_processes):
+            try:
+                process.terminate()
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                process.wait()
+            print(f"Server {i+1} stopped")
+        print("All servers stopped")
+
+
+if __name__ == '__main__':
+    main()

package/src/agents/SubAgentManager.js

@@ -1,11 +1,14 @@
 import { runAgentLoop } from "../core/AgentLoop.js";
-import { buildSystemPrompt } from "../systemPrompt.js";
+import { buildSystemPrompt } from "./systemPrompt.js";
 import { toolFunctions } from "../tools/index.js";
 import { agentProfiles, defaultSubAgentTools } from "../config/agentProfiles.js";
+import { config } from "../config/default.js";
 import eventBus from "../core/EventBus.js";
 import { v4 as uuidv4 } from "uuid";
 import tenantContext from "../tenants/TenantContext.js";
 import { resolveModelForProfile } from "../models/ModelRouter.js";
+import { createSession, getSession, setMessages } from "../services/sessions.js";
+import skillLoader from "../skills/SkillLoader.js";
 
 /**
  * Sub-Agent Manager - spawns, tracks, kills, and steers sub-agents.
@@ -27,6 +30,27 @@ import { resolveModelForProfile } from "../models/ModelRouter.js";
 
 const MAX_CONCURRENT_SUB_AGENTS = 7;
 
+/**
+ * Resolve sub-agent model. Priority:
+ *   1. Profile-specific route (tenant modelRoutes[profile] or CODE_MODEL/etc env)
+ *   2. SUB_AGENT_MODEL (tenant-level or env-level)
+ *   3. Parent agent's model (inherit from main agent)
+ *   4. DEFAULT_MODEL
+ */
+function _resolveSubAgentModel(profile, tenantConfig, parentModel) {
+  const _profileEnvMap = { coder: "CODE_MODEL", researcher: "RESEARCH_MODEL", writer: "WRITER_MODEL", analyst: "ANALYST_MODEL" };
+  // 1. Profile-specific
+  if (profile && tenantConfig.modelRoutes?.[profile]) return tenantConfig.modelRoutes[profile];
+  if (profile && process.env[_profileEnvMap[profile]]) return process.env[_profileEnvMap[profile]];
+  // 2. Sub-agent model (tenant > env)
+  if (tenantConfig.subAgentModel) return tenantConfig.subAgentModel;
+  if (process.env.SUB_AGENT_MODEL) return process.env.SUB_AGENT_MODEL;
+  // 3. Parent's model — sub-agents default to the same model as the main agent
+  if (parentModel) return parentModel;
+  // 4. Global default
+  return config.defaultModel;
+}
+
 /** Map<agentId, { taskDescription, startedAt, parentTaskId, abortController, steerQueue }> */
 const activeSubAgents = new Map();
 
@@ -81,6 +105,7 @@ eventBus.on("supervisor:kill", ({ taskId }) => {
  * @param {number}   [options.depth]               Recursion depth (managed internally)
  * @param {string}   [options.parentTaskId]        Parent task ID for kill propagation
  * @param {string}   [options.parentContext]       Summary/context from parent agent
+ * @param {string[]} [options.skills]              Skill paths to inject (e.g. ["skills/coding.md", "skills/brand-guidelines.md"])
  * @param {string}   [options.approvalMode]        Inherited approval mode
  * @param {object}   [options.channelMeta]         Inherited channel meta for approvals
  * @returns {Promise<string>} Sub-agent's final response
@@ -94,12 +119,15 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     toolOverride         = null,        // exact tool functions - specialist agents only (e.g. MCP)
     systemPromptOverride = null,        // replace system prompt - specialist agents only
     maxCost              = 0.10,
-    timeout              = 120_000,
+    timeout              = 300_000,
     depth                = 0,
     parentTaskId         = null,
     parentContext        = null,
+    skills               = null,        // explicit skill paths to inject (e.g. ["skills/coding.md"])
     approvalMode         = "auto",
     channelMeta          = null,
+    historyMessages      = [],     // previous session messages to prepend (persistent sub-agent sessions)
+    returnFullResult     = false,  // return {text, messages, cost} instead of just text
   } = options;
 
   const maxDepth = 3;
@@ -114,17 +142,18 @@ export async function spawnSubAgent(taskDescription, options = {}) {
   const agentId = uuidv4().slice(0, 8);
   const taskId  = `subagent-${agentId}`;
 
+  // ── Model resolution ────────────────────────────────────────────────────
+  // Priority: explicit > profile route > SUB_AGENT_MODEL > parent's model > DEFAULT_MODEL
+  const store = tenantContext.getStore();
+  const parentModel = store?.resolvedModel || null;
+  const resolvedModel = model
+    || _resolveSubAgentModel(profile, store?.resolvedConfig || {}, parentModel);
+
   const profileLabel = profile ? ` [${profile}]` : "";
   const modelLabel   = resolvedModel ? ` ${C.dim}(${resolvedModel})${C.reset}` : "";
   _agentLog(C.cyan + C.bold, "🤖 SPAWN", agentId, depth,
     `${C.cyan}${C.bold}${profileLabel}${C.reset}${modelLabel} "${taskDescription.slice(0, 80)}${taskDescription.length > 80 ? "…" : ""}"`);
 
-  // ── Model resolution - priority: explicit > profile routing > parent > global default ───────
-  const store = tenantContext.getStore();
-  const resolvedModel = model
-    || resolveModelForProfile(profile, store?.resolvedConfig || {}, null)
-    || store?.resolvedModel
-    || config.defaultModel;
 
   const apiKeys = store?.apiKeys || {};
 
@@ -229,14 +258,77 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     taskDescription: taskDescription.slice(0, 100),
   });
 
-  // ── Build initial messages (optionally include parent context) ────────────
-  const initialMessages = [];
+  // ── Auto session load for regular sub-agents (not MCP — they manage their own) ──
+  const mainSessionId = store?.sessionId || null;
+  const shouldManageSession = !toolOverride && historyMessages.length === 0 && mainSessionId;
+  let subSessionId = null;
+
+  if (shouldManageSession) {
+    const sessionKey = profile || "general";
+    subSessionId = `${mainSessionId}--${sessionKey}`;
+    const subSession = getSession(subSessionId);
+    if (subSession && subSession.messages.length > 0) {
+      historyMessages = subSession.messages.map(m => ({ role: m.role, content: m.content }));
+      console.log(`[SubAgent:${agentId}] Loaded ${historyMessages.length} history messages from "${subSessionId}"`);
+    }
+  }
+
+  // ── Skill injection ─────────────────────────────────────────────────────
+  // Priority: 1) Explicit skills passed by parent  2) Semantic embedding search
+  // Both produce full skill content so the sub-agent doesn't waste a readFile turn.
+  let skillContext = "";
+  try {
+    const injectedSkills = [];
+
+    // 1. Explicit skills — parent agent passed skill paths/names directly
+    if (skills && skills.length > 0) {
+      for (const ref of skills) {
+        const skill = skillLoader.getSkill(ref);
+        if (skill) {
+          injectedSkills.push(skill);
+        } else {
+          console.log(`[SubAgent:${agentId}] Skill not found: "${ref}"`);
+        }
+      }
+    }
+
+    // 2. Semantic embedding search — find relevant skills the parent didn't explicitly pass
+    if (injectedSkills.length === 0 && taskDescription) {
+      const semanticResult = await skillLoader.getSkillPromptsAsync(taskDescription);
+      if (semanticResult) {
+        // getSkillPromptsAsync returns formatted string with --- Skill: name --- blocks
+        skillContext = semanticResult;
+      }
+    }
+
+    // Format explicitly-passed skills
+    if (injectedSkills.length > 0) {
+      skillContext = injectedSkills.map(s =>
+        `\n--- Skill: ${s.name} ---\n${s.content}\n--- End Skill ---`
+      ).join("\n");
+    }
+
+    if (injectedSkills.length > 0) {
+      console.log(`[SubAgent:${agentId}] Injected ${injectedSkills.length} skill(s) (explicit): ${injectedSkills.map(s => s.name).join(", ")}`);
+    } else if (skillContext) {
+      console.log(`[SubAgent:${agentId}] Injected skills (semantic embedding match)`);
+    }
+  } catch (e) {
+    // Non-blocking — skills are optional
+    console.log(`[SubAgent:${agentId}] Skill injection failed (non-blocking): ${e.message}`);
+  }
 
-  if (parentContext) {
-    // Give the sub-agent a quick summary of what the parent knows
+  // ── Build initial messages (include history + parent context + skills) ──
+  const initialMessages = [...historyMessages];
+
+  const contextParts = [];
+  if (parentContext) contextParts.push(`[Context from parent agent]:\n${parentContext}`);
+  if (skillContext) contextParts.push(`[Matched Skills — follow these instructions precisely]:\n${skillContext}`);
+
+  if (contextParts.length > 0) {
     initialMessages.push({
       role: "user",
-      content: `[Context from parent agent]:\n${parentContext}\n\n[Your task]:\n${taskDescription}`,
+      content: `${contextParts.join("\n\n")}\n\n[Your task]:\n${taskDescription}`,
     });
   } else {
     initialMessages.push({ role: "user", content: taskDescription });
@@ -249,7 +341,11 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     const result = await Promise.race([
       runAgentLoop({
         messages:     initialMessages,
-        systemPrompt: systemPromptOverride || await buildSystemPrompt(taskDescription),
+        systemPrompt: systemPromptOverride || await buildSystemPrompt(taskDescription, "minimal", {
+          model: resolvedModel,
+          agentId,
+          taskDescription,
+        }),
         tools:        agentTools,
         modelId:      resolvedModel,
         taskId,
@@ -268,10 +364,32 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     ]);
 
     const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
-    const costStr = result.cost ? ` $${result.cost.toFixed(4)}` : "";
+    const costVal = typeof result.cost === "number" ? result.cost : result.cost?.estimatedCost;
+    const costStr = costVal ? ` $${costVal.toFixed(4)}` : "";
     _agentLog(C.green + C.bold, "✅ DONE ", agentId, depth,
       `${C.green}${C.bold}completed in ${elapsed}s${costStr}${C.reset}`);
-    eventBus.emitEvent("agent:finished", { agentId, taskId, parentTaskId, cost: result.cost });
+    eventBus.emitEvent("agent:finished", {
+      agentId, taskId, parentTaskId, cost: result.cost,
+      toolCalls: (result.toolCalls || []).map(tc => ({ tool: tc.tool, duration: tc.duration })),
+      resultPreview: (result.text || "").slice(0, 200),
+      model: resolvedModel,
+      role: profile || "general",
+    });
+
+    // ── Auto session save for regular sub-agents ──────────────────────────
+    if (subSessionId && result.messages) {
+      let subSession = getSession(subSessionId);
+      if (!subSession) subSession = createSession(subSessionId);
+      const capped = result.messages.length > 100
+        ? result.messages.slice(-100)
+        : result.messages;
+      setMessages(subSessionId, capped);
+      console.log(`[SubAgent:${agentId}] Saved ${capped.length} messages to "${subSessionId}"`);
+    }
+
+    if (returnFullResult) {
+      return { text: result.text, messages: result.messages, cost: result.cost };
+    }
     return result.text;
 
   } catch (error) {