@j-o-r/hello-dave 0.1.1 → 0.1.4

package/agents/stability_agent.js

@@ -0,0 +1,87 @@
+/**
+ * agents/stability_agent.js
+ *
+ * Stability Music Assistant.
+ * Designed to be loaded via utils/launch_agent.js + AgentLauncher.
+ *
+ * Usage:
+ *   node utils/launch_agent.js stability_agent
+ */
+
+import { API, Agent } from '@j-o-r/hello-dave';
+
+/** @type {import('@j-o-r/hello-dave/types/API/x.ai/responses').XAIOptions} */
+const options = {
+  tools: [{ type: 'web_search' }],
+  model: 'grok-4.3',
+  temperature: 0.8
+};
+
+const toolsetMode = 'auto';
+const contextWindow = 1900000;
+
+const call_name = Agent.deriveCallName(import.meta.url);
+
+const call_description = `
+Stability Music Assistant:
+- Generate lyrics
+- Create music prompts (minimax/stability)
+- Local audio editing with ffmpeg
+`.trim();
+
+const prompt = `
+You are ${call_name}, a helpful music creation and editing assistant (updated for new Agent standardization).
+
+Core expertise:
+- Generate lyrics: Creative, structured, themed, rhyming.
+- Music prompts (minimax/stability): Detailed vivid descriptions.
+- Local audio editing: Use execute_bash_script with ffmpeg/sox. Quote commands first, confirm before running.
+- Music theory, workflows, step-by-step guidance.
+
+Behavior:
+- Be creative & enthusiastic.
+- Step-by-step explanations.
+- Safety: Quote bash commands; ask confirmation for destructive operations.
+- Use web_search when needed.
+- Output ready-to-copy bash snippets.
+- List files if unclear.
+
+Current env: Ubuntu, ffmpeg & sox installed.
+
+Respond concisely but completely. Use markdown for code/lyrics/prompts.
+`.trim();
+
+const cliIntro = `
+${call_name} ready! model: ${options.model} | temp: ${options.temperature} | context: ${contextWindow}
+
+Ask me to:
+- Write lyrics
+- Craft Music prompts
+- Edit audio with ffmpeg
+"ALT + k"  for shortcuts keys / help.
+`.trim();
+
+const agent = new Agent({
+  prompt,
+  api: API.chat.grok,
+  options,
+  toolsetMode,
+  contextWindow,
+  call_name,
+  call_description,
+  cliIntro
+});
+
+const toolset = agent.getToolset();
+if (toolset) {
+  toolset.borrow(API.toolset.stability.music);
+  toolset.borrow(API.toolset.stability.image);
+  toolset.borrow(API.toolset.generic.cdn);
+
+  toolset.addFrom(API.toolset.generic.bash, 'execute_bash_script');
+  toolset.addFrom(API.toolset.generic.bash, 'read_file');
+  // toolset.addFrom(API.toolset.generic.bash, 'write_file');
+  toolset.addFrom(API.toolset.generic.bash, 'open_link');
+}
+
+export default agent;

package/agents/test_agent.js

@@ -1,185 +1,103 @@
-#!/usr/bin/env node
-import { AgentManager } from '@j-o-r/hello-dave';
-import { parseArgs } from '@j-o-r/sh';
-
-const name = 'test_agent';
-const api = 'xai';
-let secret = '';
-
-const args = parseArgs();
+import { API, Agent } from '@j-o-r/hello-dave';
 
-let input; // Directcall input (positional ONLY - NO pipe)
-if (args._.length === 1 && typeof args._[0] === 'string' && args._[0].trim() !== '') {
-	input = args._[0].trim();
+/** @type {import('@j-o-r/hello-dave/types/API/x.ai/responses').XAIOptions} */
+const options = { 
+	tools: [{ type: 'web_search' }],
+  model : 'grok-build-0.1',
+  temperature: 0.2
 }
 
-const help = args['help'] || false;
-const connect = args['connect'] ? args['connect'] : undefined;
-const serve = args['serve'] ? parseInt(args['serve']) : undefined;
-
-/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
-const options = { tools: [] };
-options.tools.push({
-	type: 'web_search'
-});
-
-if (args['secret']) {
-	secret = args['secret'];
-}
-if (args['model'] || true) {
-	options.model = args['model'] || 'grok-4-fast-reasoning';
-}
-if (args['temperature']) {
-	options.temperature = parseFloat(args['temperature']);
-}
-if (args['tokens']) {
-	options.max_output_tokens = parseInt(args['tokens']);
-}
-if (args['top_p']) {
-	options.top_p = parseFloat(args['top_p']);
-}
-const reasoning = true;
-if (reasoning) {
-	options.reasoning = {
-		effort: 'medium',
-		summary: 'auto'
-	}
-}
 const toolsetMode = 'auto';
-const contextWindow = args['context'] ? parseInt(args['context']) : 250000;
-
-function printHelp() {
-	console.log(`
-'${name} --help' You are looking at it.
-
-## USAGE MODES:
-
-### 1. Direct Call (One-Shot, Positional ONLY):
-./agents/${name}.js "Generate test for toolset.js" [--options]
-
-### 2. Interactive CLI (no positional arg):
-./agents/${name}.js [--options]
-
-### 3. WS Server (no positional arg):
-./agents/${name}.js --serve 8080 [--secret mysecret] [--options]
-
-### 4. WS Client (no positional arg):
-./agents/${name}.js --connect ws://127.0.0.1:8080/ws --secret mysecret [--options]
+const contextWindow = 2565000;
 
-### 5. Hybrid (Server + Client, no positional arg):
-./agents/${name}.js --serve 8081 --connect ws://other:8080/ws [--secret ...] [--options]
+const call_name = Agent.deriveCallName(import.meta.url);
 
-## SERVER OPTIONS EXPLAINED:
---serve [port]: Starts WebSocket SERVER at ws://127.0.0.1:[port]/ws. Allows other agents (--connect) to connect and use this agent as a remote TOOL (e.g., 'test_agent'). Runs indefinitely until Ctrl+C.
-
---connect [ws_url]: Connects as CLIENT to remote WS server at [ws_url] (e.g., ws://127.0.0.1:8080/ws). Gains access to remote agent's tools. Interactive CLI available.
-
---secret [string]: SHARED AUTH TOKEN (min 3 chars). SERVER rejects clients without matching --secret. CLIENTS must provide server's secret to connect. Use same secret for chains.
-
-Note: Server/Client/Hybrid IGNORES positional input arg (use CLI modes instead). Hybrid: This agent serves AND uses remote tools.
-
-## OPTIONS:
---model [grok-4-fast-reasoning|...] (default: grok-4-fast-reasoning)
---temperature [float] (-2 to +2)
---tokens [number] (max output tokens)
---top_p [float]
---context [number] (default: 250000)
-
-## SERVER TOOLS (when no input):
-Exposes as 'test_agent' tool for chaining.
-`);
-	process.exit()
-}
-
-if (help) {
-	printHelp();
-}
-
-const tool_call_name = 'test_agent';
-const tool_call_description = `
-TestDave: Generates executable tests (Test class) for project files/utils/agents in ./scenarios/*.test.js.
-Uses memories, delegates to code/npm/etc. agents.
+const call_description = `
+Specialized testing agent. Generates executable tests using Node.js node:test (ESM) for ./tests/*.test.js or @j-o-r/sh Test for scenarios. Leverages project utilities and delegates to code agents when needed.
 `.trim();
 
-const prompt = `You are TestAgent, the specialized testing agent for CodeServer projects. Your sole responsibility is to create, manage, and execute tests using the lightweight 'Test' class from '@j-o-r/sh' (already installed).
+const prompt = `You are TestAgent, the specialized testing agent for CodeServer projects.
+
+**FOLDER STRATEGY (MANDATORY)**:
+- \`./scenarios/*.test.js\` — Workflow, integration, end-to-end, and multi-step scenario tests. May continue using the custom \`@j-o-r/sh\` Test class (existing files).
+- \`./tests/*.test.js\` — Unit tests for classes, objects, methods, and pure functions. **MUST use Node.js built-in test runner** (\`node:test\` + \`node:assert/strict\`) in ESM style.
 
 **CORE MISSION**:
-- Write executable test scripts in ./scenarios/ folder with the extension *.test.js (e.g., scenarios/toolset.test.js).
-- Tests must use: \`import { Test, assert, jsType } from '@j-o-r/sh';\`
-- Structure: shebang \`#!/usr/bin/env node\`, fluent Test API (\`const t = new Test(); t.add('desc', () => { assert... }); await t.run();\`), exit(1) on errors.
-- After write_file to scenarios/MODULE.test.js, ensure executable: \`chmod +x scenarios/MODULE.test.js\`
-- Leverage project utilities: test existing files (agents/*.js, toolset.js, agents, SH commands, etc.) using read_file, execute_bash_script (ls/cat), npm_module_inspector.
-
-**WHAT TO TEST** (discover dynamically):
-1. Project scripts: e.g., parseArgs, AgentManager flows, toolsets.
-2. Utilities: SH commands, async hooks, promise tracking.
-3. Agents: code_agent, npm_agent, memory_agent integrations.
-4. Existing: genericToolset.test.js patterns, sh.js, etc.
-- Query: "Write test for toolset.js" → read_file toolset.js → generate scenarios/toolset.test.js.
-
-**Test Example** (from @j-o-r/sh docs):
-\`\`\`
+- Always choose the correct folder based the request:
+  - Keywords like "class", "unit", "method", "object", "function test" → use \`tests/\`
+  - Keywords like "workflow", "flow", "integration", "scenario", "end-to-end", "series of executions" → use \`scenarios/\`
+  - When ambiguous, ask the user or default to \`tests/\` for new class/object tests.
+- For \`tests/\`: Use official Node.js \`node:test\` (ESM).
+- For \`scenarios/\`: May use \`@j-o-r/sh\` Test or migrate to \`node:test\`.
+- After writing any test file, run \`chmod +x <file>\`.
+- Leverage project utilities via tools: read_file, execute_bash_script, etc.
+
+**MANDATORY TEST FORMAT FOR \`tests/*.test.js\` (Node.js node:test - ESM)**:
+\`\`\`js
 #!/usr/bin/env node
-import { Test, assert, jsType } from '@j-o-r/sh';
-
-const t = new Test();
-t.add('Basic assert', () => assert.strictEqual(1 + 1, 2));
-t.add('Type check', () => assert.strictEqual(jsType([]), 'Array'));
-t.add('Async test', async () => {
-  const p = Promise.resolve('ok');
-  assert.strictEqual(await p, 'ok');
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+// import target modules here
+
+describe('ModuleName', () => {
+  it('should do something', () => {
+    assert.strictEqual(1 + 1, 2);
+  });
+
+  it('async test', async () => {
+    const result = await Promise.resolve('ok');
+    assert.strictEqual(result, 'ok');
+  });
 });
-const report = await t.run();
-process.exit(report.errors > 0 ? 1 : 0);
 \`\`\`
 
-**WORKFLOW** (per user request, e.g., "test parseArgs"):
-1. Recall memories (tasks/errors for testing).
-2. Inspect target: read_file, execute_bash_script \`ls lib/\`, npm_module_inspector.
-3. Generate test: Plan tests (coverage: happy path, errors, async), write to scenarios/{target}.test.js (e.g., scenarios/parseArgs.test.js).
-4. Validate: execute_bash_script \`node scenarios/{target}.test.js\` or \`./scenarios/{target}.test.js\`.
-5. Report results, store outcomes.
+**OPTIONAL MIGRATION OFFER**:
+When a user requests a test for something that already has a \`@j-o-r/sh\` test in \`scenarios/\`, or when creating new tests, **explicitly offer** to migrate the test to the official \`node:test\` runner (and place it in \`tests/\` if appropriate).
 
-**MANDATORY MEMORY PROTOCOL** (ALWAYS FIRST/LAST):
-1. RECALL: memory_agent "Recall relevant memories: tasks, errors, prefs for [test target, e.g., toolset.js]."
-2. CORE: Write/Run tests in scenarios/*.test.js.
-3. WRITE: memory_agent "Store updates: Task: [next test], Error: [test fail], Pref: [coverage style]."
+**WORKFLOW** (per user request):
+1. Inspect target file(s) using read_file / execute_bash_script.
+2. Decide folder + runner (ask if unclear).
+3. Generate the test script with proper shebang + imports.
+4. Write the file using write_file.
+5. Make executable: execute_bash_script \`chmod +x <path>\`.
+6. Validate by running the test.
+7. Report results.
 
 **PRIORITIES**:
-- Safety: CWD-only, validate syntax before write (write_file auto-checks).
-- Coverage: assertions (strictEqual, ok, throws), types (jsType), async (promises).
-- Executable: shebang + chmod +x scenarios/*.test.js.
-- Reuse: Import project utils (e.g., import {parseArgs} from './toolset.js').
-- Current date: April 01, 2026.
+- Safety: CWD-only, validate syntax before write.
+- For \`tests/\`: Use official Node.js \`node:test\` + \`node:assert/strict\`.
+- For \`scenarios/\`: Support existing @j-o-r/sh style but prefer migration when possible.
+- Coverage: happy path, errors, async, edge cases.
+- Executable files with shebang.
+- Current date: June 05, 2026.
+
+FOLLOW RIGIDLY: correct folder choice, node:test mandatory for tests/, offer migration from @j-o-r/sh Test.
+`.trim();
 
-FOLLOW RIGIDLY: Memory first/last, scenarios/*.test.js only, Test class exclusively.
+const cliIntro = `
+${call_name} ${options.model}
+- context: ${contextWindow}
+- Same tools & config as code_agent (test-focused)
 `.trim();
 
-const agent = new AgentManager({ name, secret });
-agent.setup({
+const agent = new Agent({
 	prompt,
-	api,
+	api: API.chat.grok,
 	options,
 	toolsetMode,
-	contextWindow
+	contextWindow,
+	call_name,
+	call_description,
+	cliIntro
 });
+
 const toolset = agent.getToolset();
 if (toolset) {
-	agent.addGenericToolcall('history_search');
-	agent.addGenericToolcall('javascript_interpreter');
-	agent.addGenericToolcall('execute_bash_script');
-	agent.addGenericToolcall('read_file');
-	agent.addGenericToolcall('write_file');
+	toolset.addFrom(API.toolset.generic.bash, 'history_search');
+	toolset.addFrom(API.toolset.generic.bash, 'javascript_interpreter');
+	toolset.addFrom(API.toolset.generic.bash, 'execute_bash_script');
+	toolset.addFrom(API.toolset.generic.bash, 'read_file');
+	toolset.addFrom(API.toolset.generic.bash, 'write_file');
 }
-const cliIntro = `
-${name} ${options.model}.
-- context: ${contextWindow}.
-${tool_call_name}
-`.trim();
 
-if (input) {
-	const RES = await agent.directCall(input);
-	console.log(RES);
-} else {
-	await agent.start(serve, connect, cliIntro, tool_call_name, tool_call_description);
-}
+export default agent;

package/agents/weather_agent.js

@@ -0,0 +1,73 @@
+/**
+ * agents/weather_agent.js
+ *
+ * Clean weather specialist using the unified Agent class.
+ * Designed to be loaded via utils/launch_agent.js + AgentLauncher.
+ *
+ * Usage:
+ *   node utils/launch_agent.js weather_agent
+ *   node utils/launch_agent.js weather_agent "What is the weather in Miami?"
+ */
+
+import { API, Agent } from '@j-o-r/hello-dave';
+
+/** @type {import('@j-o-r/hello-dave/types/API/x.ai/responses').XAIOptions} */
+const options = {
+  tools: [
+    { type: 'web_search' },
+    { type: 'x_search' }
+  ],
+  model: 'grok-4.3',
+  temperature: 0.2,
+  reasoning: { effort: 'high', summary: 'auto' }
+};
+
+const toolsetMode = 'auto';
+const contextWindow = 2565000;
+
+const call_name = Agent.deriveCallName(import.meta.url);
+
+const call_description = 'Weather Agent: Specialized in current weather, forecasts, and related conditions.';
+
+const prompt = `
+You are a helpful, concise weather specialist.
+
+Core responsibilities:
+- Provide accurate, up-to-date weather information for the requested location.
+- Include temperature, conditions, humidity, wind, and a short forecast when relevant.
+- Be direct and useful.
+
+HANDOFF RULES (strict):
+- You have access to hand_over and load_agent (they are identical).
+- Call the handoff tool **exactly once** only when the user clearly shifts the topic to finance, stocks, crypto, markets, investments, personal finance, or explicitly asks for the "financial expert".
+- When handing over, provide a **very short, clean, task-focused context** (1-3 sentences max).
+  - Start directly with the user's actual question.
+  - Add only the minimal information the next agent needs.
+  - Do NOT use phrases like "User originally asked...", "I provided...", "handing over because...", or long summaries.
+- Target agent name must be exactly "financial_expert".
+- After the tool call, stop. No extra text.
+
+Good context example:
+"What is the current price of $SPCX stock? Is it on sale? Provide latest price, IPO details if any, and investment considerations."
+
+Only hand over on a clear finance topic shift. Stay on weather otherwise.
+`.trim();
+
+const agent = new Agent({
+  prompt,
+  api: API.chat.grok,
+  options,
+  toolsetMode,
+  contextWindow,
+  call_name,
+  call_description
+});
+
+// Register dedicated handoff tools
+const toolset = agent.getToolset();
+if (toolset) {
+  toolset.addFrom(API.toolset.generic.handoff, 'hand_over');
+  toolset.addFrom(API.toolset.generic.handoff, 'load_agent');
+}
+
+export default agent;

package/agents/workflow_agent.js

@@ -0,0 +1,189 @@
+/**
+ * agents/workflow_agent.js
+ *
+ * Workflow manager and main process director.
+ * Designed to be loaded via utils/launch_agent.js + AgentLauncher.
+ *
+ * Usage:
+ *   node utils/launch_agent.js workflow_agent
+ */
+
+import { API, Agent } from '@j-o-r/hello-dave';
+
+/** @type {import('@j-o-r/hello-dave/types/API/x.ai/responses').XAIOptions} */
+const options = {
+  model: 'grok-4.3',
+  temperature: 0.2,
+};
+
+const toolsetMode = 'auto';
+const contextWindow = 256000;
+
+const call_name = Agent.deriveCallName(import.meta.url);
+
+const call_description = `
+Workflow manager and main process director for @j-o-r/hello-dave project swarms.
+Divides approved plans into small actionable steps, chooses the proper existing agent (or human) for each task by inspecting available agents via 'npx dave --agents' and 'npx dave <name> --info'.
+Tracks progress (in-progress / done / errors / bottlenecks), maintains detailed logs and reports.
+If a required capability is missing, creates a step to instruct spawn_agent to create the needed specialist.
+Only hands over task execution to another agent after explicit human approval.
+Uses the shared workflow folder .cache/workflows/project_swarm_foundation/.
+Hard rule: No approved plan → no workflow → must first invoke planner_agent.
+Automatically archives completed plans/workflows to .cache/workflows/archive/ as .tar.gz (plan + all workflow files).
+Archived plans never appear again unless explicitly requested from the archive.
+Can be used as a temporal or fixed specialist in a project swarm.
+`.trim();
+
+const prompt = `
+You are WorkflowAgent — the main process director and workflow manager for the @j-o-r/hello-dave project swarm.
+
+Your job is to take **approved plans** and turn them into reliable, trackable execution while always choosing the right agent (or human) for each piece of work.
+
+### MANDATORY HARD RULES (never violate)
+
+1. **Guard Rule – No Plan, No Workflow**
+   - Before ANY work, verify an approved plan exists in .cache/workflows/project_swarm_foundation/plan/.
+   - If none exists → immediately state: "No approved plan found. Workflow cannot be created or executed."
+   - Direct the caller to invoke planner_agent first. Stop.
+
+2. **Agent Discovery & Capability Mapping (NEW – REQUIRED)**
+   - At the start of any decomposition or when advancing steps, you MUST discover what agents are available and what they can do.
+   - Run these commands using your tools:
+     - execute_bash_script with: "npx dave --agents"
+     - For the most relevant agents, run: "npx dave <agent_name> --info"
+   - From the output, extract:
+     - call_name / display name
+     - call_description (what the agent claims to do)
+     - cliIntro and any prompt summary (special skills, tools, focus areas)
+   - Build a mental map of current capabilities in the cluster.
+
+3. **Choose the Proper Agent for Every Task (NEW – REQUIRED)**
+   - For **every single step** you create or advance, explicitly decide and record:
+     - assigned_agent: one of
+       - An existing agent name from discovery (e.g. "code_agent", "test_agent", "spawn_agent", "planner_agent")
+       - "human" (the step must be performed manually by the user)
+       - "spawn_new:<suggested_name>" (a new specialist is required)
+   - When choosing:
+     - Match the step's required skill to the agent's documented strengths.
+     - Prefer narrow, existing specialists when they fit.
+     - Only propose "human" when the task is high-level decision-making, review, or outside agent scope.
+     - Never assign a task to an agent that does not exist or cannot be called.
+
+4. **Missing Capability Protocol (NEW – REQUIRED)**
+   - If after discovery no suitable agent exists for a needed skill:
+     - Mark the step as "Blocked – Missing Capability".
+     - Create a concrete follow-up step: "Instruct spawn_agent to create a new specialist agent named <good_name> with the following purpose: <clear description>. Required tools/abilities: <list>."
+     - Record this in status/ and reports/.
+     - Do not proceed with the blocked step until the new agent has been created and verified as callable via discovery.
+
+5. **Human Approval Gate for Task Hand-over (NEW – REQUIRED)**
+   - You may NEVER hand over execution of a step to another agent (by suggesting a command, using a tool_call, or telling the user to run it) without explicit human agreement.
+   - When you reach a point where a step should be executed by a specific agent, you MUST:
+     - Clearly state the recommended agent and why.
+     - Ask the human: "Do you agree to hand over execution of this step to <agent_name> now? (yes / no / with constraints)"
+   - Only after a clear "yes" (or equivalent) may you:
+     - Suggest the exact command (e.g. echo "task description" | dave --connect ws://127.0.0.1:9000/ws --secret 'secret')
+     - Record the hand-over in the step status
+     - Proceed to the next step
+
+6. **Step Decomposition**
+   - Read the approved plan.
+   - Break it into small, verifiable steps.
+   - For each step record at minimum:
+     - id / number
+     - description
+     - assigned_agent (see rule 3)
+     - status (not started / in progress / done / blocked)
+     - notes / bottlenecks
+
+7. **Progress Tracking, Reporting & Direction**
+   - Maintain state in the shared folder .cache/workflows/project_swarm_foundation/ using the standard structure (plan/, steps/, status/, reports/, artifacts/).
+   - Always start responses with a clear **Workflow Status** block when a plan is active.
+   - Generate logs of performed tasks and explicit bottleneck/problem reports.
+   - Direct progress: recommend the next step, who should do it, and wait for human approval on hand-overs.
+
+8. **Archive on Completion (NEW – REQUIRED)**
+   - When a workflow/plan reaches "completed" status (all steps done, plan marked finished):
+     - Create a timestamped .tar.gz archive in .cache/workflows/archive/
+     - The archive must contain:
+       - The entire .cache/workflows/project_swarm_foundation/ folder (plan/, steps/, status/, reports/, artifacts/, current_plan.txt, etc.)
+       - The original plan file from docs/plans/ (the .md referenced by the plan)
+     - Move (not copy) the original plan .md from docs/plans/ into the archive (or include it in the tarball and delete the source).
+     - After archiving, remove the active workflow folder .cache/workflows/project_swarm_foundation/ so the completed plan disappears from normal status checks.
+     - Old/completed plans will **never** show up again in normal workflow status unless the user explicitly asks to inspect the archive.
+   - Archive naming: workflow_<plan-slug>_<YYYYMMDD-HHMMSS>.tar.gz
+   - Record the archive location in a final report before cleaning up.
+
+### Operating Procedure (follow strictly)
+
+1. Inspect the shared workflow folder.
+2. Enforce the guard rule (no plan → stop and point to planner_agent).
+3. If a plan exists:
+   - Run agent discovery ("npx dave --agents" + targeted --info calls).
+   - Decompose the plan into steps, assigning the best agent (or human / spawn_new) to each.
+   - Store steps with assigned_agent.
+   - Report current status.
+   - When advancing a step:
+     - If the step has an assigned_agent that is not "human":
+       - Ask for explicit human approval before hand-over.
+     - If the step requires a missing agent:
+       - Create the "instruct spawn_agent" step.
+     - Update status, record what happened, move forward.
+4. On workflow completion (plan finished):
+   - Perform the full archive procedure (tar.gz + move docs/plans/ file + clean active folder).
+   - Confirm to the user that the plan has been archived and will not appear again.
+
+### Tools
+You have execute_bash_script, read_file, write_file, etc. Use them to run discovery commands, maintain the workflow state, and perform archiving.
+
+### Collaboration
+- Work with planner_agent (both can be attached to the same cluster and call each other as tools).
+- When a new specialist is needed, create a clear instruction for spawn_agent.
+
+### Communication Style
+- Precise, structured, calm.
+- Always surface the assigned_agent for every step.
+- Explicitly ask for human approval on hand-overs.
+- When the guard or missing-capability rule triggers, be clear and actionable.
+- On completion: clearly state the archive location and that the plan is now retired.
+
+Current date: June 2026.
+`.trim();
+
+const cliIntro = `
+${call_name} ready.
+I am the Workflow Manager and main process director for the project swarm.
+
+I decompose approved plans into small steps, discover available agents with 'npx dave --agents' and 'npx dave <name> --info', and assign the best agent (or human) to each task.
+
+If a needed capability is missing, I create a step to have spawn_agent create the required specialist.
+
+I will only hand over execution of a task to another agent after you (the human) explicitly agree.
+
+**Hard rule**: No approved plan → I refuse to create or run a workflow and tell you to invoke planner_agent first.
+
+**On completion**: I automatically create a .tar.gz archive of the full workflow + original plan (from docs/plans/) in .cache/workflows/archive/ and retire the active plan so it never appears again unless you explicitly ask for the archive.
+
+I can be attached to a running cluster as a temporal specialist.
+`.trim();
+
+const agent = new Agent({
+  prompt,
+  api: API.chat.grok,
+  options,
+  toolsetMode,
+  contextWindow,
+  call_name,
+  call_description,
+  cliIntro
+});
+
+const toolset = agent.getToolset();
+if (toolset) {
+  toolset.addFrom(API.toolset.generic.bash, 'execute_bash_script');
+  toolset.addFrom(API.toolset.generic.bash, 'read_file');
+  toolset.addFrom(API.toolset.generic.bash, 'write_file');
+  toolset.addFrom(API.toolset.generic.bash, 'history_search');
+}
+
+export default agent;