Create and maintain browser-first DomoDomo utility tools and their product registrations. Use when adding or changing a component in src/tools, a tool registry entry, dashboard card, technical documentation record, category, or export workflow.
Create and maintain browser-first DomoDomo utility tools and their product registrations. Use when adding or changing a component in src/tools, a tool registry entry, dashboard card, technical documentation record, category, or export workflow.
DomoDomo Tool Authoring
Maintain Standalone local browser utilities, their registry metadata, dashboard visibility, documentation, metrics, and release content.
Operating contract
Scope: Standalone local browser utilities, their registry metadata, dashboard visibility, documentation, metrics, and release content.
Before changing code: Read a comparable tool in the same category, its engine registration, dashboard metadata, documentation record, and export implementation.
01. tool problem definition
For tool problem definition, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For tool problem definition, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For tool problem definition, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For tool problem definition, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For tool problem definition, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For tool problem definition, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For tool problem definition, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For tool problem definition, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For tool problem definition, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For tool problem definition, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For tool problem definition, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For tool problem definition, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For tool problem definition, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For tool problem definition, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For tool problem definition, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For tool problem definition, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For tool problem definition, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For tool problem definition, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For tool problem definition, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For tool problem definition, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For tool problem definition, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
02. category selection
For category selection, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For category selection, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For category selection, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For category selection, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For category selection, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For category selection, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For category selection, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For category selection, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For category selection, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For category selection, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For category selection, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For category selection, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For category selection, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For category selection, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For category selection, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For category selection, 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.
03. component file placement
For component file placement, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For component file placement, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For component file placement, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For component file placement, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For component file placement, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For component file placement, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For component file placement, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For component file placement, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For component file placement, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For component file placement, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For component file placement, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For component file placement, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For component file placement, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For component file placement, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For component file placement, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For component file placement, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
04. stable tool identifiers
For stable tool identifiers, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For stable tool identifiers, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For stable tool identifiers, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For stable tool identifiers, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For stable tool identifiers, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For stable tool identifiers, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For stable tool identifiers, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For stable tool identifiers, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For stable tool identifiers, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For stable tool identifiers, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For stable tool identifiers, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For stable tool identifiers, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For stable tool identifiers, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For stable tool identifiers, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For stable tool identifiers, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For stable tool identifiers, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
05. registry object design
For registry object design, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For registry object design, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For registry object design, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For registry object design, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For registry object design, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For registry object design, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For registry object design, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For registry object design, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For registry object design, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For registry object design, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For registry object design, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For registry object design, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For registry object design, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For registry object design, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For registry object design, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For registry object design, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
06. dashboard card metadata
For dashboard card metadata, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For dashboard card metadata, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For dashboard card metadata, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For dashboard card metadata, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For dashboard card metadata, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For dashboard card metadata, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For dashboard card metadata, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For dashboard card metadata, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For dashboard card metadata, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For dashboard card metadata, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For dashboard card metadata, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For dashboard card metadata, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For dashboard card metadata, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For dashboard card metadata, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For dashboard card metadata, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For dashboard card metadata, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
07. local-only processing
For local-only processing, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For local-only processing, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For local-only processing, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For local-only processing, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For local-only processing, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For local-only processing, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For local-only processing, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For local-only processing, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For local-only processing, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For local-only processing, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For local-only processing, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For local-only processing, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For local-only processing, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For local-only processing, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For local-only processing, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For local-only processing, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
08. single file workflows
For single file workflows, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For single file workflows, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For single file workflows, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For single file workflows, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For single file workflows, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For single file workflows, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For single file workflows, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For single file workflows, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For single file workflows, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For single file workflows, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For single file workflows, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For single file workflows, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For single file workflows, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For single file workflows, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For single file workflows, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For single file workflows, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
09. batch file workflows
For batch file workflows, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For batch file workflows, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For batch file workflows, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For batch file workflows, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For batch file workflows, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For batch file workflows, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For batch file workflows, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For batch file workflows, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For batch file workflows, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For batch file workflows, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For batch file workflows, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For batch file workflows, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For batch file workflows, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For batch file workflows, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For batch file workflows, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For batch file workflows, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
10. format validation
For format validation, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For format validation, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For format validation, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For format validation, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For format validation, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For format validation, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For format validation, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For format validation, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For format validation, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For format validation, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For format validation, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For format validation, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For format validation, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For format validation, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For format validation, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For format validation, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For format validation, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
11. preview rendering
For preview rendering, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For preview rendering, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For preview rendering, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For preview rendering, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For preview rendering, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For preview rendering, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For preview rendering, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For preview rendering, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For preview rendering, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For preview rendering, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For preview rendering, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For preview rendering, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For preview rendering, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For preview rendering, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For preview rendering, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For preview rendering, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For preview rendering, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
12. download and export actions
For download and export actions, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For download and export actions, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For download and export actions, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For download and export actions, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For download and export actions, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For download and export actions, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For download and export actions, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For download and export actions, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For download and export actions, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For download and export actions, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For download and export actions, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For download and export actions, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For download and export actions, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For download and export actions, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For download and export actions, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For download and export actions, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
13. canvas viewport controls
For canvas viewport controls, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For canvas viewport controls, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For canvas viewport controls, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For canvas viewport controls, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For canvas viewport controls, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For canvas viewport controls, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For canvas viewport controls, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For canvas viewport controls, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For canvas viewport controls, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For canvas viewport controls, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For canvas viewport controls, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For canvas viewport controls, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For canvas viewport controls, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For canvas viewport controls, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For canvas viewport controls, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For canvas viewport controls, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
14. worker lifecycle handling
For worker lifecycle handling, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For worker lifecycle handling, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For worker lifecycle handling, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For worker lifecycle handling, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For worker lifecycle handling, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For worker lifecycle handling, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For worker lifecycle handling, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For worker lifecycle handling, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For worker lifecycle handling, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For worker lifecycle handling, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For worker lifecycle handling, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For worker lifecycle handling, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For worker lifecycle handling, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For worker lifecycle handling, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For worker lifecycle handling, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For worker lifecycle handling, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
15. large file limitations
For large file limitations, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For large file limitations, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For large file limitations, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For large file limitations, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For large file limitations, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For large file limitations, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For large file limitations, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For large file limitations, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For large file limitations, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For large file limitations, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For large file limitations, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For large file limitations, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For large file limitations, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For large file limitations, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For large file limitations, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For large file limitations, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
16. technical documentation records
For technical documentation records, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For technical documentation records, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For technical documentation records, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For technical documentation records, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For technical documentation records, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For technical documentation records, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For technical documentation records, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For technical documentation records, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For technical documentation records, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For technical documentation records, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For technical documentation records, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For technical documentation records, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For technical documentation records, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For technical documentation records, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For technical documentation records, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For , test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
17. documentation page discoverability
For documentation page discoverability, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For documentation page discoverability, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For documentation page discoverability, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For documentation page discoverability, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For documentation page discoverability, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For documentation page discoverability, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For documentation page discoverability, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For documentation page discoverability, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For documentation page discoverability, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For documentation page discoverability, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For documentation page discoverability, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For documentation page discoverability, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For documentation page discoverability, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For documentation page discoverability, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For documentation page discoverability, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
18. About page metrics
For About page metrics, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For About page metrics, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For About page metrics, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For About page metrics, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For About page metrics, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For About page metrics, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For About page metrics, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For About page metrics, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For About page metrics, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For About page metrics, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For About page metrics, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For About page metrics, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For About page metrics, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For About page metrics, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For About page metrics, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For About page metrics, 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.
19. blog announcement content
For blog announcement content, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For blog announcement content, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For blog announcement content, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For blog announcement content, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For blog announcement content, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For blog announcement content, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For blog announcement content, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For blog announcement content, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For blog announcement content, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For blog announcement content, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For blog announcement content, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For blog announcement content, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For blog announcement content, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For blog announcement content, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For blog announcement content, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For blog announcement content, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
20. tool completion verification
For tool completion verification, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For tool completion verification, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For tool completion verification, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For tool completion verification, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For tool completion verification, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For tool completion verification, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For tool completion verification, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For tool completion verification, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For tool completion verification, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For tool completion verification, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For tool completion verification, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For tool completion verification, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For tool completion verification, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For tool completion verification, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For tool completion verification, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For tool completion verification, 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.
category selection
For category selection, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For category selection, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For category selection, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For category selection, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For component file placement, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For component file placement, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For component file placement, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For component file placement, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For component file placement, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For stable tool identifiers, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For stable tool identifiers, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For stable tool identifiers, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For stable tool identifiers, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For stable tool identifiers, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For registry object design, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For registry object design, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For registry object design, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For registry object design, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For registry object design, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For dashboard card metadata, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For dashboard card metadata, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For dashboard card metadata, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For dashboard card metadata, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For dashboard card metadata, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For local-only processing, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For local-only processing, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For local-only processing, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For local-only processing, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For local-only processing, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For single file workflows, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For single file workflows, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For single file workflows, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For single file workflows, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For single file workflows, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For batch file workflows, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For batch file workflows, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For batch file workflows, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For batch file workflows, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For batch file workflows, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For format validation, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For format validation, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For format validation, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For format validation, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For preview rendering, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For preview rendering, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For preview rendering, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For preview rendering, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For download and export actions, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For download and export actions, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For download and export actions, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For download and export actions, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For download and export actions, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For canvas viewport controls, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For canvas viewport controls, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For canvas viewport controls, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For canvas viewport controls, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For canvas viewport controls, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For worker lifecycle handling, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For worker lifecycle handling, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For worker lifecycle handling, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For worker lifecycle handling, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For worker lifecycle handling, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For large file limitations, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For large file limitations, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For large file limitations, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For large file limitations, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For large file limitations, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
technical documentation records
For technical documentation records, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For technical documentation records, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For technical documentation records, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For technical documentation records, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For technical documentation records, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For documentation page discoverability, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For documentation page discoverability, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For documentation page discoverability, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For documentation page discoverability, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For documentation page discoverability, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For documentation page discoverability, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
About page metrics
For About page metrics, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For About page metrics, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For About page metrics, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For About page metrics, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For blog announcement content, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For blog announcement content, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For blog announcement content, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For blog announcement content, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For blog announcement content, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For tool completion verification, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For tool completion verification, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For tool completion verification, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For tool completion verification, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For tool completion verification, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
