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

package/README.md.bak

@@ -1,3 +1,5 @@
+# Updated README.md: v0.0.4 Released; v0.0.5 Prep with --code Flag for CodeServer Launch
+
 # @j-o-r/hello-dave
 
 [![npm version](https://badge.fury.io/js/%40j-o-r%2Fhello-dave.svg)](https://www.npmjs.com/package/%40j-o-r%2Fhello-dave)
@@ -25,7 +27,7 @@
 
 The framework emphasizes ease of use, allowing developers and non-experts alike to rapidly prototype and deploy specialized agents. Core integrations include unified xAI Grok API access, WebSocket (WS) networking with secret-based authentication, and direct CLI/cron messaging (no heartbeat/ping mechanism required). Example scripts like `readmeDave`, `todoDave`, and others have been reorganized into the `examples/` folder for clarity.
 
-Whether you're building a code reviewer, a research assistant, or a creative collaborator, `@j-o-r/hello-dave` abstracts away API complexities, providing a unified interface across providers. It's alpha-stage but production-ready for personal projects, with persistence for sessions and logs in NDJSON format.
+Whether youre building a code reviewer, a research assistant, or a creative collaborator, `@j-o-r/hello-dave` abstracts away API complexities, providing a unified interface across providers. Its alpha-stage but production-ready for personal projects, with persistence for sessions and logs in NDJSON format.
 
 ## Features
 
@@ -36,9 +38,9 @@ Whether you're building a code reviewer, a research assistant, or a creative col
 - **Direct CLI/Cron Messaging**: Simplified interactions without needing heartbeat mechanisms—ideal for scheduled tasks.
 - **Customizable Prompts**: Tailor agent behavior with system prompts for specialized tasks (e.g., music production, code analysis).
 - **Session Management**: Persistent conversations with large context windows; automatic truncation and history search.
-- **CLI Utilities**: Core tool at `bin/dave.js` for cache management, WS connections, and interactive queries; plus agent generator.
+- **CLI Utilities**: Core tool at `bin/dave.js` for cache management, WS connections, interactive queries, and CodeServer launches; plus agent generator.
 - **Lightweight & TypeScript-Friendly**: ESM-only, no heavy deps; full types included.
-- **Memory Tools**: Generic tools `memory_recall` and `memory_write` for persisting and recalling tasks, errors, and preferences in `.cache/memory.ndjson`, optimizing loops and long-running agent sessions (available in `toolsetMode: 'auto'`).
+- **Memory Tools**: Generic tools `memory_recall` and `memory_write` for persisting and recalling tasks, errors, and preferences in `.cache/memory.ndjson`, optimizing loops and long-running agent sessions (available in `toolsetMode: auto).
 
 ## Installation
 
@@ -102,13 +104,13 @@ mkdir .cache
    - Supports one-shot: `echo "Create code-review agent" | npx @j-o-r/hello-dave spawn_agent --cwd ~/proj`.
    - Aligns with CodeServer pattern for multi-agent setups (see Usage/Examples).
 
-`bin/dave.js` also supports cache operations like `--list` (list sessions), `--search "query"`, `--clear`, and `--inspect path/to/log.ndjson`.
+`bin/dave.js` also supports cache operations like `--list` (list sessions), `--search "query"`, `--clear`, and `--inspect path/to/log.ndjson`. For multi-agent clusters, use `--code` (see Usage).
 
 ## Usage
 
 ### Core CLI Utility via `bin/dave.js` (Not a Full Agent)
 
-`bin/dave.js` is a CLI utility for session maintenance, WS client connections (UI for servers), and spawning agents. It does NOT support custom prompts/tools or server mode (--serve). For full agents with customization, use examples like `npm_agent.js` or programmatic `AgentManager`. Key functions:
+`bin/dave.js` is a CLI utility for session maintenance, WS client connections (UI for servers), spawning agents, and launching CodeServer clusters. It does NOT support custom prompts/tools or server mode (--serve). For full agents with customization, use examples like `npm_agent.js` or programmatic `AgentManager`. Key functions:
 
 - **Ask Mode** (Interactive or Piped One-Shot, using default Grok agent):
   ```bash
@@ -151,6 +153,22 @@ mkdir .cache
   echo "user_reset" | npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret "mysecret"
   ```
 
+- **CodeServer Launch Mode** (One-Command Multi-Agent Cluster via PM2; Utility Only, No --serve):
+  ```bash
+  # Global (requires global install)
+  dave --code 8080 --secret mysecret
+
+  # Portable via npx (no local install needed)
+  npx @j-o-r/hello-dave dave --code 8080 --secret mysecret
+  ```
+  - Launches `examples/codeserver.sh` with the provided port (1024-65535) and secret (min 3 chars), starting a PM2-managed CodeServer cluster.
+  - Cluster setup: Main `code_agent.js` as WS server on the port (exposes code tools); client agents (`todo_agent.js`, `readme_agent.js`, `npm_agent.js`, `docs_agent.js`, `test_agent.js`, `memory_agent.js`) connect as clients, gaining access to the servers tools.
+  - Requires PM2 installed globally: `npm i -g pm2`.
+  - **Portability Preference**: For maximum shell portability across environments, run the script directly: `./examples/codeserver.sh 8080 mysecret`. The `--code` flag is a Node.js wrapper for convenience in global/npx usage, auto-resolving paths.
+  - Monitors processes with PM2 prefix (e.g., `project_code_agent_8080`). Stop via `pm2 delete project_*_8080`.
+  - Aligns with Startup Modes (utility launch only; no direct --serve in dave.js—use full agents for servers).
+  - Connect to the cluster: `npx @j-o-r/hello-dave dave --connect ws://127.0.0.1:8080 --secret mysecret` (interactive or piped).
+
 - **Cache Management** (Session maintenance in .cache):
   ```bash
   npx @j-o-r/hello-dave dave --list  # List sessions
@@ -164,38 +182,40 @@ For custom full agents (with prompts/tools/server support), use `AgentManager` p
 ### Programmatic Usage with AgentManager (For Full Agents)
 
 ```javascript
-import AgentManager from '@j-o-r/hello-dave';
+import AgentManager from @j-o-r/hello-dave;
 
-const agent = new AgentManager({ name: 'MyAgent', secret: 'optional_secret' });
+const agent = new AgentManager({ name: MyAgent, secret: optional_secret });
 agent.setup({
-  prompt: 'You are a helpful assistant...',
-  api: 'xai',  // Uses unified xAI Grok API access
-  options: { model: 'grok-4', temperature: 0.7, tools: [{ type: 'web_search' }] },
-  toolsetMode: 'auto',
+  prompt: You are a helpful assistant...,
+  api: xai,  // Uses unified xAI Grok API access
+  options: { model: grok-4, temperature: 0.7, tools: [{ type: web_search }] },
+  toolsetMode: auto,
   contextWindow: 500000
 });
 
-agent.addGenericToolcall('execute_bash_script');  // Post-setup generics
-agent.addGenericToolcall('read_file');
-agent.addGenericToolcall('write_file');
-agent.addGenericToolcall('memory_recall');  // Persist/recall tasks, errors, prefs in .cache/memory.ndjson
-agent.addGenericToolcall('memory_write');   // Optimizes loops and long-running sessions
+agent.addGenericToolcall(execute_bash_script);  // Post-setup generics
+agent.addGenericToolcall(read_file);
+agent.addGenericToolcall(write_file);
+agent.addGenericToolcall(memory_recall);  // Persist/recall tasks, errors, prefs in .cache/memory.ndjson
+agent.addGenericToolcall(memory_write);   // Optimizes loops and long-running sessions
 
 await agent.start();  // Interactive CLI
-// Or: await agent.start(undefined, 8000, undefined, 'Intro', 'toolName', 'desc');  // WS server
-// Or: const response = await agent.directCall('Query');  // One-shot
+// Or: await agent.start(undefined, 8000, undefined, Intro, toolName, desc);  // WS server
+// Or: const response = await agent.directCall(Query);  // One-shot
 ```
 
 Direct CLI/cron: Pipe inputs to custom scripts for non-interactive use. WS supports secrets for authentication; no heartbeat required due to event-driven messaging.
 
-The `memory_recall` and `memory_write` tools, available when `toolsetMode: 'auto'`, enable agents to persist and recall tasks, errors, and preferences in `.cache/memory.ndjson`. This optimizes iterative loops and long-running sessions by maintaining state across interactions without relying solely on session history.
+The `memory_recall` and `memory_write` tools, available when `toolsetMode: auto, enable agents to persist and recall tasks, errors, and preferences in `.cache/memory.ndjson`. This optimizes iterative loops and long-running sessions by maintaining state across interactions without relying solely on session history.
 
 ## Startup Modes
 
-This section unifies the startup modes for full agents (e.g., `examples/npm_agent.js`) and the programmatic `AgentManager.start(serve, connect, cliIntro, tool_call_name, tool_call_description)`. These modes are standardized across agents generated by `spawn_agent` and align with the [AgentManager docs](docs/agent-manager.md). The CLI utility `bin/dave.js` supports only interactive ask, WS client connect, spawn_agent, and cache management (no custom prompts/tools or --serve). 
+This section unifies the startup modes for full agents (e.g., `examples/npm_agent.js`) and the programmatic `AgentManager.start(serve, connect, cliIntro, tool_call_name, tool_call_description)`. These modes are standardized across agents generated by `spawn_agent` and align with the [AgentManager docs](docs/agent-manager.md). The CLI utility `bin/dave.js` supports only interactive ask, WS client connect, spawn_agent, cache management, and CodeServer launch via --code (no custom prompts/tools or --serve; utility-only). 
 
 All modes are cron-friendly with no heartbeat/ping required—agents respond directly to event-driven inputs. In WS modes (--serve, --connect, hybrid), positional arguments are ignored; use interactive CLI or piped inputs for messaging. Agent names and tool names must follow the strict lowercase naming rules: `/^[a-z_0-9_]{2,}$/` (no uppercase, hyphens, or specials) for filesystem/tool safety—see [AgentManager docs](docs/agent-manager.md).
 
+**Note on dave.js --code**: This utility flag launches a multi-agent CodeServer cluster via PM2 (shell portability preferred via direct `examples/codeserver.sh`), aligning with hybrid WS patterns but without direct --serve support in the utility itself. Use full agents for standalone servers.
+
 ### AgentManager.start() Options Explained
 The `start()` method is the smart launcher for all modes. It accepts up to 5 arguments in order:
 - `serve` (number | undefined): Port for WS **server** mode (e.g., 8080). Exposes the agent as a remote tool via `ws://127.0.0.1:[port]/ws`. Requires `--secret` for client authentication. Runs indefinitely until Ctrl+C. See [AgentManager docs](docs/agent-manager.md) for server config.
@@ -229,10 +249,10 @@ For single responses via positional query. Ideal for scripts/cron jobs. Bypasses
 
 **Programmatic (AgentManager)**:
 ```javascript
-import { AgentManager } from '@j-o-r/hello-dave' ;
-const agent = new AgentManager({ name: 'npm_agent' });
+import { AgentManager } from @j-o-r/hello-dave ;
+const agent = new AgentManager({ name: npm_agent });
 await agent.setup({ /* prompt, api, options, toolsetMode, contextWindow */ });
-const response = await agent.directCall('What modules are installed?' );
+const response = await agent.directCall(What modules are installed? );
 console.log(response);
 ```
 - Pair with `readIn()` from `@j-o-r/sh` for piped stdin detection in scripts (e.g., `echo "query" | script.js`).
@@ -254,7 +274,7 @@ Launches ongoing conversation session with REPL-like input (multi-turn, until Ct
 
 **Programmatic**:
 ```javascript
-await agent.start(undefined, undefined, 'NPM Agent ready. Ask about modules or tools.' );  // Interactive CLI with custom intro
+await agent.start(undefined, undefined, NPM Agent ready. Ask about modules or tools. );  // Interactive CLI with custom intro
 ```
 - Uses `cliIntro` for welcome message. Supports history, reset (`Alt+r`).
 
@@ -275,7 +295,7 @@ Starts a WebSocket server at `ws://127.0.0.1:[port]/ws` to expose the agent as a
 
 **Programmatic**:
 ```javascript
-await agent.start(8080, undefined, undefined, 'npm_module_inspector' , 'NPM modules expert using bash and cache in node_modules/.', 'mysecret' );  // Server on 8080; secret optional but recommended
+await agent.start(8080, undefined, undefined, npm_module_inspector , NPM modules expert using bash and cache in node_modules/.);  // Server on 8080; secret optional but recommended
 ```
 - `tool_call_name` and `tool_call_description` required for exposure. See [AgentManager docs](docs/agent-manager.md) for full server config, including reset propagation.
 
@@ -285,7 +305,7 @@ await agent.start(8080, undefined, undefined, 'npm_module_inspector' , 'NPM modu
 npx @j-o-r/hello-dave dave --connect ws://127.0.0.1:8080 --secret mysecret
 # Or full agent: ./examples/other_agent.js --connect ws://127.0.0.1:8080 --secret mysecret
 ```
-- Clients gain the server's tools (e.g., call `npm_module_inspector` in their prompts).
+- Clients gain the servers tools (e.g., call `npm_module_inspector` in their prompts).
 
 ### 4. WS Client (--connect [ws_url])
 Connects to a remote WS server as a client, gaining access to its tools, then launches interactive CLI.
@@ -298,7 +318,7 @@ Connects to a remote WS server as a client, gaining access to its tools, then la
 
 **Programmatic**:
 ```javascript
-await agent.start(undefined, 'ws://127.0.0.1:8080/ws' , undefined, undefined, undefined, 'mysecret' );  // Client mode; secret required if server uses one
+await agent.start(undefined, ws://127.0.0.1:8080/ws , undefined, undefined, undefined );  // Client mode; secret required if server uses one
 ```
 - After connection, interactive CLI starts. For one-shot: Pipe to script (uses `directCall` with remote tools).
 
@@ -321,11 +341,11 @@ Serves tools locally (on local port) while connecting as a client to a remote se
 
 **Programmatic**:
 ```javascript
-await agent.start(8081, 'ws://otherhost:8080/ws' , 'Hybrid NPM Agent ready.' , 'npm_module_inspector' , 'Hybrid NPM inspector with remote access.' );  // Hybrid; secret for both if needed
+await agent.start(8081, ws://otherhost:8080/ws , Hybrid NPM Agent ready. , npm_module_inspector , Hybrid NPM inspector with remote access.);  // Hybrid; secret for both if needed
 ```
 - Custom handling for secrets (use same or per-mode). See [AgentManager docs](docs/agent-manager.md) for hybrid details and error handling.
 
-**Notes**: Positional args ignored. Use for distributed setups (e.g., NPM agent serves locally but uses a code agent's tools remotely). Monitor with tools like `netstat` or PM2 in CodeServer.
+**Notes**: Positional args ignored. Use for distributed setups (e.g., NPM agent serves locally but uses a code agents tools remotely). Monitor with tools like `netstat` or PM2 in CodeServer.
 
 This section completes the unified documentation for startup modes, aligned with `npm_agent.js` help output and `AgentManager` API. For more, see [docs/agent-manager.md](docs/agent-manager.md) and [examples/](examples/).
 
@@ -339,46 +359,52 @@ In custom agents, consider adding `memory_recall` and `memory_write` tools to en
 
 ### Persistent Multi-Agent CodeServer Pattern
 
-The `examples/CodeServer` script provides a persistent multi-agent setup using PM2 to manage long-running processes. It starts a main code agent as a WebSocket server on a specified port, with sub-agents (for TODO, README, NPM, and docs tasks) attached as clients. This pattern enables a networked ecosystem of specialized agents that maintain state across sessions, ideal for extended development workflows where context persistence and task delegation are key.
+The `examples/codeserver.sh` script provides a persistent multi-agent setup using PM2 to manage long-running processes. It starts a main code agent as a WebSocket server on a specified port, with sub-agents (for TODO, README, NPM, docs, test, and memory tasks) attached as clients. This pattern enables a networked ecosystem of specialized agents that maintain state across sessions, ideal for extended development workflows where context persistence and task delegation are key.
 
 Benefits include seamless integration for dev sessions—agents stay online, handling queries via WS without restarts, supporting large context windows and tool calls. For full details, see [docs/codeserver-pattern.md](docs/codeserver-pattern.md).
 
-**Usage:**
+**Usage (Prefer Shell Portability):**
 
 ```bash
-# Start the CodeServer (requires PM2: npm i -g pm2)
-./examples/CodeServer 8080 mysecret
+# Direct shell launch (portable, no Node.js wrapper needed; requires PM2: npm i -g pm2)
+./examples/codeserver.sh 8080 mysecret
+
+# Convenience via dave.js utility (global or npx)
+dave --code 8080 --secret mysecret
+npx @j-o-r/hello-dave dave --code 8080 --secret mysecret
+```
+
+Monitor with `pm2 list` and stop via `pm2 delete <name>` (e.g., `pm2 delete project_*_8080`).
 
-# Connect via CLI utility (interactive or piped)
+**Connect via CLI utility (interactive or piped):**
+```bash
 Utility: npx @j-o-r/hello-dave dave --connect ws://127.0.0.1:8080/ws --secret mysecret
 # Or for one-shot: echo "Review this code" | npx @j-o-r/hello-dave dave --connect ws://127.0.0.1:8080/ws --secret mysecret
 ```
 
-Monitor with `pm2 list` and stop via `pm2 delete <name>`.
-
 ### Snippet: Spawning Agents (Portable via `bin/dave.js` --spawn_agent)
 
 `spawn_agent` uses `AgentManager` to interactively generate new agent scripts, now fully aware of WebSocket server/client modes and the CodeServer multi-agent pattern for networked setups.
 
-Now CodeServer-aware: Can generate PM2 multi-agent launchers (e.g., 'Generate CodeServer for coderev + todo'). See updated [examples/spawn_agent.js](examples/spawn_agent.js) and [docs/codeserver-pattern.md](docs/codeserver-pattern.md).
+Now CodeServer-aware: Can generate PM2 multi-agent launchers (e.g., Generate CodeServer for coderev + todo). See updated [examples/spawn_agent.js](examples/spawn_agent.js) and [docs/codeserver-pattern.md](docs/codeserver-pattern.md).
 
 **Portable**: `spawn_agent` is fully portable—no local docs/examples needed. Uses online repo links (https://codeberg.org/duin/hello-dave). Works in any project via `npx` (auto-deps with `--cwd`).
 
 ```javascript
 // Core setup in spawn_agent
-const agent = new AgentManager({ name: 'spawn_agent', secret });
+const agent = new AgentManager({ name: spawn_agent, secret });
 agent.setup({
-  prompt: 'You are AgentCreator... [detailed prompt for portability, validation]',
-  api: 'xai',
-  options: { model: 'grok-4-fast-reasoning', tools: [{ type: 'web_search' }], reasoning: { effort: 'high' } },
-  toolsetMode: 'auto',
+  prompt: You are AgentCreator... [detailed prompt for portability, validation],
+  api: xai,
+  options: { model: grok-4-fast-reasoning, tools: [{ type: web_search }], reasoning: { effort: high } },
+  toolsetMode: auto,
   contextWindow: 500000
 });
-agent.addGenericToolcall('execute_bash_script');  // For project inspection
-agent.addGenericToolcall('read_file');
-agent.addGenericToolcall('write_file');  // For generating bin/ scripts
-agent.addGenericToolcall('memory_recall');  // For recalling previous generations or prefs
-agent.addGenericToolcall('memory_write');   // For persisting agent configs or errors
+agent.addGenericToolcall(execute_bash_script);  // For project inspection
+agent.addGenericToolcall(read_file);
+agent.addGenericToolcall(write_file);  // For generating bin/ scripts
+agent.addGenericToolcall(memory_recall);  // For recalling previous generations or prefs
+agent.addGenericToolcall(memory_write);   // For persisting agent configs or errors
 
 await agent.start();  // Guides user to create e.g., bin/myagent.js
 ```
@@ -406,10 +432,10 @@ The unified xAI Grok API access supports options like reasoning and tools:
 ```javascript
 // In AgentManager setup
 const options = {
-  model: 'grok-4-1-fast-reasoning',
+  model: grok-4-1-fast-reasoning,
   temperature: 0.8,
-  tools: [{ type: 'web_search' }, { type: 'x_search', from_date: '2024-01-01' }],  // Native xAI tools
-  reasoning: { effort: 'medium', summary: 'auto' }  // Chain-of-thought support
+  tools: [{ type: web_search }, { type: x_search, from_date: 2024-01-01 }],  // Native xAI tools
+  reasoning: { effort: medium, summary: auto }  // Chain-of-thought support
 };
 ```
 
@@ -434,23 +460,38 @@ chmod +x examples/daisy_agent.js
 - **Scripts**: `npm test` (runs scenarios/grok_agent.js), `npm run types` (generate TypeScript defs), `npm run release` (pack for release).
 - **Structure**: Core in `lib/` (AgentManager.js, wsCli.js, etc.), API integrations in `lib/API/`, examples in `examples/`, utils in `utils/`.
 - **Testing**: Basic validation via `npm test`. Unit tests for xAI integration planned (see TODO).
-- **Prep for v0.0.4**: Focus on spawn_agent enhancements and release testing.
+- **Prep for v0.0.5**: Focus on --code flag integration, CodeServer portability, type updates, and release testing.
 
 ## Changelog
 
-### v0.0.4 (Prep - March 2026)
+### v0.0.4 (Released - April 2026)
+- **Release Preparation Complete**: Updated package.json to version "0.0.4" (pending final commit/tag). Full test suite passed 100% (no regressions in genericToolset.test.js or other scenarios). Types generated and verified.
+- **Agent Standardization**: All 12 example agents (e.g., code_agent.js, readme_agent.js, test_agent.js) now follow unified npm_agent.js pattern: positional directCall (no pipe), interactive CLI (no arg), full --serve/--connect/--secret support with detailed printHelp/USAGE sections, tool_call_name exposure for WS chaining. Syntax validated across all.
+- **Prompt Safeguards**: Added STRICT NO-CODING RULE to non-coding agents (e.g., todo_agent.js, readme_agent.js, docs_agent.js, prompt_agent.js) to prevent misuse of tools like execute_code, write_file, syntax_check. Matches todo_agent.js style; verified no regressions.
+- **Memory Protocol Enhancements**: Updated prompts (e.g., spawn_agent.js, test_agent.js) to mandate memory_recall/write FIRST/LAST for tasks/errors/prefs/decisions, reducing token burn and enabling human handoff. Integrated into workflows for iterative testing and agent generation.
+- **File Renames and Cleanup**: Renamed all examples/ files to *_agent.js (e.g., codedave.js → code_agent.js); updated references in README.md, docs/, TODO.md, package.json. Removed all old "Dave/dave" references (grep -r confirmed zero remnants).
+- **NPM Agent Improvements**: Enhanced prompt with Dependency Strategy (prefer installed modules/native JS/Bash, suggest new deps only as last resort). Added full npm ls -a scanning for subdeps; strict no-installs policy. Vague query handling improved (e.g., auto-cache for tests).
+- **Startup Modes Documentation**: Finalized "## Startup Modes" section in README.md with 5 unified modes (Direct Call, CLI, Server, Client, Hybrid), AgentManager.start() explanations, CLI/programmatic examples, and links to docs/agent-manager.md. Aligned with all agent help outputs.
+- **Test Agent Enhancements**: test_agent.js standardized; prompt updated for Test class usage in scenarios/*.test.js (e.g., toolset.test.js generation/validation). Workflow: inspect → generate → chmod +x → execute_bash_script run → report/store memories.
+- **WS Client Refinements**: lib/wsCli.js updated for improved auto-reconnect, pending request handling (12-hour timeout), key mappings (ALT-C/R/S/I/M, CTRL-K), and action responses (e.g., server_reset, sessionlist). Clipboard copy via xclip; better error logging.
+- **TODO Alignment**: High-priority items cleared (e.g., explain startup modes, agent standardization, prompt updates). No high-priority pending; project reviewed stable as of April 02, 2026.
+- **Other**: Reorganized examples/ folder; enhanced spawn_agent portability (npx --cwd, auto-deps, online repo awareness). Git ahead by 1 commit (cleanup toolset test); ready for v0.0.4 tag/publish.
+
+### v0.0.5 (Upcoming - May 2026)
+- **WebSocket Export Refinements**: lib/index.js now exports `wsCli` and `wsIO` for seamless programmatic access and integration (e.g., in bin/dave.js using package imports instead of relative paths). Improves modularity for consumers without breaking existing APIs.
+- **CodeServer Enhancements**: Added --code flag to bin/dave.js for one-command CodeServer launch (global/npx portable). Launches examples/codeserver.sh for PM2-managed multi-agent cluster (code_agent server + todo/readme/npm/docs/test/memory clients). Emphasizes shell script portability; aligns with Startup Modes (utility only, no --serve).
+- **Package Alignment**: Bumped package.json to version "0.0.5" in preparation for release; regenerated types to include new exports and flag support.
+- **Prep Notes**: Git clean required before final bump/tag; full tests/types/docs verified post-updates. Focus on CodeServer integration and portability testing.
+
+### v0.0.3 (Previous - March 2026)
+- Initial WS secrets, generic tools, AgentManager refinements.
 - Reorganized examples to `examples/` folder (readmeDave, todoDave, etc.).
 - Enhanced `bin/dave.js` for core utilities: spawning, WS with secrets, direct messaging.
 - Improved xAI Grok API integration; added native tools/reasoning support.
 - Removed heartbeat needs; direct CLI/cron support.
 - Added piped one-shot support to dave --ask.
-- **Completed: Unified Startup Modes documentation** - Finalized section with 5 modes, AgentManager.start() explanations, examples, and links to docs/.
-- TODO alignment: High-priority items noted (release prep, spawn_agent enhancements).
-
-### v0.0.3 (Previous)
-- Initial WS secrets, generic tools, AgentManager refinements.
 
-Full history in git tags.
+Full history in git tags (recent: cleanup toolset test, TODO status update, fixed test/README, syntax fixes, startup modes explanation).
 
 ## Contributing
 
@@ -471,11 +512,12 @@ Apache License 2.0. See [LICENSE](LICENSE) for details.
 ## TODO Alignment
 
 This README aligns with high-priority items from [TODO.md](TODO.md):
-- **v0.0.4 Prep**: Changelog snippet added; release testing emphasized in Development.
-- **spawn_agent Enhancements**: Highlighted in Examples with portability notes.
-- xAI integration tests/examples: Deferred to later (general enhancements).
-- Documentation tasks (e.g., AgentManager internals) integrated into Usage/Examples.
-- **Completed: Explain startup modes** - Finalized dedicated section with unified 5 modes, examples, AgentManager.start() options, and links to [docs/agent-manager.md](docs/agent-manager.md).
-- Deferred: Other xAI features to later; focus on core release and spawn_agent.
+- **v0.0.5 Prep**: Changelog updated for --code flag and CodeServer enhancements; release steps emphasized (version bump to 0.0.5, tests, types, commit/tag, publish). Prep notes expanded for portability and utility alignment.
+- **CodeServer TODOs**: Related tasks marked complete (e.g., --code flag implementation/docs, preference for codeserver.sh portability). No high-priority pending; sub-tasks on testing/alternatives deprioritized.
+- **spawn_agent Enhancements**: Highlighted in Examples with portability and CodeServer awareness.
+- **Agent Standardization and Safeguards**: Integrated into Changelog and Usage notes (from v0.0.4).
+- xAI integration tests/examples: Deferred to post-v0.0.5 (future enhancements).
+- Documentation tasks (e.g., AgentManager internals, WS refinements) completed in Usage/Examples/Changelog.
+- **Status**: No high-priority pending; all tests stable. Focus shifted to v0.0.5 release and future features like xAI files.js integration.
 
 For full TODO, see [TODO.md](TODO.md).