daemora 1.0.1 → 1.0.3

package/src/skills/SkillLoader.js

@@ -1,15 +1,19 @@
-import { readFileSync, readdirSync, existsSync, statSync, watchFile } from "fs";
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from "fs";
 import { join } from "path";
+import { createHash } from "node:crypto";
 import { config } from "../config/default.js";
+import { generateEmbedding, getEmbeddingProvider } from "../utils/Embeddings.js";
 
 /**
- * Skill Loader — auto-discovers .md skill files from the skills/ directory.
+ * Skill Loader - auto-discovers .md skill files from the skills/ directory.
  *
  * Each skill file has YAML frontmatter (name, description, triggers)
  * followed by the skill prompt content.
  *
- * Skills are injected into the system prompt when their description
- * matches the current task context.
+ * Skills are matched to tasks via:
+ *  1. Semantic (embeddings) - cosine similarity on OpenAI text-embedding-3-small vectors.
+ *     Vectors are cached in data/skill-embeddings.json, recomputed only when skill content changes.
+ *  2. Keyword fallback - simple trigger/description word matching when no API key is set.
  *
  * Format:
  * ```markdown
@@ -22,10 +26,14 @@ import { config } from "../config/default.js";
  * ```
  */
 
+const SKILL_EMBEDDINGS_PATH = join(config.dataDir, "skill-embeddings.json");
+const EMBED_THRESHOLD = 0.32;  // Lower than memory (0.40) - skill descriptions are shorter
+
 class SkillLoader {
   constructor() {
     this.skills = new Map();
     this.loaded = false;
+    this._skillVectors = {};  // { skillName: { hash, vector } }
   }
 
   /**
@@ -56,6 +64,7 @@ class SkillLoader {
     }
 
     this.loaded = true;
+    this._loadSkillVectors();
     console.log(
       `[SkillLoader] Loaded ${this.skills.size} skills: ${[...this.skills.keys()].join(", ") || "(none)"}`
     );
@@ -67,7 +76,6 @@ class SkillLoader {
   parseSkill(content, filename) {
     const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
     if (!fmMatch) {
-      // No frontmatter — use filename as name
       return {
         name: filename.replace(".md", ""),
         description: "",
@@ -100,6 +108,137 @@ class SkillLoader {
     };
   }
 
+  // ── Embedding helpers ────────────────────────────────────────────────────────
+
+  _contentHash(skill) {
+    // Include provider so cache auto-invalidates when user switches embedding provider
+    const provider = getEmbeddingProvider() || "none";
+    return createHash("sha1")
+      .update(`${provider}|${skill.name}|${skill.description}|${skill.triggers.join(",")}|${skill.content}`)
+      .digest("hex")
+      .slice(0, 16);
+  }
+
+  _loadSkillVectors() {
+    if (!existsSync(SKILL_EMBEDDINGS_PATH)) return;
+    try {
+      this._skillVectors = JSON.parse(readFileSync(SKILL_EMBEDDINGS_PATH, "utf-8"));
+    } catch {
+      this._skillVectors = {};
+    }
+  }
+
+  _saveSkillVectors() {
+    try {
+      mkdirSync(config.dataDir, { recursive: true });
+      writeFileSync(SKILL_EMBEDDINGS_PATH, JSON.stringify(this._skillVectors));
+    } catch {}
+  }
+
+  _generateEmbedding(text) {
+    return generateEmbedding(text);
+  }
+
+  _cosineSim(a, b) {
+    let dot = 0, na = 0, nb = 0;
+    for (let i = 0; i < a.length; i++) {
+      dot += a[i] * b[i];
+      na  += a[i] * a[i];
+      nb  += b[i] * b[i];
+    }
+    if (!na || !nb) return 0;
+    return dot / (Math.sqrt(na) * Math.sqrt(nb));
+  }
+
+  // ── Public async API ─────────────────────────────────────────────────────────
+
+  /**
+   * Pre-compute and cache embeddings for all loaded skills.
+   * Called once at startup as fire-and-forget. Only re-embeds skills whose content changed.
+   */
+  async embedSkills() {
+    if (!getEmbeddingProvider()) return;
+    if (!this.loaded) this.load();
+
+    let changed = false;
+
+    for (const [name, skill] of this.skills) {
+      const hash = this._contentHash(skill);
+      if (this._skillVectors[name]?.hash === hash) continue;  // Cache hit - skip
+
+      // Text to embed: name + description + triggers + first 500 chars of body
+      const text = [
+        `Skill: ${skill.name}`,
+        `Description: ${skill.description}`,
+        `Triggers: ${skill.triggers.join(", ")}`,
+        skill.content.slice(0, 500),
+      ].join("\n");
+
+      const vector = await this._generateEmbedding(text);
+      if (vector) {
+        this._skillVectors[name] = { hash, vector };
+        changed = true;
+        console.log(`[SkillLoader] Embedded skill: ${name}`);
+      }
+    }
+
+    // Remove cached vectors for skills that no longer exist
+    for (const name of Object.keys(this._skillVectors)) {
+      if (!this.skills.has(name)) {
+        delete this._skillVectors[name];
+        changed = true;
+      }
+    }
+
+    if (changed) this._saveSkillVectors();
+  }
+
+  /**
+   * Semantic skill matching - embeds the task input and returns skills above cosine threshold.
+   * Falls back to keyword matching if OPENAI_API_KEY is absent or embeddings aren't ready.
+   *
+   * Returns top-5 matched skills, sorted by relevance score (highest first).
+   */
+  async getSkillPromptsAsync(taskInput) {
+    if (!taskInput) return "";
+    if (!this.loaded) this.load();
+
+    const vectorsAvailable = Object.keys(this._skillVectors).length > 0;
+
+    if (getEmbeddingProvider() && vectorsAvailable) {
+      const queryVector = await this._generateEmbedding(taskInput);
+      if (queryVector) {
+        const scored = [];
+
+        for (const [name, skill] of this.skills) {
+          const cached = this._skillVectors[name];
+          if (!cached?.vector) continue;
+          const score = this._cosineSim(queryVector, cached.vector);
+          if (score >= EMBED_THRESHOLD) {
+            scored.push({ skill, score });
+          }
+        }
+
+        scored.sort((a, b) => b.score - a.score);
+        const matched = scored.slice(0, 5).map((s) => s.skill);
+
+        if (matched.length > 0) {
+          console.log(
+            `[SkillLoader] Semantic match (${matched.length}): ${matched.map((s) => s.name).join(", ")}`
+          );
+          return matched
+            .map((s) => `\n--- Skill: ${s.name} ---\n${s.content}\n--- End Skill ---`)
+            .join("\n");
+        }
+      }
+    }
+
+    // Fallback: keyword matching
+    return this.getSkillPrompts(taskInput);
+  }
+
+  // ── Sync keyword API (fallback) ───────────────────────────────────────────────
+
   /**
    * Match skills relevant to a given task/message.
    * Returns skill contents to inject into the system prompt.
@@ -111,10 +250,8 @@ class SkillLoader {
     const matched = [];
 
     for (const [name, skill] of this.skills) {
-      // Check triggers
       const triggerMatch = skill.triggers.some((t) => input.includes(t));
 
-      // Check description keywords
       const descWords = skill.description.toLowerCase().split(/\s+/);
       const descMatch = descWords.some(
         (w) => w.length > 3 && input.includes(w)
@@ -129,7 +266,7 @@ class SkillLoader {
   }
 
   /**
-   * Get skill prompt text for matched skills.
+   * Get skill prompt text for matched skills (sync keyword version).
    */
   getSkillPrompts(taskInput) {
     const matched = this.matchSkills(taskInput);

package/src/storage/TaskStore.js

@@ -43,27 +43,51 @@ export function listTasks({ limit = 20, status = null } = {}) {
 
 /**
  * On startup, find tasks stuck in "running" state and reset to "pending".
+ * Returns the count of tasks reset so the caller can log accordingly.
  */
 export function recoverStaleTasks() {
-  const files = readdirSync(TASKS_DIR).filter((f) => f.endsWith(".json"));
   let recovered = 0;
-
-  for (const f of files) {
-    try {
-      const task = JSON.parse(readFileSync(`${TASKS_DIR}/${f}`, "utf-8"));
-      if (task.status === "running") {
-        task.status = "pending";
-        task.startedAt = null;
-        writeFileSync(`${TASKS_DIR}/${f}`, JSON.stringify(task, null, 2));
-        recovered++;
-        console.log(`[TaskStore] Recovered stale task: ${task.id}`);
+  try {
+    const files = readdirSync(TASKS_DIR).filter((f) => f.endsWith(".json"));
+    for (const f of files) {
+      try {
+        const task = JSON.parse(readFileSync(`${TASKS_DIR}/${f}`, "utf-8"));
+        if (task.status === "running") {
+          task.status = "pending";
+          task.startedAt = null;
+          writeFileSync(`${TASKS_DIR}/${f}`, JSON.stringify(task, null, 2));
+          recovered++;
+          console.log(`[TaskStore] Recovered stale task: ${task.id}`);
+        }
+      } catch {
+        // skip corrupt files
       }
-    } catch {
-      // skip corrupt files
     }
+  } catch {
+    // TASKS_DIR may not exist yet on first run
   }
+  return recovered;
+}
 
-  if (recovered > 0) {
-    console.log(`[TaskStore] Recovered ${recovered} stale task(s)`);
+/**
+ * Load all tasks currently in "pending" state from disk, sorted oldest-first.
+ * Used by TaskQueue.init() to re-hydrate the in-memory queue after a restart.
+ */
+export function loadPendingTasks() {
+  try {
+    const files = readdirSync(TASKS_DIR).filter((f) => f.endsWith(".json"));
+    return files
+      .map((f) => {
+        try { return JSON.parse(readFileSync(`${TASKS_DIR}/${f}`, "utf-8")); }
+        catch { return null; }
+      })
+      .filter((t) => t && t.status === "pending")
+      .sort((a, b) => {
+        // Sort by priority first (lower number = higher priority), then by createdAt (oldest first)
+        if (a.priority !== b.priority) return (a.priority || 5) - (b.priority || 5);
+        return new Date(a.createdAt) - new Date(b.createdAt);
+      });
+  } catch {
+    return [];
   }
 }

package/src/systemPrompt.js

@@ -6,6 +6,7 @@ import mcpManager from "./mcp/MCPManager.js";
 import tenantContext from "./tenants/TenantContext.js";
 
 skillLoader.load();
+skillLoader.embedSkills().catch(() => {});  // Pre-compute skill embeddings at startup (fire-and-forget)
 
 /**
  * Build the system prompt dynamically by composing modular sections.
@@ -48,7 +49,7 @@ function _getContextMemoryPaths() {
 /**
  * Inject the top-k most semantically relevant memories for this specific task.
  * Only runs when OPENAI_API_KEY is set and the embeddings store has entries.
- * Falls back silently — never blocks startup or errors out.
+ * Falls back silently - never blocks startup or errors out.
  */
 async function renderSemanticRecall(taskInput) {
   if (!taskInput || taskInput.length < 10) return null;
@@ -101,7 +102,7 @@ You MUST respond with a JSON object matching this exact schema on every turn:
 - Set finalResponse to true
 
 ## CRITICAL RULES:
-1. NEVER set finalResponse to true unless the work is VERIFIED complete — not just written, but confirmed working.
+1. NEVER set finalResponse to true unless the work is VERIFIED complete - not just written, but confirmed working.
 2. If the user asks you to DO something (fix, create, edit, build, search, etc.), your FIRST response MUST be type "tool_call". Not text. Not a plan. A tool call.
 3. Chain multiple tool calls across turns. After each tool result, decide: need more tools? Call another. Done with verification? Set finalResponse true.
 4. If a tool fails, try an alternative approach. Do NOT give up and ask the user to do it manually.
@@ -245,15 +246,15 @@ Append to today's daily log. Use to track task progress and decisions.
 ### spawnAgent(taskDescription, optionsJson?)
 Spawn a sub-agent for a single task.
 - optionsJson: {"profile":"coder","extraTools":["sendEmail"],"parentContext":"spec string","model":"openai:gpt-4.1-mini"}
-- profile: "researcher" | "coder" | "writer" | "analyst" — focused tool set for the task type
+- profile: "researcher" | "coder" | "writer" | "analyst" - focused tool set for the task type
 - extraTools: add specific tools on top of the profile (e.g. researcher that also needs writeFile)
-- tools: explicit tool list — overrides profile entirely when you need exact control
-- taskDescription must be comprehensive — sub-agent has no other context
+- tools: explicit tool list - overrides profile entirely when you need exact control
+- taskDescription must be comprehensive - sub-agent has no other context
 
 ### parallelAgents(tasksJson, sharedOptionsJson?)
 Spawn multiple sub-agents in parallel. Each task can have its own profile.
-- tasksJson: array of {"description":"...","options":{"profile":"coder"}} — each must be self-contained
-- sharedOptionsJson: {"sharedContext":"..."} — spec/contract shared with ALL agents before their task
+- tasksJson: array of {"description":"...","options":{"profile":"coder"}} - each must be self-contained
+- sharedOptionsJson: {"sharedContext":"..."} - spec/contract shared with ALL agents before their task
 - Always pass workspace path in sharedContext when agents need to share artifacts via filesystem
 
 ### manageAgents(action, paramsJson?)
@@ -261,14 +262,14 @@ List, kill, or steer running sub-agents. action: "list"|"kill"|"steer". paramsJs
 
 ### useMCP(serverName, taskDescription)
 Delegate a task to a specialist agent for the named MCP server.
-- serverName: the MCP server to use — check "Connected MCP Servers" section for available servers
-- taskDescription: full task spec — the specialist has zero other context, include all details
+- serverName: the MCP server to use - check "Connected MCP Servers" section for available servers
+- taskDescription: full task spec - the specialist has zero other context, include all details
 - The specialist gets ONLY that server's tools: lean context, no noise from built-in tools
 
 ### manageMCP(action, paramsJson?)
 Inspect connected MCP servers and their available tools at runtime.
-- list / status: no params — all servers with connection status and tool names
-- tools: paramsJson {"server":"github"} — full tool list for one server, or {} for all
+- list / status: no params - all servers with connection status and tool names
+- tools: paramsJson {"server":"github"} - full tool list for one server, or {} for all
 
 ### delegateToAgent(agentUrl, taskInput)
 Delegate to an external AI agent via A2A protocol.
@@ -276,11 +277,11 @@ Delegate to an external AI agent via A2A protocol.
 ## Project Tracking
 
 ### projectTracker(action, paramsJson?)
-Track multi-step project progress. Persisted to disk — survives crashes and timeouts.
+Track multi-step project progress. Persisted to disk - survives crashes and timeouts.
 - createProject: paramsJson {"name":"...","description":"...","tasks":["step 1","step 2",...]}
 - addTask: paramsJson {"projectId":"...","title":"...","description":"..."}
 - updateTask: paramsJson {"projectId":"...","taskId":"t1","status":"in_progress|done|failed|skipped","notes":"..."}
-- getProject: paramsJson {"projectId":"..."} — shows ✅⬜🔄❌ status per task
+- getProject: paramsJson {"projectId":"..."} - shows ✅⬜🔄❌ status per task
 - listProjects: paramsJson {} or {"status":"in_progress|done"}
 - deleteProject: paramsJson {"projectId":"..."}
 
@@ -296,7 +297,7 @@ function renderMCPTools() {
 
   const serverList = servers
     .map((s) => {
-      const desc = s.description ? ` — ${s.description}` : "";
+      const desc = s.description ? ` - ${s.description}` : "";
       return `- **${s.name}**${desc} (${s.toolCount} tools: ${s.toolNames.join(", ")})`;
     })
     .join("\n");
@@ -308,7 +309,7 @@ The following MCP servers are connected. Use \`useMCP(serverName, taskDescriptio
 ${serverList}
 
 Use \`manageMCP("list")\` to check server connection status at any time.
-Do NOT call mcp__ tools directly — always route through \`useMCP\`. The specialist agent receives only that server's tools for focused, efficient execution.`;
+Do NOT call mcp__ tools directly - always route through \`useMCP\`. The specialist agent receives only that server's tools for focused, efficient execution.`;
 }
 
 function renderToolUsageRules() {
@@ -322,7 +323,7 @@ function renderToolUsageRules() {
 ## Choose the Right Tool
 - **Small, targeted change** (fix a line, rename a variable, replace a block): use editFile
 - **Major rewrite or adding lots of content** (new CSS sections, restructuring): use writeFile to rewrite the entire file
-- **editFile keeps failing?** Switch to writeFile — read the full file, modify the content, write it all back
+- **editFile keeps failing?** Switch to writeFile - read the full file, modify the content, write it all back
 - **Need to find something?** Use searchContent before reading multiple files
 - **Need file list?** Use listDirectory or searchFiles, not executeCommand("ls")
 
@@ -330,7 +331,7 @@ function renderToolUsageRules() {
 - If editFile fails because oldString wasn't found: re-read the file to get the exact current content, then retry
 - If editFile fails because params are wrong: remember it needs EXACTLY 3 string params (filePath, oldString, newString)
 - If a command fails: read the error, diagnose, try a different approach
-- NEVER tell the user to do something manually. You have tools — use them.
+- NEVER tell the user to do something manually. You have tools - use them.
 
 ## Don't Over-Engineer
 - Only make changes that are directly requested or clearly necessary.
@@ -338,7 +339,7 @@ function renderToolUsageRules() {
 - Don't add docstrings, comments, or type annotations to code you didn't change. Only add comments where the logic isn't self-evident.
 - Don't add error handling, fallbacks, or validation for scenarios that can't happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs).
 - Don't use feature flags or backwards-compatibility shims when you can just change the code.
-- Don't create helpers, utilities, or abstractions for one-time operations. Don't design for hypothetical future requirements. The right amount of complexity is the minimum needed — three similar lines of code is better than a premature abstraction.
+- Don't create helpers, utilities, or abstractions for one-time operations. Don't design for hypothetical future requirements. The right amount of complexity is the minimum needed - three similar lines of code is better than a premature abstraction.
 - Avoid backwards-compatibility hacks like renaming unused _vars, re-exporting types, adding "// removed" comments for removed code. If something is unused, delete it completely.
 - Do not create new files unless absolutely necessary. Prefer editing an existing file over creating a new one.
 
@@ -350,7 +351,7 @@ function renderToolUsageRules() {
 
 ## Quality Standards
 - Follow existing code conventions (naming, formatting, indentation, style).
-- Match the existing project's patterns — check surrounding code first.
+- Match the existing project's patterns - check surrounding code first.
 - Never assume a library is available without checking package.json or imports.
 - Prefer the simplest correct solution. Complexity is a cost, not a feature.
 
@@ -361,21 +362,21 @@ function renderToolUsageRules() {
 - Heavy task (3+ files, multi-agent, research then build, unclear scope): plan first using projectTracker, then execute.
 
 ### Planning workflow for heavy tasks
-1. Call projectTracker("createProject") — breaks work into tasks AND creates a shared workspace directory.
-2. The workspace path is returned — pass it in sharedContext so all sub-agents know where to write artifacts.
+1. Call projectTracker("createProject") - breaks work into tasks AND creates a shared workspace directory.
+2. The workspace path is returned - pass it in sharedContext so all sub-agents know where to write artifacts.
 3. Define the shared contract (API schema, DOM structure, naming conventions) before spawning agents.
 4. Mark each task in_progress before starting, done with notes when finished.
 5. If interrupted, call projectTracker("listProjects") to find and resume.
 
-### Parallel vs sequential — the decision rule
+### Parallel vs sequential - the decision rule
 - Ask: does task B need output from task A? Yes → sequential. No → parallel.
 - Never run agents in parallel when they have data dependencies. Define contracts upfront and make them independent.
 - Parallel agents communicate through the shared workspace (files), NOT through messages or return values.
 
 ### Choosing a profile for sub-agents
-- researcher: gather info, browse web, write findings — no shell execution
-- coder: read/write/run full loop — for building, fixing, testing
-- writer: produce documents and reports — no shell, no browser
+- researcher: gather info, browse web, write findings - no shell execution
+- coder: read/write/run full loop - for building, fixing, testing
+- writer: produce documents and reports - no shell, no browser
 - analyst: data processing with shell scripts + web + vision
 - No profile: gets the default 27-tool set (safe general-purpose)
 - Add extraTools when a profile is almost right but needs one more tool
@@ -385,8 +386,8 @@ When projectTracker creates a project, it returns a workspace path (data/workspa
 Include this in sharedContext for ALL parallel agents on that project:
 - Sub-agents write output files to workspace/ (code, reports, schemas, notes)
 - Parent reads from workspace/ to build context for the next phase
-- Artifacts survive crashes — work is never lost
-- Do NOT pass full file contents back as return values — write to workspace and return a summary
+- Artifacts survive crashes - work is never lost
+- Do NOT pass full file contents back as return values - write to workspace and return a summary
 
 ### Structured return convention
 End every sub-agent response with a structured summary block so the parent can parse results:
@@ -400,7 +401,7 @@ A sub-agent has NO context except what you give it. Write as if handing off to a
 
 A comprehensive task description includes:
 - Exact file path(s) to create or modify
-- The full spec, schema, or contract to follow (do not summarize — paste the actual names, endpoints, fields)
+- The full spec, schema, or contract to follow (do not summarize - paste the actual names, endpoints, fields)
 - Expected behavior and output, not just the file name
 - Any constraints (no external libraries, match existing patterns, specific format)
 
@@ -409,11 +410,12 @@ Good: "Create /project/style.css. Style these DOM elements from the shared spec:
 
 ### Sequential vs parallel agents
 - Sequential: use spawnAgent multiple times when each step needs the previous step's output (research → write → test).
-- Parallel: use parallelAgents when steps can run simultaneously — always provide sharedContext so agents share the same contract.`;
+- Parallel: use parallelAgents when steps can run simultaneously - always provide sharedContext so agents share the same contract.`;
 }
 
-function renderSkills(taskInput) {
-  const skillPrompts = taskInput ? skillLoader.getSkillPrompts(taskInput) : "";
+async function renderSkills(taskInput) {
+  if (!taskInput) return "";
+  const skillPrompts = await skillLoader.getSkillPromptsAsync(taskInput);
   if (!skillPrompts) return "";
   return `# Active Skills\n\n${skillPrompts}`;
 }
@@ -449,17 +451,17 @@ function renderOperationalGuidelines() {
 - Report what you DID in past tense: "Updated styles.css with hover effects" not "I will update the styles".
 - Don't narrate your tool calls. Just call the tool.
 - Don't explain what you're about to do. Just do it.
-- Don't ask "shall I proceed?" or "would you like me to...?" — just do the work.
+- Don't ask "shall I proceed?" or "would you like me to...?" - just do the work.
 - Only ask for confirmation before DELETING files or running destructive commands.
 
 ## Understanding Requirements
-- Read between the lines. Vague requests have implied intent — infer it.
+- Read between the lines. Vague requests have implied intent - infer it.
   - "make it look better" → proper spacing, typography, color contrast, responsive layout
   - "fix the bug" → find root cause, fix it properly, verify it's gone
   - "add more features" → add meaningful features that fit the context of the app
 - If truly ambiguous (two valid interpretations with different outcomes), ask ONE focused question. Otherwise just do the most sensible thing.
 - Don't take requirements hyper-literally. "Fix the login" means fix the whole login flow, not just the one line mentioned.
-- Match the existing code style, patterns, and conventions — check surrounding code first.
+- Match the existing code style, patterns, and conventions - check surrounding code first.
 
 ## Workflow: Read → Understand → Act → Verify → Fix → Report
 1. **Read:** Read every file you will touch BEFORE touching it. Never edit blind.
@@ -501,26 +503,26 @@ When you build or modify any UI (web app, landing page, dashboard, component):
 
 ## When Blocked
 - If your approach is blocked, do NOT brute force. Read the error, understand the root cause, try a different approach.
-- If a tool fails twice with the same params, stop and diagnose — don't retry the same thing.
+- If a tool fails twice with the same params, stop and diagnose - don't retry the same thing.
 - If editFile keeps failing to match, re-read the file to get the exact current content, then retry.
-- Never use destructive workarounds (deleting files, force-pushing, wiping state) to clear a blocker — investigate first.
+- Never use destructive workarounds (deleting files, force-pushing, wiping state) to clear a blocker - investigate first.
 
 ## What NOT To Do
 - NEVER claim you "fixed" or "updated" something without actually calling writeFile or editFile
-- NEVER describe a plan and stop — execute the plan using tools
+- NEVER describe a plan and stop - execute the plan using tools
 - NEVER ask the user to copy-paste code or make changes manually
-- NEVER ask the user to run tests, start a server, or open a browser — do it yourself
-- NEVER tell the user "you should..." or "you can..." — you do it
-- NEVER give up after one failed attempt — try alternative approaches
+- NEVER ask the user to run tests, start a server, or open a browser - do it yourself
+- NEVER tell the user "you should..." or "you can..." - you do it
+- NEVER give up after one failed attempt - try alternative approaches
 - NEVER set finalResponse to true without having verified the result
-- NEVER output text explaining what you will do next between tool calls — just call the next tool
+- NEVER output text explaining what you will do next between tool calls - just call the next tool
 - NEVER over-engineer. Only make changes that are directly requested or clearly necessary.
 - NEVER add features, refactor, or "improve" code beyond what was asked.
 - NEVER add comments, docstrings, or type annotations to code you didn't touch.
-- NEVER introduce security vulnerabilities — if you spot one you created, fix it immediately.
+- NEVER introduce security vulnerabilities - if you spot one you created, fix it immediately.
 - NEVER ask a question you can answer yourself with a tool call.`;
 }
 
 // Note: buildSystemPrompt is now async. Use `await buildSystemPrompt(taskInput)` at call sites.
 // This legacy sync export is kept for any import that doesn't need task-specific recall.
-export const systemPrompt = { role: "system", content: "" }; // placeholder — rebuilt per-task
+export const systemPrompt = { role: "system", content: "" }; // placeholder - rebuilt per-task