AI Agent & Automation Workflows

Use when making design decisions, debugging non-obvious issues, encountering gotchas, wondering why code is structured a certain way, or when you need context about prior work on the same feature or component. Myco captures the reasoning, trade-offs, and lessons behind the codebase — things the code itself doesn't show. Also use when the user mentions vault, spores, sessions, team knowledge, institutional memory, or prior decisions.

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 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 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.

Use when designing, writing, configuring, or debugging a new phased executor task for the Myco agent harness — even if the user doesn't explicitly ask for a "task authoring" guide. Applies when adding a new intelligence task, modifying phase structure, tuning turn budgets or model routing, adjusting scheduling triggers or session-gating, designing a tool surface, or debugging silent phase failures or budget exhaustion. Covers: YAML task anatomy and registration; phase decomposition and the judgment/recipe gradient; model selection via the advisor pattern; turn budget calibration including local-model multipliers; scheduling triggers and session-gating; tool surface design and readOnly enforcement; Grove scope iteration patterns; per-project lifecycle management; and observability via the agentruns audit table.

Procedures for Bun binary compilation, asset bundling strategies, virtual filesystem handling, build artifact packaging, multi-target compilation patterns, and binary entry point dispatch in Myco's build system. Use when compiling static binaries with Bun, managing package assets vs user files, resolving virtual filesystem paths, handling cross-platform builds, or debugging binary packaging issues, even if the user doesn't explicitly ask for Bun compilation help.

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.

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.

Comprehensive procedures for managing Myco daemon process lifecycle including startup robustness, unified eviction and restart workflows, process identity management, multi-instance coordination, health checking, update application, and resource cleanup. Covers operational daemon management patterns from auto-spawn and migration tasks through SIGTERM/SIGKILL sequences to port release verification and cross-runtime coordination. Use when starting, restarting, updating, or coordinating daemon processes, even if the user doesn't explicitly ask for daemon lifecycle management.

Use when adding a new config toggle that mutates files beyond myco.yaml (e.g., .gitignore writes, AGENTS.md managed blocks), or when building a compound provider+model dropdown field in daemon settings UI. Covers two patterns not in daemon-ui-development: (1) the 3-step config toggle side-effects architecture — boolean flag in myco.yaml → managed block in the target file → in-process registerSymbionts() reconciliation on save; (2) the ProviderModelSelector compound enum pattern for paired provider+model dropdowns where the provider selection resets and filters the model list. Also covers .gitignore scope boundaries for file-mutation toggles. For core form lifecycle triad (toFormState/builder/dirty-check), SectionSaveRow, useCallback dep completeness, and Playwright smoke test structure, see the daemon-ui-development skill.

Use when the Myco daemon is misbehaving — even if the user doesn't explicitly ask for a debugging procedure. Activates for: daemon process crashes, uncaught exceptions, FK constraint violations, PowerManager jobs not firing, scheduler starvation, outbox drain loops, duplicate or phantom sessions, executor tasks that silently succeed or stall, and any log output from the daemon's core subsystems (PowerManager, SQLite, outbox, session lifecycle, phased executor). This is the cross-cutting playbook for investigating, tracing, and surgically fixing daemon-layer bugs — distinct from debugging agent task YAML, schema migrations, or outbox architecture design.

Use 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.

Use when installing Myco for the first time, initializing Myco in a new project, or troubleshooting a broken installation. Activate even if the user just asks \"how do I get started with Myco\" or \"how do I add Myco to my project\" without explicitly saying \"install.\" Covers the full lifecycle: bootstrapping the CLI via the install script, running myco init, verifying health with myco doctor, and managing updates and removal.

Comprehensive lifecycle for authoring, registering, documenting, and maintaining MCP tools in packages/myco/src/tools/ — covering schema definition in TOOLDEFINITIONS arrays, handler implementation with DaemonClient patterns, shared tool-runtime registration, documentation bundling, anti-drift testing patterns, and cloud vs local placement decisions. Essential for maintaining the schema ↔ handler ↔ documentation triad that agents depend on for correct tool invocations, even when the user doesn't explicitly ask for MCP tool development.

Quality engineering procedures for Myco's npm workspace: build orchestration (make vs npm), cross-platform artifact validation, workspace dependency management, release workflow hardening, and CI/CD pipeline robustness. Use when setting up quality gates, debugging build failures, hardening release workflows, or managing workspace dependencies.

Use when running or debugging the Myco skill lifecycle end to end: identifying candidates from vault knowledge, curating them through approval, generating SKILL.md files, and evolving existing skills as the vault grows. It applies to skill-survey, skill-generate, skill-evolve, and any work on the Skills dashboard, including cases where candidates appear but no skills materialize, surveys return zero results, or generated skills need refreshes.

Use 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.

Comprehensive procedures for implementing and maintaining Myco's notification system across all architectural layers. Covers database schema design for notification tables, domain event emission point integration across daemon/vault/symbiont/UI domains, browser notification APIs with annoyance prevention, React component architecture for notification display, registry-driven notification configuration, and multi-mode delivery coordination. Use when implementing new notification types, integrating event emission into existing domains, building notification UI components, or coordinating notification delivery across multiple channels, even if the user doesn't explicitly ask for notification system architecture.

Use when extending the Myco notification system with a new domain, configuring notification modes, diagnosing missing or misbehaving notifications, or fixing React UI issues related to notifications — even if the user doesn't explicitly ask for notification system help. Covers: domain self-registration and default configuration; the mode resolution priority chain (payload > domain override > global default > registry default) and its critical gotcha; emission point discipline with a coverage checklist; the SystemNotifications.tsx banner-only filter requirement; dismissed-vs-deleted semantics and the full debug protocol; React Router same-URL navigation fix for notification clicks; and schema design with on-write pruning. Complements extend-myco-daemon (which covers wiring steps) with operational semantics and failure-mode playbooks.

Use when working with Myco's skill lifecycle system — whether generating a new skill from an approved candidate, reviewing the candidate queue, updating a stale skill, retiring an outdated one, or debugging why a skill wasn't triggered. Activates whenever you touch vaultskillcandidates, vaultskillrecords, or vaultwriteskill — or whenever the user asks about skills, the Skills dashboard, skill generation tasks, or the .agents/skills/ directory. Apply this skill even if the user doesn't explicitly say "skill lifecycle" — any time a task involves producing or updating a SKILL.md file, evaluating candidates, or managing skill status, this procedure applies.

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 authoring, configuring, and maintaining Myco's PowerManager infrastructure and scheduled task system. Covers PowerManager job registration and lifecycle, task scheduler architecture and configuration, per-project power state tracking implementation, scheduled task fan-out across Groves, cold-project gating and threshold management, and fire-and-forget dispatch patterns for long-running tasks.