Maintain DomoDomo’s local Model Context Protocol server, tool schemas, filesystem controls, process integration, and client connection behavior. Use when changing mcp-server/, src/utils/mcpClient.ts, MCP tool definitions, or local agent permissions.
Maintain DomoDomo’s local Model Context Protocol server, tool schemas, filesystem controls, process integration, and client connection behavior. Use when changing mcp-server/, src/utils/mcpClient.ts, MCP tool definitions, or local agent permissions.
DomoDomo MCP Integration
Maintain The Node MCP server and browser client that expose intentional local capabilities to DomoDomo agents.
Operating contract
Scope: The Node MCP server and browser client that expose intentional local capabilities to DomoDomo agents.
Primary files: mcp-server/src/index.ts, mcp-server/package.json, mcp-server/tsconfig.json, src/utils/mcpClient.ts, and AI MCP management components.
Before changing code: Read the current MCP transport, tool list, schema shape, workspace-root assumptions, and calling UI before adding or widening a capability.
01. MCP server startup
For MCP server startup, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For MCP server startup, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For MCP server startup, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For MCP server startup, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For MCP server startup, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For MCP server startup, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For MCP server startup, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For MCP server startup, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For MCP server startup, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For MCP server startup, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For MCP server startup, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For MCP server startup, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For MCP server startup, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For MCP server startup, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For MCP server startup, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For MCP server startup, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For MCP server startup, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For MCP server startup, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For MCP server startup, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For MCP server startup, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For MCP server startup, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
02. transport lifecycle
For transport lifecycle, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For transport lifecycle, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For transport lifecycle, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For transport lifecycle, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For transport lifecycle, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For transport lifecycle, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For transport lifecycle, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For transport lifecycle, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For transport lifecycle, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For transport lifecycle, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For transport lifecycle, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For transport lifecycle, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For transport lifecycle, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For transport lifecycle, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For transport lifecycle, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For transport lifecycle, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
03. tool naming
For tool naming, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For tool naming, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For tool naming, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For tool naming, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For tool naming, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For tool naming, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For tool naming, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For tool naming, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For tool naming, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For tool naming, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For tool naming, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For tool naming, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For tool naming, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For tool naming, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For tool naming, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For tool naming, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For tool naming, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
04. tool descriptions
For tool descriptions, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For tool descriptions, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For tool descriptions, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For tool descriptions, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For tool descriptions, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For tool descriptions, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For tool descriptions, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For tool descriptions, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For tool descriptions, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For tool descriptions, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For tool descriptions, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For tool descriptions, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For tool descriptions, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For tool descriptions, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For tool descriptions, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For tool descriptions, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For tool descriptions, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
05. JSON schema design
For JSON schema design, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For JSON schema design, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For JSON schema design, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For JSON schema design, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For JSON schema design, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For JSON schema design, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For JSON schema design, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For JSON schema design, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For JSON schema design, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For JSON schema design, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For JSON schema design, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For JSON schema design, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For JSON schema design, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For JSON schema design, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For JSON schema design, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For JSON schema design, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For , inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
06. input validation
For input validation, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For input validation, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For input validation, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For input validation, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For input validation, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For input validation, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For input validation, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For input validation, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For input validation, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For input validation, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For input validation, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For input validation, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For input validation, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For input validation, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For input validation, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For input validation, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For input validation, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
07. workspace path resolution
For workspace path resolution, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For workspace path resolution, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For workspace path resolution, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For workspace path resolution, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For workspace path resolution, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For workspace path resolution, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For workspace path resolution, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For workspace path resolution, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For workspace path resolution, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For workspace path resolution, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For workspace path resolution, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For workspace path resolution, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For workspace path resolution, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For workspace path resolution, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For workspace path resolution, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For workspace path resolution, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
08. filesystem read controls
For filesystem read controls, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For filesystem read controls, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For filesystem read controls, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For filesystem read controls, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For filesystem read controls, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For filesystem read controls, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For filesystem read controls, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For filesystem read controls, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For filesystem read controls, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For filesystem read controls, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For filesystem read controls, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For filesystem read controls, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For filesystem read controls, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For filesystem read controls, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For filesystem read controls, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For filesystem read controls, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
09. filesystem write controls
For filesystem write controls, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For filesystem write controls, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For filesystem write controls, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For filesystem write controls, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For filesystem write controls, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For filesystem write controls, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For filesystem write controls, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For filesystem write controls, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For filesystem write controls, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For filesystem write controls, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For filesystem write controls, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For filesystem write controls, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For filesystem write controls, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For filesystem write controls, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For filesystem write controls, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For filesystem write controls, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
10. command execution boundaries
For command execution boundaries, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For command execution boundaries, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For command execution boundaries, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For command execution boundaries, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For command execution boundaries, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For command execution boundaries, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For command execution boundaries, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For command execution boundaries, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For command execution boundaries, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For command execution boundaries, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For command execution boundaries, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For command execution boundaries, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For command execution boundaries, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For command execution boundaries, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For command execution boundaries, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For command execution boundaries, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
11. process output handling
For process output handling, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For process output handling, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For process output handling, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For process output handling, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For process output handling, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For process output handling, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For process output handling, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For process output handling, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For process output handling, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For process output handling, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For process output handling, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For process output handling, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For process output handling, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For process output handling, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For process output handling, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For process output handling, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
12. Ollama model discovery
For Ollama model discovery, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For Ollama model discovery, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For Ollama model discovery, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For Ollama model discovery, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For Ollama model discovery, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For Ollama model discovery, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For Ollama model discovery, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For Ollama model discovery, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For Ollama model discovery, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For Ollama model discovery, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For Ollama model discovery, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For Ollama model discovery, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For Ollama model discovery, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For Ollama model discovery, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For Ollama model discovery, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For Ollama model discovery, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
13. SSE connection behavior
For SSE connection behavior, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For SSE connection behavior, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For SSE connection behavior, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For SSE connection behavior, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For SSE connection behavior, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For SSE connection behavior, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For SSE connection behavior, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For SSE connection behavior, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For SSE connection behavior, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For SSE connection behavior, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For SSE connection behavior, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For SSE connection behavior, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For SSE connection behavior, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For SSE connection behavior, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For SSE connection behavior, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For SSE connection behavior, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
14. client connection states
For client connection states, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For client connection states, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For client connection states, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For client connection states, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For client connection states, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For client connection states, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For client connection states, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For client connection states, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For client connection states, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For client connection states, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For client connection states, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For client connection states, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For client connection states, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For client connection states, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For client connection states, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For client connection states, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
15. agent permission UX
For agent permission UX, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For agent permission UX, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For agent permission UX, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For agent permission UX, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For agent permission UX, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For agent permission UX, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For agent permission UX, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For agent permission UX, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For agent permission UX, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For agent permission UX, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For agent permission UX, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For agent permission UX, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For agent permission UX, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For agent permission UX, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For agent permission UX, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For agent permission UX, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
16. failure and timeout handling
For failure and timeout handling, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For failure and timeout handling, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For failure and timeout handling, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For failure and timeout handling, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For failure and timeout handling, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For failure and timeout handling, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For failure and timeout handling, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For failure and timeout handling, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For failure and timeout handling, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For failure and timeout handling, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For failure and timeout handling, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For failure and timeout handling, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For failure and timeout handling, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For failure and timeout handling, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For failure and timeout handling, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For failure and timeout handling, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
17. sensitive output redaction
For sensitive output redaction, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For sensitive output redaction, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For sensitive output redaction, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For sensitive output redaction, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For sensitive output redaction, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For sensitive output redaction, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For sensitive output redaction, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For sensitive output redaction, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For sensitive output redaction, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For sensitive output redaction, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For sensitive output redaction, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For sensitive output redaction, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For sensitive output redaction, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For sensitive output redaction, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For sensitive output redaction, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For sensitive output redaction, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
18. MCP build verification
For MCP build verification, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For MCP build verification, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For MCP build verification, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For MCP build verification, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For MCP build verification, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For MCP build verification, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For MCP build verification, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For MCP build verification, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For MCP build verification, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For MCP build verification, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For MCP build verification, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For MCP build verification, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For MCP build verification, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For MCP build verification, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For MCP build verification, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For MCP build verification, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
19. MCP integration testing
For MCP integration testing, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For MCP integration testing, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For MCP integration testing, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For MCP integration testing, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For MCP integration testing, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For MCP integration testing, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For MCP integration testing, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For MCP integration testing, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For MCP integration testing, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For MCP integration testing, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For MCP integration testing, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For MCP integration testing, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For MCP integration testing, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For MCP integration testing, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For MCP integration testing, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For MCP integration testing, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
20. MCP capability completion
For MCP capability completion, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For MCP capability completion, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For MCP capability completion, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For MCP capability completion, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For MCP capability completion, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For MCP capability completion, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For MCP capability completion, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For MCP capability completion, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For MCP capability completion, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For MCP capability completion, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For MCP capability completion, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For MCP capability completion, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For MCP capability completion, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For MCP capability completion, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For MCP capability completion, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For MCP capability completion, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
Completion standard
Confirm every changed surface follows this playbook and its local-first constraints.
Confirm applicable documentation, About metrics, technical records, and blog content accurately describe the final behavior.
Confirm the handoff records the commands run, validation outcome, known limits, and intentionally deferred work.
For transport lifecycle, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For transport lifecycle, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For transport lifecycle, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For transport lifecycle, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For transport lifecycle, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For tool naming, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For tool naming, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For tool naming, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For tool naming, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For tool descriptions, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For tool descriptions, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For tool descriptions, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For tool descriptions, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
JSON schema design
For JSON schema design, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For JSON schema design, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For JSON schema design, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For JSON schema design, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For input validation, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For input validation, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For input validation, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For input validation, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For workspace path resolution, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For workspace path resolution, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For workspace path resolution, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For workspace path resolution, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For workspace path resolution, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For filesystem read controls, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For filesystem read controls, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For filesystem read controls, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For filesystem read controls, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For filesystem read controls, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For filesystem write controls, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For filesystem write controls, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For filesystem write controls, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For filesystem write controls, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For filesystem write controls, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For command execution boundaries, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For command execution boundaries, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For command execution boundaries, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For command execution boundaries, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For command execution boundaries, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For process output handling, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For process output handling, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For process output handling, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For process output handling, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For process output handling, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For Ollama model discovery, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For Ollama model discovery, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For Ollama model discovery, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For Ollama model discovery, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For Ollama model discovery, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For SSE connection behavior, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For SSE connection behavior, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For SSE connection behavior, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For SSE connection behavior, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For SSE connection behavior, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For client connection states, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For client connection states, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For client connection states, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For client connection states, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For client connection states, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For agent permission UX, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For agent permission UX, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For agent permission UX, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For agent permission UX, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For agent permission UX, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For failure and timeout handling, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For failure and timeout handling, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For failure and timeout handling, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For failure and timeout handling, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For failure and timeout handling, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For sensitive output redaction, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For sensitive output redaction, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For sensitive output redaction, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For sensitive output redaction, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For sensitive output redaction, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For MCP build verification, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For MCP build verification, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For MCP build verification, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For MCP build verification, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For MCP build verification, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For MCP integration testing, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For MCP integration testing, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For MCP integration testing, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For MCP integration testing, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For MCP integration testing, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For MCP capability completion, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For MCP capability completion, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For MCP capability completion, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For MCP capability completion, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For MCP capability completion, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
