Maintain DomoDomo’s local FastAPI application, routers, SQLite models, local services, and Python utilities. Use when changing backend/, API contracts, CORS behavior, persistence logic, RAG helpers, or development service startup.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Maintain DomoDomo’s local FastAPI application, routers, SQLite models, local services, and Python utilities. Use when changing backend/, API contracts, CORS behavior, persistence logic, RAG helpers, or development service startup.
DomoDomo Backend FastAPI
Maintain The local FastAPI backend that supports DomoDomo without becoming a hosted or externally reachable service.
Operating contract
Scope: The local FastAPI backend that supports DomoDomo without becoming a hosted or externally reachable service.
Primary files: backend/main.py, backend/database.py, backend/models.py, backend/routers/, backend/utils/, backend/requirements.txt, and scripts/start-backend.cjs.
Before changing code: Read the relevant router, database helper, request models, startup behavior, and frontend caller before adding an endpoint or changing a payload.
01. application startup
For application startup, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For application startup, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For application startup, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For application startup, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For application startup, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For application startup, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For application startup, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For application startup, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For application startup, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For application startup, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For application startup, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For application startup, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For application startup, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For application startup, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For application startup, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For application startup, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For application startup, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For application startup, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For application startup, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For application startup, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For application startup, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
02. router ownership
For router ownership, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For router ownership, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For router ownership, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For router ownership, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For router ownership, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For router ownership, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For router ownership, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For router ownership, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For router ownership, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For router ownership, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For router ownership, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For router ownership, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For router ownership, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For router ownership, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For router ownership, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For router ownership, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For router ownership, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
03. request validation
For request validation, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For request validation, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For request validation, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For request validation, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For request validation, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For request validation, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For request validation, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For request validation, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For request validation, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For request validation, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For request validation, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For request validation, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For request validation, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For request validation, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For request validation, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For request validation, 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.
04. response contracts
For response contracts, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For response contracts, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For response contracts, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For response contracts, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For response contracts, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For response contracts, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For response contracts, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For response contracts, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For response contracts, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For response contracts, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For response contracts, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For response contracts, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For response contracts, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For response contracts, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For response contracts, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For response contracts, 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.
05. HTTP error semantics
For HTTP error semantics, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For HTTP error semantics, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For HTTP error semantics, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For HTTP error semantics, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For HTTP error semantics, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For HTTP error semantics, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For HTTP error semantics, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For HTTP error semantics, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For HTTP error semantics, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For HTTP error semantics, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For HTTP error semantics, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For HTTP error semantics, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For HTTP error semantics, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For HTTP error semantics, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For HTTP error semantics, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For HTTP error semantics, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
06. local CORS configuration
For local CORS configuration, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For local CORS configuration, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For local CORS configuration, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For local CORS configuration, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For local CORS configuration, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For local CORS configuration, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For local CORS configuration, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For local CORS configuration, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For local CORS configuration, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For local CORS configuration, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For local CORS configuration, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For local CORS configuration, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For local CORS configuration, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For local CORS configuration, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For local CORS configuration, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For local CORS configuration, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
07. SQLite connection handling
For SQLite connection handling, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For SQLite connection handling, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For SQLite connection handling, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For SQLite connection handling, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For SQLite connection handling, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For SQLite connection handling, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For SQLite connection handling, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For SQLite connection handling, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For SQLite connection handling, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For SQLite connection handling, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For SQLite connection handling, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For SQLite connection handling, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For SQLite connection handling, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For SQLite connection handling, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For SQLite connection handling, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For SQLite connection handling, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
08. schema compatibility
For schema compatibility, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For schema compatibility, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For schema compatibility, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For schema compatibility, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For schema compatibility, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For schema compatibility, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For schema compatibility, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For schema compatibility, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For schema compatibility, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For schema compatibility, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For schema compatibility, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For schema compatibility, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For schema compatibility, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For schema compatibility, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For schema compatibility, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For schema compatibility, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
09. migration safety
For migration safety, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For migration safety, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For migration safety, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For migration safety, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For migration safety, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For migration safety, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For migration safety, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For migration safety, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For migration safety, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For migration safety, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For migration safety, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For migration safety, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For migration safety, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For migration safety, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For migration safety, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For migration safety, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For migration safety, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
10. transaction boundaries
For transaction boundaries, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For transaction boundaries, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For transaction boundaries, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For transaction boundaries, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For transaction boundaries, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For transaction boundaries, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For transaction boundaries, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For transaction boundaries, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For transaction boundaries, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For transaction boundaries, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For transaction boundaries, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For transaction boundaries, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For transaction boundaries, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For transaction boundaries, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For transaction boundaries, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For transaction boundaries, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
11. background processing
For background processing, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For background processing, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For background processing, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For background processing, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For background processing, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For background processing, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For background processing, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For background processing, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For background processing, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For background processing, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For background processing, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For background processing, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For background processing, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For background processing, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For background processing, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For background processing, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
12. streaming endpoints
For streaming endpoints, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For streaming endpoints, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For streaming endpoints, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For streaming endpoints, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For streaming endpoints, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For streaming endpoints, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For streaming endpoints, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For streaming endpoints, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For streaming endpoints, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For streaming endpoints, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For streaming endpoints, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For streaming endpoints, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For streaming endpoints, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For streaming endpoints, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For streaming endpoints, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For streaming endpoints, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
13. chat service behavior
For chat service behavior, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For chat service behavior, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For chat service behavior, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For chat service behavior, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For chat service behavior, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For chat service behavior, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For chat service behavior, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For chat service behavior, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For chat service behavior, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For chat service behavior, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For chat service behavior, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For chat service behavior, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For chat service behavior, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For chat service behavior, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For chat service behavior, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For chat service behavior, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
14. memory service behavior
For memory service behavior, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For memory service behavior, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For memory service behavior, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For memory service behavior, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For memory service behavior, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For memory service behavior, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For memory service behavior, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For memory service behavior, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For memory service behavior, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For memory service behavior, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For memory service behavior, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For memory service behavior, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For memory service behavior, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For memory service behavior, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For memory service behavior, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For memory service behavior, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
15. OCR and ML routes
For OCR and ML routes, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For OCR and ML routes, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For OCR and ML routes, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For OCR and ML routes, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For OCR and ML routes, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For OCR and ML routes, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For OCR and ML routes, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For OCR and ML routes, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For OCR and ML routes, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For OCR and ML routes, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For OCR and ML routes, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For OCR and ML routes, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For OCR and ML routes, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For OCR and ML routes, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For OCR and ML routes, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For OCR and ML routes, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
For OCR and ML routes, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
16. RAG utility boundaries
For RAG utility boundaries, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For RAG utility boundaries, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For RAG utility boundaries, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For RAG utility boundaries, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For RAG utility boundaries, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For RAG utility boundaries, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For RAG utility boundaries, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For RAG utility boundaries, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For RAG utility boundaries, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For RAG utility boundaries, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For RAG utility boundaries, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For RAG utility boundaries, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For RAG utility boundaries, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For RAG utility boundaries, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For RAG utility boundaries, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For RAG utility boundaries, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
17. sensitive data logging
For sensitive data logging, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For sensitive data logging, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For sensitive data logging, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For sensitive data logging, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For sensitive data logging, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For sensitive data logging, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For sensitive data logging, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For sensitive data logging, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For sensitive data logging, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For sensitive data logging, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For sensitive data logging, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For sensitive data logging, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For sensitive data logging, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For sensitive data logging, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For sensitive data logging, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For sensitive data logging, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
18. local service failures
For local service failures, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For local service failures, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For local service failures, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For local service failures, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For local service failures, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For local service failures, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For local service failures, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For local service failures, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For local service failures, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For local service failures, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For local service failures, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For local service failures, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For local service failures, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For local service failures, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For local service failures, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For local service failures, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
19. backend integration testing
For backend integration testing, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For backend integration testing, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For backend integration testing, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For backend integration testing, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For backend integration testing, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For backend integration testing, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For backend integration testing, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For backend integration testing, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For backend integration testing, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For backend integration testing, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For backend integration testing, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For backend integration testing, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For backend integration testing, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For backend integration testing, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For backend integration testing, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For backend integration testing, test the narrowest realistic scenario first, then test a large or slow input and a user interruption before declaring success.
20. backend change completion
For backend change completion, establish the exact user-facing outcome and explicitly state which behavior is intentionally out of scope.
For backend change completion, read the nearest existing implementation before creating files, types, helpers, or a second pattern for the same job.
For backend change completion, map every caller, consumer, and persisted or exported output affected by this area before changing a contract.
For backend change completion, prefer the smallest local implementation that fits the established DomoDomo architecture and preserves offline behavior.
For backend change completion, use explicit TypeScript or Python types at boundaries; reject malformed values early and explain recovery to the user.
For backend change completion, keep user files, prompts, tokens, metadata, and derived artifacts on the device unless a documented local service is required.
For backend change completion, avoid adding a remote dependency, analytics call, credential requirement, or hidden network transfer to solve a local workflow.
For backend change completion, design empty, invalid, loading, cancellation, permission-denied, and failure states before treating the happy path as complete.
For backend change completion, release resources deterministically: revoke object URLs and terminate workers, listeners, streams, timers, and subscriptions.
For backend change completion, bound memory, CPU, and rendering work for large inputs; provide progress and a clear limit instead of freezing the interface.
For backend change completion, reuse DomoDomo visual patterns, semantic controls, labels, focus behavior, responsive rules, and accessible feedback.
For backend change completion, keep identifiers stable and align names, categories, descriptions, paths, exports, and documentation across all affected surfaces.
For backend change completion, record non-obvious browser, model, file-format, hardware, or platform limitations where agents and users will encounter them.
For backend change completion, treat logs, exception messages, generated artifacts, and command output as potentially sensitive; minimize what is retained or shown.
For backend change completion, verify that retries and repeated actions are safe and do not duplicate records, leak handles, or leave stale UI state.
For backend change 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 router ownership, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For router ownership, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For router ownership, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For router ownership, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
request validation
For request validation, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For request validation, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For request validation, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For request validation, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
response contracts
For response contracts, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For response contracts, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For response contracts, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For response contracts, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For HTTP error semantics, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For HTTP error semantics, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For HTTP error semantics, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For HTTP error semantics, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For HTTP error semantics, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For local CORS configuration, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For local CORS configuration, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For local CORS configuration, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For local CORS configuration, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For local CORS configuration, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For SQLite connection handling, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For SQLite connection handling, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For SQLite connection handling, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For SQLite connection handling, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For SQLite connection handling, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For schema compatibility, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For schema compatibility, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For schema compatibility, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For schema compatibility, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For schema compatibility, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For migration safety, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For migration safety, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For migration safety, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For migration safety, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For transaction boundaries, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For transaction boundaries, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For transaction boundaries, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For transaction boundaries, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For transaction boundaries, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For background processing, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For background processing, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For background processing, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For background processing, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For background processing, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For streaming endpoints, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For streaming endpoints, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For streaming endpoints, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For streaming endpoints, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For streaming endpoints, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For chat service behavior, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For chat service behavior, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For chat service behavior, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For chat service behavior, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For chat service behavior, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For memory service behavior, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For memory service behavior, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For memory service behavior, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For memory service behavior, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For memory service behavior, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For OCR and ML routes, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For OCR and ML routes, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For OCR and ML routes, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For OCR and ML routes, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For RAG utility boundaries, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For RAG utility boundaries, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For RAG utility boundaries, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For RAG utility boundaries, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For RAG utility boundaries, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For sensitive data logging, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For sensitive data logging, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For sensitive data logging, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For sensitive data logging, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For sensitive data logging, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For local service failures, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For local service failures, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For local service failures, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For local service failures, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For local service failures, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For backend integration testing, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For backend integration testing, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For backend integration testing, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For backend integration testing, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For backend integration testing, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
For backend change completion, inspect the final diff for accidental generated files, credentials, databases, model data, unrelated refactors, and false claims.
For backend change completion, run the applicable project command and report its result; do not infer correctness from a visual inspection alone.
For backend change completion, update product-facing documentation, technical records, metrics, and blog content whenever this area changes a public capability.
For backend change completion, preserve unrelated working-tree changes and do not rewrite another contributor’s implementation without explicit scope.
For backend change completion, finish with a concise handoff that identifies changed files, verification evidence, limitations, and remaining follow-up work.
