Bun runs its test suite in a shared process where module-scope state persists across test files. This creates three categories of hard-to-diagnose failures: process-scoped mock registrations that poison unrelated tests, module-level timers that block suite exit, and eager SDK construction that fails

This skill covers two advanced patterns for daemon settings UI that are **not** in `daemon-ui-development`:

Procedure for safely claiming a production Grove for local dogfooding of the dev binary. Use when testing changes against production-shaped Grove data without risking permanent mutations. Activate when the user says "claim", "dogfood against prod", "test against production", or "release a claimed Grove."

The codebase shows you **what** exists. Myco shows you **why** it exists — why this approach was chosen over alternatives, what broke along the way, what's non-obvious. When you're wondering *why* something is the way it is, or *whether* something was already tried, Myco has the answers.

The Myco agent harness is a phased executor running inside the daemon. Each task is an ordered sequence of phases — each phase is a single LLM invocation with a bounded tool surface and a turn budget. This skill covers the full authoring lifecycle: designing the phase sequence, writing the task co

Carry a session's working **intention** to another session cleanly. The codebase shows *what* exists and the plan shows *what's next* — this skill captures the *why* and *how we got here* that neither stores, compresses it to ≤1500 tokens, and rides it on a Myco plan (the cross-symbiont shared v

This skill covers the operational semantics of the Myco notification system — the gotchas, configuration rules, and debug protocols a developer needs when extending, configuring, or diagnosing notification domains. For the mechanical wiring steps (registry → emission → display → React hook),

Keep AGENTS.md minimal, durable, and canonical across agents. Use for adding, trimming, or auditing project rules without turning the rules file into a dump of dynamic context.

Use this skill when adding a new symbiont (agent integration) to Myco's SymbiontInstaller — the component that manages agent lifecycle operations (init, update, remove, doctor) for all registered agents. Activates whenever you need to onboard a new AI agent (Claude Code, Cursor, Windsurf, a custom agent, etc.) so that `myco init`, `myco update`, and `myco doctor` manage its installation. Apply this skill even if the user doesn't explicitly mention SymbiontInstaller — any time you're adding a new agent type, creating a symbiont manifest, wiring new hook templates, or extending the supported agents list, this skill applies. Also relevant when a new symbiont needs the cross-platform hook guard or environment variable injection.

Use this skill when authoring, configuring, or debugging Myco agent pipeline tasks. It covers task YAML anatomy, scheduling, parameter injection, timeout and concurrency behavior, audit-log interpretation, turn-budget failures, skill-lifecycle task constraints, and hardening patterns for new tasks and MCP tools. Apply it whenever work touches `src/agent/tasks/`, `src/agent/executor.ts`, `src/daemon/task-scheduler.ts`, or `src/mcp/tools/`, even if the user does not explicitly mention task authoring.

Comprehensive procedures for building and extending Myco's Canopy code intelligence system. Covers agent harness task standardization, three-layer file exclusion models, context injection and attribution pipelines, hook response shape compatibility, local-only aggregation architecture, and scanner configuration workflows. Apply when developing file indexing capabilities, extending intelligence features, or integrating code analysis workflows, even if the user doesn't explicitly ask for canopy system development.

Implement manifest-driven tool resolution for Canopy read-tool detection across symbionts. Covers adding canopyReadTools discriminated union declarations to symbiont manifests (structured vs shell-pattern modes), implementing symbiont-agnostic resolvers, unifying pre/post tool-use hooks, and updating database queries to respect manifest declarations. Use when adding new symbionts that need Canopy integration, extending tool resolution capabilities, or debugging read-tool detection issues, even if the user doesn't explicitly ask for manifest-driven architecture.

Deploy, maintain, and operate Myco's multi-worker Cloudflare infrastructure including team sync D1/Vectorize deployment, cloud MCP server operations, collective worker configuration, Wrangler upgrade hardening, Workers KV auth token lifecycle, and D1 schema migration ordering. Use this for any Cloudflare Worker deployment, D1 database operations, MCP server management, multi-worker coordination, Wrangler CLI troubleshooting, or cross-worker infrastructure tasks, even if the user doesn't explicitly mention the full infrastructure scope.

Comprehensive procedures for analyzing, optimizing, and monitoring LLM costs and performance in Myco's agent harness system. Covers cost leak identification, performance bottleneck analysis, resource allocation optimization, SDK execution telemetry, and budget calibration patterns. Use when investigating cost spikes, optimizing agent task efficiency, calibrating turn budgets, or implementing cost control measures, even if the user doesn't explicitly ask for cost optimization analysis.

Use this skill when delivering a non-trivial Myco feature that spans multiple files and needs clean PR history. It applies whenever you need git worktrees for isolated implementation, the `/simplify` quality pass, `make build` as the full quality gate, or a single clean squash-merge commit for the final PR.

Comprehensive procedures for implementing and managing Myco's Grove multi-tenant architecture with request context management. Covers request context threading through transport boundaries, project identity binding via .myco/project.toml, multi-tenant database schema design, context enforcement across six layers, MCP transport unification, Grove registry management, and comprehensive importer architecture. Use when implementing multi-tenant features, setting up Grove projects, debugging context propagation issues, or ensuring request context isolation.

Procedures for operating multiple daemon instances with proper isolation, ownership enforcement, and boundary controls across development/production environments. Covers Grove ownership enforcement, multi-environment service directory coordination, scope-aware iteration, ownership gates, legacy scope elimination, and multi-tenant daemon coordination. Use when setting up multiple daemon instances, enforcing Grove ownership boundaries, or coordinating development/production environments, even if the user doesn't explicitly ask for multi-environment orchestration.

Use this skill when adding or maintaining a Myco symbiont integration, or debugging capture-pipeline and installer issues for a supported agent. It covers architectural foundations, manifests, hook templates, transcript parsing, image and attachment format differences, declarative capture rules, the cross-platform hook guard, SymbiontInstaller wiring, installer fixtures, session identity, phantom-session defenses, environment-variable injection, transcript path parsing failures, registration.mcpCwd field for portable MCP launch, SDK-specific MCP configuration requirements (Claude SDK auto-loading, OpenAI strict function-calling, strictMcpConfig, settingSources control), Runtime.command redirect mechanisms, substituteRuntimeCommand flag for PATH collision handling, universal stop buffer fallback patterns, scratchProbe() session validation, installer skill discovery, MCP tool registration verification procedures, API verification discipline, and source==exec capture filter for sub-agent phantom defense.

Procedures for implementing and maintaining Myco's plan persistence architecture, including logical-key identity models, agent-directed capture patterns via MCP tools, cross-channel deduplication strategies, unified capture helper architecture, plan lineage tracking, and search integration. Use when implementing plan capture systems, designing logical-key strategies, building MCP capture tools, or resolving plan deduplication conflicts, even if the user doesn't explicitly ask for plan persistence architecture.

Comprehensive procedures for platform architecture design and package extraction methodology for multi-product deployment. Covers platform vision strategy, API surface analysis, package boundary design, ownership separation, and phased extraction implementation. Use this when architecting platform solutions, extracting reusable packages, or designing multi-product architectures, even if the user doesn't explicitly ask for platform extraction guidance.