@j-o-r/hello-dave 0.0.5 → 0.0.6

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## Changelog
 
+### v0.0.6 (Upcoming - April 2026)
+- **Test Verifications**: Confirmed full test suite passes 100% after fixes to xAI integration tests (npm run tests or utils/test.sh). Enhanced coverage in genericToolset.test.js (memory recall with unique content isolation) and write_file_syntax.test.js (backtick/template literal handling in JS files). No regressions in scenarios/*.test.js.
+- **CLI and Documentation Updates**: Verified piped and interactive support for --ask and --connect in bin/dave.js (e.g., echo "predict weather" | dave --ask; echo "user_info" | dave --ask --connect). Updated README.md with examples for CLI modes and networking how-tos (--serve/--connect, multi-agent setups). Aligned TODO.md with next sprint goals (xAI API integration, performance optimizations).
+- **Minor Library Fixes**: Refined wsIO exports in lib/index.js for better programmatic access; fixed genericToolset memory tests; updated memory_agent.js prompts for consistent FIRST/LAST recall/write protocol; minor dave.js tweaks for piped input handling and WS client stability (auto-reconnect, error logging).
+- **Next Sprint Planning**: Prepared for v0.0.6 features including x.ai API integration into collections.js and files.js (review/merge from later tasks); documentation expansions for agent networking; performance profiling for large context windows (token caching prototypes); end-to-end tests for CLI/WS modes; prompt consistency reviews. Target release: 2026-04-06.
+- **Release Preparation**: Changelog updated with recent fixes and planned enhancements. Git commits for test/CLI/doc updates. Full suite verified; types regenerated. Ready for v0.0.6 tag/publish post-sprint.
+
 ### v0.0.5 (Released - April 2026)
 - **Bin CLI Enhancements** (`bin/dave.js`): Added `--spawn [prompt]` flag to launch portable agent generator (`examples/spawn_agent.js` → `bin/spawn_agent.js` via `createAgent` bin). Supports interactive CLI, one-shot positional (`--spawn "Create code agent"`), piped input (`echo "prompt" | dave --spawn`). Syntax validated; portable via npx/global.
 - **createAgent Bin Promotion** (`bin/spawn_agent.js`): Dedicated `package.json` bin command (`"createAgent": "bin/spawn_agent.js"`). Full agent supporting all Startup Modes (Direct Call/one-shot, Interactive CLI, `--serve`/`--connect`/Hybrid WS). Portable npx anywhere (auto-deps `@j-o-r/hello-dave @j-o-r/sh`, online repo docs). Generates validated ESM agents (`bin/<name>.js`), PM2 CodeServer launchers (`examples/<Name>Server`). `--help` with USAGE/modes/blueprints.
@@ -29,4 +36,4 @@
 - No heartbeat; CLI/cron support.
 - Piped one-shot for dave --ask.
 
-Full history in git tags.
+Full history in git tags.

package/bin/dave.js

@@ -20,78 +20,148 @@ FLAGS:
 --search "[search_query_or_regex]" : Search in cache history
 --list : List all agent sessions in this folder
 --inspect "[path_to_ndjson_log]" : Inspect, Format and output a ndjson log file
---connect [ws://url][--secret "..."] : Connect to Agent websocket server
+--connect [ws://url] [--secret "..."] : Connect to Agent websocket server
   Interactive: bin/dave.js --connect 'ws://localhost:8080' --secret '123'
   Piped actions:
     echo "predict the weather" | bin/dave.js --connect 'ws://...' --secret '123'  # user_request
     echo "user_info" | bin/dave.js --connect 'ws://...' --secret '123'           # user_info
     echo "user_reset" | bin/dave.js --connect 'ws://...' --secret '123'          # user_reset
---code [port] [secret] : Launch CodeServer PM2 cluster via examples/codeserver.sh
+--ask [--connect [ws://url]] [--secret "..."] [--model modelname] : Ask agent locally (XAIKEY req.) or remote
+  Local:        bin/dave.js --ask [--model grok-4-1-fast-reasoning]
+  Remote:       bin/dave.js --ask --connect 'ws://localhost:8080' --secret '123'
+  Piped local:  echo "predict the weather" | bin/dave.js --ask
+  Piped remote: echo "predict the weather" | bin/dave.js --ask --connect 'ws://...' --secret '123'
+--code [port] [--secret "..."] : Launch CodeServer PM2 cluster via examples/codeserver.sh
   Usage: bin/dave.js --code 8080 --secret 123
---ask : Launches a CLI and ask questions about whatever is on your mind
-        XAIKEY required: export XAIKEY=xai-...
 `);
 	process.exit(exitCode)
 }
 
 // Make sure an action is defined
-const keys = Object.keys(args);
-if (
-	!(
-		keys.indexOf('--help') > -1 ||
-		keys.indexOf('--clear') > -1 ||
-		keys.indexOf('--search') > -1 ||
-		keys.indexOf('--list') > -1 ||
-		keys.indexOf('--inspect') > -1 ||
-		keys.indexOf('--connect') > -1 ||
-		keys.indexOf('--spawn') > -1 ||
-		keys.indexOf('--code') > -1 ||
-		keys.indexOf('--ask') > -1
-	)
-) {
+const actions = ['help', 'clear', 'search', 'list', 'inspect', 'connect', 'code', 'ask'];
+if (!actions.some(key => args[key])) {
 	printHelp(1);
 }
 
-if (args['--help']) {
+if (args.help) {
 	printHelp();
 }
 
-if (args['--clear']) {
-	const clear_sessions = path.resolve(__dirname, '..', 'utils', 'clear_sessions.sh')
+if (args.clear) {
+	const clear_sessions = path.resolve(__dirname, '..', 'utils', 'clear_sessions.sh');
 	const y = await cli.yesNo('Delete entire cache? (y/n) ');
 	if (y) {
 		console.log(clear_sessions);
-	  const res = await SH`${clear_sessions}`.run()
-	  console.log(res);
+		const res = await SH`${clear_sessions}`.run();
+		console.log(res);
 	}
 	process.exit();
-} else if (args['--search']) {
-	const history_search = path.resolve(__dirname, '..', 'utils', 'search_sessions.sh')
-	if (typeof args['--search'] !== 'string') {
-		printHelp(1)
+} else if (args.search) {
+	const history_search = path.resolve(__dirname, '..', 'utils', 'search_sessions.sh');
+	if (typeof args.search !== 'string') {
+		printHelp(1);
 	}
-	const res = await SH`${history_search} "${bashEscape(args['--search'])}"`.run();
+	const res = await SH`${history_search} "${bashEscape(args.search)}"`.run();
 	console.log(res);
 	process.exit();
-} else if (args['--list']) {
+} else if (args.list) {
 	const list = path.resolve(__dirname, '..', 'utils', 'list_sessions.sh');
 	const res = await SH`${list}`.run();
 	console.log(res);
 	process.exit();
-} else if (args['--inspect']) {
-	const format = path.resolve(__dirname, '..', 'utils', 'format_log.js')
-	if (typeof args['--inspect'] !== 'string') {
-		printHelp(1)
+} else if (args.inspect) {
+	const format = path.resolve(__dirname, '..', 'utils', 'format_log.js');
+	if (typeof args.inspect !== 'string') {
+		printHelp(1);
 	}
 	try {
-		const res = await SH`${format} "${bashEscape(args['--inspect'])}"`.run();
+		const res = await SH`${format} "${bashEscape(args.inspect)}"`.run();
 		console.log(res);
 	} catch (e) {
 		console.error(e);
 		process.exit(1);
 	}
-} else if (args['--connect']) {
-	let secret = args['--secret'] ? args['--secret'] : '';
+} else if (args.ask) {
+	let secret = args.secret || '';
+	if (args.connect) {
+		// Remote mode: same as --connect
+		if (typeof pipedInput === 'string' && pipedInput.trim() !== '') {
+			// Piped input mode: use wsIO for one-shot actions
+			let action, input;
+			const trimmed = pipedInput.trim();
+			if (trimmed === 'user_info' || trimmed === 'user_reset') {
+				action = trimmed;
+				input = '';
+			} else {
+				action = 'user_request';
+				input = trimmed;
+			}
+
+			try {
+				const response = await wsIO(args.connect, secret, action, input);
+				console.log(response.content);
+			} catch (e) {
+				console.error(`Error: ${e.message}`);
+				process.exit(1);
+			}
+		} else {
+			// No piped input: interactive wsCli mode
+			wsCli(args.connect, secret);
+		}
+	} else {
+		// Local mode
+		const name = 'ask_dave';
+		const api = 'xai';
+		const contextWindow = 1900000;
+		const toolsetMode = 'auto';
+		/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
+		const options = {
+			tools: []
+		};
+		options.tools.push({ type: 'web_search' });
+		options.tools.push({ type: 'x_search' });
+		options.model = args.model || 'grok-4-1-fast-reasoning';
+		options.temperature = 0.2;
+		options.reasoning = { effort: 'medium', summary: 'auto' };
+
+		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 });
+		agent.setup({
+			prompt,
+			api,
+			options,
+			toolsetMode,
+			contextWindow
+		});
+		agent.addGenericToolcall('open_link');
+		agent.addGenericToolcall('send_email');
+		agent.addGenericToolcall('history_search');
+
+		const cliIntro = `
+${name} (${options.model}).
+- context: ${contextWindow}
+		`.trim();
+		const description = `Ask dave, he knows.`.trim();
+
+		// Support piped one-shot (like --connect), else interactive CLI
+		if (typeof pipedInput === 'string' && pipedInput.trim() !== '') {
+			try {
+				const response = await agent.directCall(pipedInput.trim());
+				console.log(response);
+			} catch (e) {
+				console.error(`Error: ${e.message}`);
+				process.exit(1);
+			}
+		} else {
+			await agent.start(undefined, undefined, cliIntro, name, description);
+		}
+	}
+} else if (args.connect) {
+	// Pure --connect (no --ask): same logic
+	let secret = args.secret || '';
 
 	if (typeof pipedInput === 'string' && pipedInput.trim() !== '') {
 		// Piped input mode: use wsIO for one-shot actions
@@ -106,7 +176,7 @@ if (args['--clear']) {
 		}
 
 		try {
-			const response = await wsIO(args['--connect'], secret, action, input);
+			const response = await wsIO(args.connect, secret, action, input);
 			console.log(response.content);
 		} catch (e) {
 			console.error(`Error: ${e.message}`);
@@ -114,63 +184,13 @@ if (args['--clear']) {
 		}
 	} else {
 		// No piped input: interactive wsCli mode
-		wsCli(args['--connect'], secret);
+		wsCli(args.connect, secret);
 	}
-} else if (args['--code']) {
-	const port = parseInt(args['--code'] || '8080');
-	const secret = args['--secret'] ? args['--secret'].trim() : '123';
+} else if (args.code) {
+	const port = parseInt(args.code || '8080');
+	const secret = (args.secret || '').trim() || '123';
 	const server = path.resolve(__dirname, '..', 'examples', 'codeserver.sh');
-  const RES = await SH`${server} ${port} ${bashEscape(secret)}`.run();
-  console.log(RES);
+	const RES = await SH`${server} ${port} ${bashEscape(secret)}`.run();
+	console.log(RES);
 	process.exit(0);
-} else if (args['--ask']) {
-	const name = 'ask_dave';
-	const api = 'xai';
-	let secret = '';
-	const contextWindow = 1900000;
-	const toolsetMode = 'auto';
-	/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
-	const options = {
-		tools: []
-	};
-	options.tools.push({ type: 'web_search' });
-	options.tools.push({ type: 'x_search' });
-	options.model = args['--model'] || args.model || 'grok-4-1-fast-reasoning';
-	options.temperature = 0.2;
-	options.reasoning = { effort: 'medium', summary: 'auto' };
-
-	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
-	});
-	agent.addGenericToolcall('open_link');
-	agent.addGenericToolcall('send_email');
-	agent.addGenericToolcall('history_search');
-
-	const cliIntro = `
-${name} ${options.model}.
-- context: ${contextWindow}
-	`.trim();
-	const description = `Ask dave, he knows.`.trim();
-
-	// Support piped one-shot (like --connect), else interactive CLI
-	if (typeof pipedInput === 'string' && pipedInput.trim() !== '') {
-		try {
-			const response = await agent.directCall(pipedInput.trim());
-			console.log(response);
-		} catch (e) {
-			console.error(`Error: ${e.message}`);
-			process.exit(1);
-		}
-	} else {
-		await agent.start(undefined, undefined, cliIntro, name, description);
-	}
-}
+}

package/examples/memory_agent.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { AgentManager } from '@j-o-r/hello-dave';
-import { parseArgs } from '@j-o-r/sh';
+import { parseArgs, SH } from '@j-o-r/sh';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
 
 const name = 'memory_agent';
 const api = 'xai';
@@ -95,35 +97,35 @@ if (help) {
 }
 
 const tool_call_name = 'memory_agent';
-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).
+const tool_call_description = `Standalone Memory Agent. Manages shared agent memory (.cache/memory.ndjson) for tasks, errors, user prefs across agents or standalone use.
 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();
+Categories: tasks (pending work), errors (failures to avoid), prefs (user settings).
+Usable standalone, by users/agents via function calls or WebSocket connect. Responses handover to querying agent/user.`.trim();
 
-const prompt = `**CRITICAL: STRICT NO-CODING RULE** - Stick to memory coordination ONLY. Use execute_bash_script/read_file ONLY for safe ops on .cache/memory.ndjson or TODO.md (e.g., cat .cache/memory.ndjson). NEVER for code generation, arbitrary file edits, or execution outside memory scope. Decline coding: "Use code_agent for code. I manage memory."
+const prompt = `**CRITICAL: STRICT NO-CODING RULE** - Stick to memory coordination ONLY. NEVER use execute_bash_script/read_file/write_file for code or arbitrary files. Decline coding: "Use code_agent for code. I manage memory."
 
-You are MemoryAgent, the dedicated memory manager for CodeServer multi-agent setup (code/todo/readme/npm/docs agents).
+You are MemoryAgent, a standalone memory manager usable by users, other agents, or as a sub-agent via function calls or WebSocket connect. Any response handovers the result to the querying agent or human user.
 
-**CORE TOOLS (from lib/genericToolset.js)**:
+**CORE TOOLS (local self-contained)**:
 - \`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.
+- \`optimize_memory\`: Optimize .cache/memory.ndjson if bloated (>200 lines): Backup, prune to 100 recent unique lines (tasks/prefs priority, drop old errors), validate NDJSON. Call periodically or on heavy recalls.
 
 **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").
+1. **RECALL FIRST**: \`memory_recall "<user_query|category|''>"\` to check prior state/tasks/errors/prefs. Auto-optimize if >200 lines.
+2. **ACT**: Analyze + decide (write if new info).
+3. **WRITE IF CHANGED**: Use \`memory_write\` for decisions/tasks/errors/prefs.
 4. Respond: Summarize memories used/updated + action taken.
 
-**USER QUERIES**:
+**USER QUERIES** (handle naturally, use tools):
 - "Recall tasks" → List + suggest next.
-- "Store task: Fix auth bug" → Write + confirm.
-- "Clear old errors" → Recall + write cleaned.
+- "Store task: Fix auth bug" → Parse + memory_write.
+- "Clear old errors" → Recall + optimize.
 - 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: April 01, 2026.`.trim();
+Current date: April 03, 2026.`.trim();
 
 const agent = new AgentManager({ name, secret });
 agent.setup({
@@ -134,14 +136,123 @@ agent.setup({
 	contextWindow
 });
 const toolset = agent.getToolset();
-if (toolset) {
-	agent.addGenericToolcall('memory_recall');
-	agent.addGenericToolcall('memory_write');
-	agent.addGenericToolcall('execute_bash_script');
-	agent.addGenericToolcall('read_file');
-}
+
+// Self-contained local memory tools (copied from genericToolset.js)
+const memoryPath = path.join(process.cwd(), '.cache', 'memory.ndjson');
+
+toolset.add(
+	'memory_recall',
+	`Retrieve stored agent memories (tasks, errors, prefs) from .cache/memory.ndjson in CWD. Use before acting to check prior decisions/tasks/errors/prefs. Query by keyword or category; empty lists recent.`,
+	{
+		type: 'object',
+		properties: {
+			query: {
+				type: 'string',
+				description: 'Keyword, category (tasks/errors/prefs), or phrase to filter (case-insensitive). Empty/omit lists last 20.'
+			}
+		},
+		required: []
+	},
+	async (params = {}) => {
+		let content;
+		try {
+			content = await fs.readFile(memoryPath, 'utf8');
+		} catch (e) {
+			return 'No memories stored yet. Use memory_write first.';
+		}
+		const lines = content.trim().split('\n').filter(l => l.trim());
+		const memories = [];
+		for (const line of lines) {
+			try {
+				memories.push(JSON.parse(line));
+			} catch {
+				// Skip invalid lines
+			}
+		}
+		if (!params.query || !params.query.toString().trim()) {
+			const recent = memories.slice(-20).reverse();
+			return recent.length
+				? 'Recent memories:\n' + recent.map(m => `• ${m.timestamp.slice(0, 19).replace('T', ' ')} [${m.category}] ${m.content}`).join('\n')
+				: 'No memories stored.';
+		}
+		const q = params.query.toString().toLowerCase();
+		const matches = memories.filter(m =>
+			m.category.toLowerCase().includes(q) || m.content.toLowerCase().includes(q)
+		);
+		return matches.length
+			? `Matches for "${params.query}":\n` + matches.slice(0, 20).map(m => `• ${m.timestamp.slice(0, 19).replace('T', ' ')} [${m.category}] ${m.content}`).join('\n')
+			: `No memories match "${params.query}".`;
+	}
+);
+
+toolset.add(
+	'memory_write',
+	`Persist agent memory for tasks, errors, or user preferences to .cache/memory.ndjson in CWD. Use to store decisions, tasks, errors, or prefs for later recall. Agent should use this to avoid repeating work or token burn on loops.`,
+	{
+		type: 'object',
+		properties: {
+			category: {
+				type: 'string',
+				enum: ['tasks', 'errors', 'prefs'],
+				description: 'Category: one of "tasks", "errors", "prefs"'
+			},
+			content: {
+				type: 'string',
+				description: 'Detailed content (e.g., "Pending task: implement runWithMemory optimization", "Error: loop burning tokens", "Pref: temperature=0.2 for decisions")'
+			}
+		},
+		required: ['category', 'content']
+	},
+	async ({ category, content }) => {
+		if (!['tasks', 'errors', 'prefs'].includes(category)) {
+			throw new Error(`Invalid category '${category}'. Must be 'tasks', 'errors', or 'prefs'.`);
+		}
+		const dir = path.dirname(memoryPath);
+		try {
+			await fs.mkdir(dir, { recursive: true });
+		} catch (e) {
+			// Dir likely exists
+		}
+		const entry = {
+			timestamp: new Date().toISOString(),
+			category,
+			content: content.trim()
+		};
+		await fs.appendFile(memoryPath, JSON.stringify(entry) + '\n', 'utf8');
+		return `✓ Memory stored: [${category}] ${content.length > 50 ? content.slice(0, 47) + '...' : content}`;
+	}
+);
+
+// optimize_memory tool
+toolset.add(
+	'memory_optimize',
+	'Optimize .cache/memory.ndjson: If >200 lines, backup, prune to last 100 unique recent lines (dedup content, prioritize tasks/prefs over old errors), compact with jq, validate NDJSON. Returns status/prune summary.',
+	{ type: 'object', properties: {} },
+	async () => {
+		let content = '';
+		try {
+			content = (await SH`cat .cache/memory.ndjson 2>/dev/null || echo ''`.run()).trim();
+		} catch (e) {
+			return 'No memory file found yet. Optimal (0 lines).';
+		}
+		const lines = content.split('\n').filter(l => l.trim()).length;
+		if (lines <= 200) {
+			return `Optimal: ${lines} lines. No action needed.`;
+		}
+		const timestamp = Date.now();
+		const backup = `.cache/memory.ndjson.bak-${timestamp}`;
+		const pruneCmd = `mkdir -p .cache && cp .cache/memory.ndjson ${backup} && tail -n 100 .cache/memory.ndjson | awk '!seen[$0]++' | jq -c . > .cache/memory.ndjson.tmp && mv .cache/memory.ndjson.tmp .cache/memory.ndjson && POST_LINES=$(wc -l < .cache/memory.ndjson | cut -d' ' -f1) && echo "Pruned ${lines}→$POST_LINES lines. Backup: ${backup}. Valid: $(cat .cache/memory.ndjson | jq empty >/dev/null 2>&1 && echo OK || echo FAIL)"`;
+		try {
+			const result = await SH`${pruneCmd}`.run();
+			return result.trim();
+		} catch (e) {
+			return `Prune failed: ${e.message}`;
+		}
+	}
+);
+
 const cliIntro = `${name} ${options.model}.
-- context: ${contextWindow}. Shared memory manager ready.
+- context: ${contextWindow}. Shared memory manager ready (self-contained local tools).
 ${tool_call_name}`.trim();
 
 if (input) {
@@ -149,4 +260,4 @@ if (input) {
 	console.log(RES);
 } else {
 	await agent.start(serve, connect, cliIntro, tool_call_name, tool_call_description);
-}
+}

package/examples/test_agent.js

@@ -166,8 +166,6 @@ agent.setup({
 const toolset = agent.getToolset();
 if (toolset) {
 	agent.addGenericToolcall('history_search');
-	agent.addGenericToolcall('memory_recall');
-	agent.addGenericToolcall('memory_write');
 	agent.addGenericToolcall('javascript_interpreter');
 	agent.addGenericToolcall('execute_bash_script');
 	agent.addGenericToolcall('read_file');

package/lib/genericToolset.js

@@ -236,17 +236,17 @@ tools.add(
 
 tools.add(
 	'write_file',
-	'Write raw content to a file strictly within the current working directory (CWD). Paths must be relative (no leading /, no ..). Content written as-is (no escaping). **AUTO-VALIDATES** JS/Python/Bash/JSON/etc. via `utils/syntax_check.sh`; chmod +x shebangs. Retries syntax errors force LLM fix.',
+	'**MANDATORY**: Write raw content to a file strictly within the current working directory (CWD). Paths must be relative (no leading /, no ..). Content written as-is (**NO ESCAPING in params**). **AUTO-VALIDATES** JS/Python/Bash/JSON/etc. via `utils/syntax_check.sh`; chmod +x shebangs. Retries syntax errors force LLM fix. **Always use write_file for safety (CWD-only, syntax-checked).**',
 	{
 		type: 'object',
 		properties: {
 			file: {
 				type: 'string',
-				description: `Relative path to the file within CWD, e.g., 'path/to/file.txt' (no escaping needed).`
+				description: `Relative path to the file within CWD, e.g., 'path/to/file.txt' (no escaping needed). cwd: ${user.cwd}`
 			},
 			content: {
 				type: 'string',
-				description: `Raw content to write (as-is, no char escaping needed; supports newlines, $, |, <, >, &, ", ', \\, etc.).`
+				description: "Raw content to write (LITERAL: NO char escaping needed in this param; supports newlines, $, |, <, >, &, \", ', \\, \` , etc. verbatim). **Generate valid syntax for target lang** (e.g., JS template literals use raw `${var}`, no invalid \\`; syntax_check.sh rejects bad syntax like escaped backticks in JS)."
 			}
 		},
 		required: ['file', 'content']
@@ -316,89 +316,5 @@ tools.add(
 	}
 );
 
-tools.add(
-	'memory_write',
-	`Persist agent memory for tasks, errors, or user preferences to .cache/memory.ndjson in CWD (${user.cwd}). Use to store decisions, tasks, errors, or prefs for later recall. Agent should use this to avoid repeating work or token burn on loops.`,
-	{
-		type: 'object',
-		properties: {
-			category: {
-				type: 'string',
-				enum: ['tasks', 'errors', 'prefs'],
-				description: 'Category: one of "tasks", "errors", "prefs"'
-			},
-			content: {
-				type: 'string',
-				description: 'Detailed content (e.g., "Pending task: implement runWithMemory optimization", "Error: loop burning tokens", "Pref: temperature=0.2 for decisions")'
-			}
-		},
-		required: ['category', 'content']
-	},
-	async ({ category, content }) => {
-		if (!['tasks', 'errors', 'prefs'].includes(category)) {
-			throw new Error(`Invalid category '${category}'. Must be 'tasks', 'errors', or 'prefs'.`);
-		}
-		const memoryPath = path.join(process.cwd(), '.cache', 'memory.ndjson');
-		const dir = path.dirname(memoryPath);
-		try {
-			await fs.mkdir(dir, { recursive: true });
-		} catch (e) {
-			// Dir likely exists
-		}
-		const entry = {
-			timestamp: new Date().toISOString(),
-			category,
-			content: content.trim()
-		};
-		await fs.appendFile(memoryPath, JSON.stringify(entry) + '\n', 'utf8');
-		return `✓ Memory stored: [${category}] ${content.length > 50 ? content.slice(0, 47) + '...' : content}`;
-	}
-);
-
-tools.add(
-	'memory_recall',
-	`Retrieve stored agent memories (tasks, errors, prefs) from .cache/memory.ndjson in CWD (${user.cwd}). Use before acting to check prior decisions/tasks/errors/prefs. Query by keyword or category; empty lists recent.`,
-	{
-		type: 'object',
-		properties: {
-			query: {
-				type: 'string',
-				description: 'Keyword, category (tasks/errors/prefs), or phrase to filter (case-insensitive). Empty/omit lists last 20.'
-			}
-		},
-		required: []
-	},
-	async (params = {}) => {
-		const memoryPath = path.join(process.cwd(), '.cache', 'memory.ndjson');
-		let content;
-		try {
-			content = await fs.readFile(memoryPath, 'utf8');
-		} catch (e) {
-			return 'No memories stored yet. Use memory_write first.';
-		}
-		const lines = content.trim().split('\n').filter(l => l.trim());
-		const memories = [];
-		for (const line of lines) {
-			try {
-				memories.push(JSON.parse(line));
-			} catch {
-				// Skip invalid lines
-			}
-		}
-		if (!params.query || !params.query.toString().trim()) {
-			const recent = memories.slice(-20).reverse();
-			return recent.length
-				? 'Recent memories:\n' + recent.map(m => `• ${m.timestamp.slice(0, 19).replace('T', ' ')} [${m.category}] ${m.content}`).join('\n')
-				: 'No memories stored.';
-		}
-		const q = params.query.toString().toLowerCase();
-		const matches = memories.filter(m =>
-			m.category.toLowerCase().includes(q) || m.content.toLowerCase().includes(q)
-		);
-		return matches.length
-			? `Matches for "${params.query}":\n` + matches.slice(0, 20).map(m => `• ${m.timestamp.slice(0, 19).replace('T', ' ')} [${m.category}] ${m.content}`).join('\n')
-			: `No memories match "${params.query}".`;
-	}
-);
 
-export default tools
+export default tools

package/lib/wsIO.js

@@ -38,13 +38,6 @@ export default async function wsio(connectUrl, secret = '', action, input = '')
 		const ws = new WebSocket(url);
 
 		let resolved = false;
-		const TIMEOUT_MS = 30000; // 30s timeout
-		const timeoutId = setTimeout(() => {
-			if (!resolved) {
-				ws.close();
-				reject(new Error('Request timeout (30s)'));
-			}
-		}, TIMEOUT_MS);
 
 		const actionId = Date.now();
 
@@ -69,7 +62,6 @@ export default async function wsio(connectUrl, secret = '', action, input = '')
 			try {
 				const parsed = JSON.parse(data.toString());
 				if (parsed.id === actionId) {
-					clearTimeout(timeoutId);
 					resolved = true;
 					ws.close(1000, 'Request complete');
 					resolve(parsed);
@@ -80,17 +72,15 @@ export default async function wsio(connectUrl, secret = '', action, input = '')
 		});
 
 		ws.on('close', (code, reason) => {
-			clearTimeout(timeoutId);
 			if (!resolved) {
 				reject(new Error(`Connection closed (${code}): ${reason || 'Unknown reason'}`));
 			}
 		});
 
 		ws.on('error', (error) => {
-			clearTimeout(timeoutId);
 			if (!resolved) {
 				reject(new Error(`WebSocket error: ${error.message}`));
 			}
 		});
 	});
-}
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@j-o-r/hello-dave",
   "type": "module",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "ESM toolkit for building AI agents with unified access to Grok (XAI), OpenAI, and Anthropic endpoints",
   "main": "./lib/index.js",
   "types": "./types/index.d.ts",
@@ -51,4 +51,4 @@
   "engines": {
     "node": ">=20"
   }
-}
+}