@j-o-r/hello-dave 0.0.2 → 0.0.4

package/examples.bak.1774780058/daisy_agent.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/*
+* --- The blueprint for an Agent ---
+* deps "@j-o-r/hello-dave" `npm i @j-o-r/hello-dave`
+* 
+* Meet Daisy , your music producer companion .
+*/
+import { AgentManager } from '@j-o-r/hello-dave';
+import { parseArgs } from '@j-o-r/sh';
+
+// The assistants name
+const name = 'daisy';
+// The Api to use 'xai|claude|gpt'
+const api = 'xai'; 
+// Optional secret for authentication on websocket server/client
+let secret = '';
+// Get command line arguments 
+/** @type {import('@j-o-r/sh').ArgsObject} */
+const args = parseArgs();
+// Show help flag
+const help = args['help'] || false;
+// Connect to websocket server e.g. 'ws://127.0.0.1:8081/ws'
+const connect = args['connect'] ? args['connect'] : undefined;
+// Create a websocket server Agent (where agents can connect)
+// (It is possible to create a websocket server and connect it as a client to another websocket server with '--connect [url]')
+const serve = args['serve'] ? parseInt(args['serve']) : undefined;
+// Define request options 'ANTHOptions|XAIOptions|OAOptions' depending on the api name in use
+/** @type {import('@j-o-r/hello-dave').XAIOptions} */
+const options = {
+	tools: []
+};
+// Add the websearch tool for XAI for online search
+options.tools.push({
+	type: 'web_search'  // Useful for lyrics research, Suno prompt ideas, music theory
+});
+if (args['secret']) { 
+	secret= args['secret'];
+}
+// Set properties only if provided via command line (model has default)
+if (args['model'] || true) {
+	options.model = args['model'] || 'grok-4-1-fast-reasoning';  // Good for creative music tasks
+}
+if (args['temperature']) {
+	options.temperature = parseFloat(args['temperature']);
+} else {
+	options.temperature = 0.8;  // Slightly higher default for creativity in lyrics/prompts
+}
+if (args['tokens']) {
+	options.max_output_tokens = parseInt(args['tokens']);
+}
+if (args['top_p']) {
+	options.top_p = parseFloat(args['top_p']);
+}
+
+const reasoning = true;  // Enable for step-by-step music editing/planning
+if (reasoning) {
+	options.reasoning = {
+		effort: 'medium',
+		summary: 'auto'
+	};
+}
+
+// Large context for song lyrics, multi-step editing sessions
+const contextWindow = args['context'] ? parseInt(args['context']) : 1900000;
+const toolsetMode = 'auto';
+// Help for the `--help` flag
+function printHelp() {
+	console.log(`
+${name} --help: Music Creation & Editing Assistant
+
+Daisy helps:
+- Edit audio with ffmpeg & sox (installed on your system)
+- Write lyrics & generate prompts for Suno AI
+- Research music theory, chords, genres via web_search
+- Execute bash scripts for audio processing
+
+OPTIONS:
+--model 'grok-4-1-fast-reasoning'|'grok-4-1-fast-non-reasoning'|'grok-code-fast-1'|'grok-4-fast-reasoning'|'grok-4-fast-non-reasoning'} [model='grok-4-fast-non-reasoning'] - Model version to use.
+--temperature [0-2] (default: 0.8 for creativity)
+--tokens [number]: max output tokens
+--context [number]: truncate history (default: 1.9M)
+--top_p [float]: 0-1
+--reasoning [low|high|true|false] (default: true)
+
+SERVER TOOLS:
+--serve [number]: create a Agent server on port number ws://127.0.0.1:[serve]/ws
+--connect [url]: connect to a Server Agent e.g ws://127.0.0.1:8080/ws (https://my.domain/ws) ...
+--secret [string] : limit access to websocket server with a secret
+
+EXAMPLES:
+daisy "Generate lyrics for a upbeat pop song about summer"
+daisy "Create a Suno prompt for electronic chill track with synths"
+daisy "Mix input.wav: fade in 2s, normalize, output to mixed.wav"
+daisy "Convert video.mp4 to audio.mp3 at 320kbps"
+
+Tools available:
+- execute_bash_script: Run ffmpeg/sox commands (e.g., "ffmpeg -i input.mp3 output.wav")
+- web_search: Find lyrics, chords, Suno tips
+- send_email: Share your tracks
+
+Start chatting!
+`);
+	process.exit();
+}
+
+if (help) {
+	printHelp();
+}
+// LLM prompt instructions 
+const prompt = `
+You are ${name}, a helpful music creation and editing assistant for the user's computer.
+
+Core expertise:
+- Generate lyrics: Creative, structured (verses, chorus), themed, rhyming.
+- Suno AI prompts: Detailed, vivid descriptions (genre, mood, instruments, structure, vocals).
+- Local audio editing: Use execute_bash_script with ffmpeg/sox commands. Provide exact bash snippets first, confirm before running. Examples:
+  * Trim: ffmpeg -i input.mp3 -ss 00:00:30 -t 00:01:00 output.mp3
+  * Concat: echo "file 'a.mp3'" > list.txt; ffmpeg -f concat -i list.txt out.mp3
+  * Sox effects: sox input.wav output.wav fade 0 3 2 norm
+  * Convert: ffmpeg -i video.mp4 audio.aac
+- Music theory: Chords, scales, BPM, EQ tips.
+- Workflows: Step-by-step for mixing, mastering, layering tracks.
+
+Behavior:
+- Be creative & enthusiastic!
+- Step-by-step: Explain, provide code, suggest files in current dir.
+- Safety: Quote bash commands; ask confirmation for destructive ops (e.g., overwrite).
+- Use web_search for inspiration/lyrics if needed.
+- Output ready-to-copy bash for ffmpeg/sox.
+- List files if unclear: Use ls *.wav *.mp3 etc. via bash.
+
+Current env: Ubuntu, ffmpeg & sox installed, cwd: /home/jd/devpri/js/daisy
+
+Respond concisely but completely. Use markdown for code/lyrics/prompts.
+`.trim();
+// Create the Agent
+const agent = new AgentManager({ name, secret });
+// Tailormade set up
+agent.setup({
+	prompt,       // Instructions
+	api,          // API name to use
+	options,      // Request options, overwrites defaults
+	toolsetMode,  // 'auto'
+	contextWindow // The max size of the context/session  
+});
+// Add toolcalls 
+// - "javascript_interpreter" Run javascript code with nodejs
+// - "open_link" Open an url or file in the local user environment
+// - "send_email" Send an email from the users environment
+// - "execute_bash_script" Execute bash commands and script on the local machine
+// - "execute_remote_script" Execute commands or scripts on a remote machine via ssh
+agent.addGenericToolcall('open_link');
+agent.addGenericToolcall('send_email');
+agent.addGenericToolcall('execute_bash_script');  // Key for music editing!
+agent.addGenericToolcall('read_file');
+agent.addGenericToolcall('write_file');
+// A welcome message to the user
+const cliIntro = `
+🎵 ${name} ${options.model} ready! (temp: ${options.temperature}, context: ${contextWindow})
+
+Ask me to:
+- Write lyrics
+- Craft Suno prompts
+- Edit audio: "fade out my track.mp3" → I'll give ffmpeg cmd
+Type /help for more.
+`.trim();
+
+const toolName = `agent_${name}`
+const toolDescription = `
+Daisy Music Assistant:
+- "Lyrics for [theme]" → Generate lyrics.
+- "Suno prompt: [style]" → Optimized Suno prompt.
+- "ffmpeg [task] on file.wav" → Bash script to run.
+- web_search: Research chords/lyrics.
+- execute_bash_script: Processes your local files safely.
+`.trim();
+await agent.start(serve, connect, cliIntro, toolName, toolDescription);

package/examples.bak.1774780058/docs_agent.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { AgentManager } from '@j-o-r/hello-dave';
+import { parseArgs } from '@j-o-r/sh';
+
+const name = 'docs_dave';
+const api = 'xai';
+let secret = '';
+
+// Read input/args
+const input = ''; //await readIn();
+const args = parseArgs();
+const help = args['help'] || false;
+const connect = args['connect'] ? args['connect'] : undefined;
+const serve = args['serve'] ? parseInt(args['serve']) : undefined;
+
+/** @type {import('@j-o-r/hello-dave/types/API/x.ai/responses').XAIOptions} */
+const options = { tools: [] };
+
+// Explicitly add web_search for research
+options.tools.push({ type: 'web_search' });
+
+if (args['secret']) { // model gets default value
+	secret = args['secret'];
+}
+
+if (args['model'] || true) {
+  options.model = args['model'] || 'grok-4-1-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']);
+}
+if (args['reasoning']) {
+  options.reasoning = { effort: 'medium', summary: 'auto' };
+}
+
+const contextWindow = args['context'] ? parseInt(args['context']) : 250000;
+const toolsetMode = 'auto';
+
+function printHelp() {
+  console.log(`
+docs --help: documentation maintainer that creates, updates, retrieves, and organizes Markdown files in ./docs/ for any subject.
+
+Usage: npx ./bin/docsDave.js [input] [options]
+
+Commands (via input):
+- "Create a doc on [topic]" → Generates new .md file with descriptive name.
+- "Update [filename] with [content]" → Appends/edits Markdown safely (backs up first).
+- "Show [topic or filename]" → Retrieves and displays content.
+- "Organize docs on [subject]" → Lists, suggests structure, or refactors files.
+
+OPTIONS:
+--model [name]          Model (default: grok-beta)
+--temperature [0-2]     Creativity (default: 0.7)
+--tokens [num]          Max output tokens
+--context [num]         Context window (default: 250000)
+--help                  Show this help
+
+SERVER TOOLS:
+--serve [number]: create a Agent server on port number ws://127.0.0.1:[serve]/ws
+--connect [url]: connect to a Server Agent e.g ws://127.0.0.1:8080/ws (https://my.domain/ws) ...
+--secret [string] : limit access to websocket server with a secret
+
+EXAMPLES:
+\$ npx ./bin/docsDave.js "Create a guide on Markdown best practices"
+\$ npx ./bin/docsDave.js "Update nodejs-basics.md with async/await section"
+\$ npx ./bin/docsDave.js --serve 8080
+
+Type /help in interactive mode for more.
+`);
+  process.exit();
+}
+
+if (help) printHelp();
+
+const prompt = `
+You are docs, a documentation maintainer that creates, updates, retrieves, and organizes Markdown files in ./docs/ (relative to cwd). You own this folder—create it if missing. All content is in clean Markdown (.md files only). Filenames must descriptively indicate content (e.g., "introduction-to-nodejs.md", "react-hooks-guide.md"—kebab-case, no spaces).
+
+Behaviors:
+- AUTONOMOUS: Use tools to manage files without user intervention. For reading: \`ls docs/*.md\` then \`cat docs/[filename].md\`. For writing/updating: Backup first (\`cp docs/old.md docs/old.md.bak\`), then \`echo "[full Markdown content]" > docs/[filename].md\`.
+- RESEARCH: Use web_search or browse_page to gather accurate info before creating/updating.
+- STRUCTURE: Markdown best practices—use # Headings, ## Subheadings, - Lists, \`code\` inline, \`\`\`blocks\`\`\`, links [text](url). Keep concise yet comprehensive.
+- RETRIEVAL: Display full file content in Markdown format when asked.
+- SAFETY: Never delete files. Confirm overwrites via backup. If unsure, ask for clarification.
+- FILENAME SUGGESTION: Propose and use logical names based on topic (e.g., for "AI agents", use "ai-agents-overview.md").
+- OUTPUT: Respond in Markdown. For file ops, show before/after diffs if changed.
+
+Use tools proactively: execute_bash_script for all file I/O (quote commands safely), web_search for topics, browse_page for deep sources. Reason step-by-step.
+`.trim();
+
+const agent = new AgentManager({ name, secret });
+agent.setup({
+  prompt,
+  api,
+  options,
+  toolsetMode,
+  contextWindow
+});
+
+// Add generic tools for file ops and research
+agent.addGenericToolcall('execute_bash_script');
+
+const cliIntro = `
+Welcome to docsDave! I manage your ./docs/ folder autonomously.
+- Ask me to create/update/retrieve Markdown docs on any topic.
+- I'll use descriptive .md filenames and keep everything organized.
+
+Example: "Create a doc on building CLI agents with Node.js"
+`.trim();
+
+const toolName = 'agent_docs';
+const toolDescription = `documentation maintainer that creates, updates, retrieves, and organizes Markdown files in ./docs/ for any subject.`.trim();
+
+await agent.start(serve, connect, cliIntro, toolName, toolDescription);

package/{bin/hdAsk.js → examples.bak.1774780058/gpt_agent.js}

@@ -1,40 +1,49 @@
 #!/usr/bin/env node
-import AgentManager from '../lib/AgentManager.js';
+import { AgentManager } from '@j-o-r/hello-dave';
 import { parseArgs, readIn } from '@j-o-r/sh';
 
-const name = 'hdAsk';
-const api = 'grok';
+const name = 'chat_gpt';
+const api = 'gpt';
+let secret = '';
 
-const input = await readIn();
+// const input = await readIn();
 const args = parseArgs();
 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/text.js').XOptions} */
-const options = {}
+/** @type {import('@j-o-r/hello-dave/types/API/openai.com/reponses/text').OAOptions} */
+const options = {
+	tools: []
+}
+options.tools.push({
+	type: 'web_search' 
+});
+if (args['secret']) { // model gets default value
+	secret = args['secret'];
+}
 // Set properties only if provided via command line (except model which has default)
 if (args['model'] || true) { // model gets default value
-	// @ts-ignore
-	options.model = args['model'] || 'grok-4-fast';
+	options.model = args['model'] || 'gpt-5.4';
 }
 if (args['temperature']) {
 	options.temperature = parseFloat(args['temperature']);
 }
 if (args['tokens']) {
-	options.max_completion_tokens = parseInt(args['tokens']);
+	options.max_output_tokens = parseInt(args['tokens']);
 }
 if (args['top_p']) {
 	options.top_p = parseFloat(args['top_p']);
 }
-options.search_parameters = { mode: 'auto' }
-const reasoning = args['reasoning'] ? args['reasoning'] : null;
+const reasoning = true // args['reasoning'] ? args['reasoning'] : null;
 if (reasoning) {
-	// @ts-ignore
-	options.reasoning_effort = reasoning
+	options.reasoning = {
+		effort: 'medium',
+		summary: 'auto'
+	}
 }
 // Large context on grok-4-fast
-const contextWindow = args['context'] ? parseInt(args['context']) : 1900000;
+const contextWindow = args['context'] ? parseInt(args['context']) : 100000;
 const toolsetMode = 'auto';
 
 function printHelp() {
@@ -45,12 +54,15 @@ OPTIONS:
 --tokens [number]: max generated tokens 
 --context [number] : truncate message history to context-windows size default 130000
 --temperature [float] : -2 / +2
---model [grok-4|grok-3|grok-3-mini|grok-3-mini-fast|grok-code-fast-1]
+--model ['grok-4-1-fast-reasoning'|'grok-4-1-fast-non-reasoning'|'grok-code-fast-1'|'grok-4-fast-reasoning'|'grok-4-fast-non-reasoning']
 --top_p [float]: number > 0, 0.1 means no top_p
 --reasoning [low|high]
 --tools [javascript,bash] comma seperated list
-e.g.
-grok.js --model grok-3-mini --tokens 4000 --context 10000
+
+SERVER TOOLS:
+--serve [number]: create a Agent server on port number ws://127.0.0.1:[serve]/ws
+--connect [url]: connect to a Server Agent e.g ws://127.0.0.1:8080/ws (https://my.domain/ws) ...
+--secret [string] : limit access to websocket server with a secret
 
 `);
 	process.exit()
@@ -61,11 +73,9 @@ if (help) {
 
 const prompt = `
 Respond briefly and directly, using minimal words. Reason step-by-step first. Focus solely on core point; avoid elaboration or follow-ups. If unclear, ask clarifying questions before proceeding.
-- open_link: [url] — open in local browser.
-- send_email: send to [email_address]; message: [message].
  `.trim();
 
-const agent = new AgentManager({ name });
+const agent = new AgentManager({ name, secret });
 agent.setup({
 	prompt,
 	api,
@@ -73,31 +83,27 @@ agent.setup({
 	toolsetMode,
 	contextWindow
 });
-	agent.addGenericToolcall('open_link');
-	agent.addGenericToolcall('send_email');
-
+// agent.addGenericToolcall('open_link');
+// agent.addGenericToolcall('send_email');
+// agent.addGenericToolcall('history_search');
+// 
+// const addTools = (args['tools']) ? args['tools'].split(',') : ['bash'];
+// if (addTools.includes('javascript')) {
+// 	agent.addGenericToolcall('javascript_interpreter');
+// }
+// if (addTools.includes('bash')) {
+// 	agent.addGenericToolcall('execute_bash_script');
+// }
+// if (addTools.includes('ssh')) {
+// 	agent.addGenericToolcall('execute_remote_script');
+// }
 const cliIntro = `
 ${name} ${options.model}.
-- search  ${options.search_parameters.mode}
 - context: ${contextWindow}
 `.trim();
 const description = `
 Guide for this smart online AI Agent:
-- query: Formulate ONE efficient, comprehensive search query in natural language, combining multiple sources/subjects/domains; mention optional sources if needed. Avoid multiple queries—conso
-lidate into a single one.
-- open_link: [URL] — Open in local browser.
-- send_email: Send to [email_address]; Message: [message].
+- query: Formulate ONE efficient, comprehensive search query in natural language, combining multiple sources/subjects/domains; mention optional sources if needed. Avoid multiple queries—consolidate into a single one.
 `.trim();
 
-if (input === '' && serve) {
-	agent.enableServer(name, description, serve);
-}
-if (input !== '') {
-	// Direct input output
-	const res = await agent.directCall(input);
-	console.log(res);
-} else if(connect) {
-	agent.attach('online_agent', description, connect)
-} else {
-	agent.startCli(cliIntro);
-}
+await agent.start(serve, connect, cliIntro, "search_agent", description);

package/examples.bak.1774780058/grok_agent.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/*
+* ONE SHOT , direct call example
+* ```bash
+* echo "What is your task?" | examples/grok.js
+* ```
+*/
+import { AgentManager }  from '@j-o-r/hello-dave';
+import { parseArgs, readIn } from '@j-o-r/sh';
+
+const name = 'ask_grok';
+const api = 'xai';
+let secret = '';
+
+const input = await readIn();
+const args = parseArgs();
+const help = args['help'] || false;
+
+/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
+const options = {
+	tools: []
+}
+options.tools.push({
+	type: 'web_search'
+});
+options.tools.push({
+	type: 'x_search'
+});
+
+// Set properties only if provided via command line (except model which has default)
+if (args['model'] || true) { // model gets default value
+	// @ts-ignore   || grok-4-1-fast-non-reasoning
+	options.model = args['model'] || 'grok-4.20-multi-agent-0309';
+}
+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 // args['reasoning'] ? args['reasoning'] : null;
+if (reasoning) {
+	options.reasoning = {
+		effort: 'medium',
+		summary: 'auto'
+	}
+}
+// Large context on grok-4-fast
+const contextWindow = args['context'] ? parseInt(args['context']) : 1900000;
+const toolsetMode = 'auto';
+
+function printHelp() {
+	console.log(`
+'${name} --help' You are looking at it.
+'
+OPTIONS: 
+--tokens [number]: max generated tokens 
+--context [number] : truncate message history to context-windows size default 130000
+--temperature [float] : -2 / +2
+--model ['grok-4-1-fast-reasoning'|'grok-4-1-fast-non-reasoning'|'grok-code-fast-1'|'grok-4-fast-reasoning'|'grok-4-fast-non-reasoning']
+--top_p [float]: number > 0, 0.1 means no top_p
+--reasoning [low|high]
+
+USAGE:
+
+\`\`\`bash
+echo "What is ..." | grok.js
+\`\`\`
+
+`);
+	process.exit()
+}
+if (help) {
+	printHelp();
+}
+
+if (input.trim() === '') {
+	printHelp();
+}
+
+const prompt = `
+Respond briefly and directly, using minimal words. Reason step-by-step first. Focus solely on core point; avoid elaboration or follow-ups. If unclear, ask clarifying questions before proceeding.
+ `.trim();
+
+const agent = new AgentManager({ name, secret });
+agent.setup({
+	prompt,
+	api,
+	options,
+	toolsetMode,
+	contextWindow
+});
+
+const res = await agent.directCall(input);
+console.log(res);

package/examples.bak.1774780058/memory_agent.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { AgentManager } from '@j-o-r/hello-dave';
+import { parseArgs } from '@j-o-r/sh';
+
+const name = 'memory_dave';
+const api = 'xai';
+let secret = '';
+
+const args = parseArgs();
+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']);
+}
+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.
+
+Project Memory manager for CodeServer multi-agent setup. Stores/retrieves shared memories in .cache/memory.ndjson (tasks/errors/prefs).
+
+OPTIONS: --model ... --temp ... --secret ...
+SERVER: --serve PORT | --connect ws://host:PORT/ws
+`);
+  process.exit();
+}
+
+if (help) printHelp();
+
+const tool_call_description = `
+CodeServer Memory Agent. Manages shared agent memory (.cache/memory.ndjson) for tasks, errors, user prefs across all agents (code/todo/readme/npm/docs).
+Use before/after actions: Recall relevant memories, write updates to avoid loops/repetition.
+Categories: tasks (pending work), errors (failures to avoid), prefs (user settings).
+`.trim();
+
+const tool_call_name = 'memory_agent';
+
+const prompt = `
+You are MemoryDave, the dedicated memory manager for CodeServer multi-agent setup (code/todo/readme/npm/docs agents).
+
+**CORE TOOLS (from lib/genericToolset.js)**:
+- \`memory_recall [query]\`: Retrieve stored memories (tasks/errors/prefs). ALWAYS recall before acting (e.g., "tasks", "errors", "" for recent).
+- \`memory_write {category: "tasks|errors|prefs", content: "details"}\`: Persist info to avoid repetition/loops/token burn.
+
+**SHARED STORAGE**: .cache/memory.ndjson in project CWD (all agents share).
+
+**ALWAYS**:
+1. **RECALL FIRST**: \`memory_recall "<user_query|category|''>"\` to check prior state/tasks/errors/prefs.
+2. **ACT**: Analyze + decide (write if new info, delegate via server if needed).
+3. **WRITE IF CHANGED**: Use \`memory_write\` for decisions/tasks/errors/prefs (e.g., "Pending: review npm deps", "Error: loop in git", "Pref: low temp for code").
+4. Respond: Summarize memories used/updated + action taken.
+
+**USER QUERIES**:
+- "Recall tasks" → List + suggest next.
+- "Store task: Fix auth bug" → Write + confirm.
+- "Clear old errors" → Recall + write cleaned.
+- Coordinate: "Check if code agent has pending tasks" → Recall + advise.
+
+Use other tools (bash/read_file) only if needed for context. Focus on memory coordination to boost multi-agent efficiency.
+
+Current date: March 27, 2026.
+`.trim();
+
+const agent = new AgentManager({ name, secret });
+agent.setup({
+  prompt,
+  api,
+  options,
+  toolsetMode,
+  contextWindow
+});
+
+// Ensure memory tools are available (auto + explicit for emphasis)
+const toolset = agent.getToolset();
+if (toolset) {
+  // Core memory tools (already in 'auto', but explicit)
+  agent.addGenericToolcall('memory_recall');
+  agent.addGenericToolcall('memory_write');
+  // Helpers for inspection
+  agent.addGenericToolcall('execute_bash_script');
+  agent.addGenericToolcall('read_file');
+}
+
+const cliIntro = `
+🤖 ${name} (${options.model}) ready! Shared CodeServer memory manager (.cache/memory.ndjson).
+- context: ${contextWindow} tokens
+- Recall: "tasks" | Write: "store task: XYZ"
+`.trim();
+
+await agent.start(serve, connect, cliIntro, tool_call_name, tool_call_description);