goondocks-co
OrganizationMyco is the nervous system for AI-assisted software teams. Works automatically alongside the coding agents, subagents, and agent teams you already use
Categories
Indexed Skills (47)
mycoadd-symbiont
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.
mycoauthor-and-debug-agent-pipeline-tasks
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.
mycoauthor-harness-task
Use this skill 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; session lifecycle orchestration and agent runtime coordination; and observability via the agent_runs audit table.
mycobackup-restore-async-reliability
Activate this skill when working on the Myco backup/restore subsystem — including restore UX changes, async job architecture, daemon thread safety, or concurrency correctness in restore operations — even if the user doesn't explicitly ask about reliability or async patterns. Covers four major procedures: (1) restructuring the restore UI around a modal-based guided flow, (2) offloading long-running DB operations to a child process + async job registry, (3) parsing dump header metadata for preview without SQL execution, and (4) hardening the job registry against temp-path collisions and memory leaks.
mycobun-test-runtime-hardening
Apply this skill when hardening Bun test environments in Myco's test suite, diagnosing CI-only test failures, investigating hung test processes after all assertions pass, or adding new test files that import external SDK modules, use mock.module(), or declare module-level timers — even if the user doesn't explicitly ask about Bun runtime behavior. Covers three procedures: (1) isolating process-scoped mock.module() registrations that leak across test files and cause non-deterministic CI failures; (2) scoping module-level side effects (timers, stubs) to individual tests with explicit afterEach cleanup to prevent suite-exit hangs; and (3) lazily initializing external SDK clients (e.g., Anthropic) that eagerly construct at module load time under Bun's browser-like test environment. The shared root cause: Bun runs tests in a process-shared environment where module-scope state — mock registrations, timers, SDK clients — persists beyond the originating file.
mycocanopy-code-intelligence-development
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.
mycocanopy-manifest-driven-tool-resolution
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.
mycocapture-pipeline-durability
Implement capture pipeline resilience patterns and detect silent failure modes in the Myco daemon. Covers identifying when capture hooks fail silently while the daemon appears healthy, diagnosing liveness vs readiness issues, implementing service-manager-aware recovery patterns with capturePost(), and debugging capture ingestion delays. Essential for maintaining reliable session/prompt/event capture even when the daemon process is alive but routed endpoints are wedged.
mycocloudflare-worker-infrastructure-lifecycle
Deploy, maintain, and operate Myco's Collective worker (packages/myco-collective) — the cross-project admin layer built on Cloudflare Workers, D1, and KV. Covers the worker's package structure, the `myco-collective` operator CLI (install/upgrade/status/add-project/ rotate-tokens/destroy), D1/KV bindings, and the general Wrangler-upgrade failure modes that apply to any Cloudflare Worker package in this repo. Use this when touching packages/myco-collective/worker, running wrangler against it, or debugging its deploy/D1/KV behavior.
mycocost-optimization-performance-telemetry
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.
mycodaemon-intent-file-protocol
Apply this skill when writing, modifying, or reviewing any code that touches Myco's intent-file-mediated daemon communication protocol — even if the user doesn't explicitly ask about correctness. The protocol (write intent file → reconciler reads → acts) has four documented failure modes: (1) concurrent writers silently dropping each other's intent via shared-file merge logic, (2) intent cleared before the async action it triggers is confirmed complete, (3) intent written but never consumed when the daemon is in deep_sleep state (SELF_RECONCILE excludes deep_sleep), and (4) reconciler re-entrancy where a handler raises a new intent for the very action the reconciler is executing, producing a perpetual no-op loop. Covers diagnosis, fix patterns, and required test coverage for all four gaps.
mycodaemon-settings-form-patterns
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 reconcileConfiguredSymbionts reconciliation, fired by the daemon config-reactions on a capture/symbionts config write; (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.
mycodebug-capture
Use this skill when a Myco session, prompt, tool use, or attachment appears to have gone missing — the agent says "I sent that" but it isn't in the dashboard, a session shows zero batches, MCP tool calls hang or silently no-op, hooks aren't firing in a worktree, the buffer file isn't growing, FK constraint errors appear in the daemon log, or the symptom is "capture went silent." Also use when investigating any reported capture regression in the Myco repo. Walks the capture lifecycle top-down — agent → hook → daemon HTTP → buffer → registry → SQLite → transcript miner — and tells you which layer to look at, in what order, with the exact command to run. Replaces the "investigate capture loss from scratch" antipattern that produced repeated one-off patches.
mycodebug-daemon-errors
Use this skill whenever 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 solutioning daemon-layer bugs — distinct from debugging agent task YAML, schema migrations, or outbox architecture design.
mycofeature-branch-worktree-squash-merge-delivery
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 `code-review high` quality pass (multi-agent fan-out; `/simplify` is deprecated), `make build` as the full quality gate, or a single clean squash-merge commit for the final PR.
mycogit-release-provenance-reconciler
Implement and maintain Git-based release provenance tracking with reconciliation for squash-merge workflows. Covers Git snapshot capture, two-tier reconciliation strategy (ancestry + patch-ID matching), knowledge graph propagation, performance optimization, and privacy-aware sync design. Use this for setting up release provenance systems, troubleshooting reconciliation issues, or maintaining Git lineage tracking even if the user doesn't explicitly ask for release provenance configuration.
mycoglobal-symbiont-install
Apply this skill when working on global symbiont installation, extending the global install model, adding new symbionts for global deployment, or debugging issues that touch multiple projects simultaneously — even if the user doesn't explicitly ask about the install model or its constraints. Covers six repeatable procedures: (1) eliminating legacy fallback code during migration, (2) scoping the Symbiont page UI to auto-detect plus per-project override only, (3) scheduling symbiont health checks against PowerManager state, (4) previewing blast radius before any global write, (5) enforcing walker grove-ownership filtering to prevent cross-grove mutations, and (6) running a dry-run validation before committing global installs. Also covers the invariant that the global model is canonical — fallbacks are traps, per-project config is the escape hatch. Includes the managed skills architecture (binary-embedded, agent-standard install) and three known failure modes for global skill symlinks.
mycogrove-multi-tenant-architecture
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.
mycoinstall-and-initialize-myco
Use this skill 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, verifying health with `myco doctor`, and managing updates and removal.
mycoknowledge-placement-doctrine
Apply when deciding WHERE to record knowledge, instructions, or context in the Myco project — even if the user hasn't explicitly asked about documentation strategy. Covers five surfaces: AGENTS.md (durable agent operating rules and architectural invariants only), SKILL.md files (codified project procedures with steps and examples), inline code comments (behavioral invariants and HOW the code works — never historical narrative), the Myco vault (decisions, rationale, incidents, tradeoffs), and user-facing docs (README, CHANGELOG, docs/, marketing site — user mental model only, never internal mechanics). The wrong surface creates knowledge rot: implementation details in user docs confuse users, historical narrative in code comments becomes lies as code evolves, behavioral invariants buried only in the vault leave developers guessing at the point of action. Use this skill when writing any new knowledge, reviewing a PR for doc discipline, or auditing existing content for surface violations.
mycomcp-tool-development-lifecycle
Comprehensive lifecycle for authoring, registering, documenting, and maintaining MCP tools in packages/myco/src/tools/ — covering schema definition in TOOL_DEFINITIONS arrays, handler implementation with DaemonClient patterns, shared tool-runtime registration, documentation bundling, anti-drift testing patterns, and per-symbiont transport (mcp vs cli) 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.
mycomonorepo-quality-engineering-build-lifecycle
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.
mycomyco-sh-docs-pipeline
Apply this skill when working on the myco.sh documentation site — including adding or updating guides, modifying the build pipeline, maintaining the GitHub Actions Pages deploy workflow, auditing SEO/AI-crawler discovery, or fixing rendering bugs in the static HTML output — even if the user doesn't explicitly ask about build infrastructure or deployment. Covers four interlocking procedures: (1) dual-surface architecture — keeping raw .md files for AI crawlers while generating parallel .html in docs/_site via docs/build.mjs; (2) build pipeline configuration using markdown-it + Shiki with the linkify fuzzyLink guard in docs/lib/render.mjs; (3) discovery layer maintenance — robots.txt, sitemap.xml, llms.txt, JSON-LD, and canonical tags; and (4) GitHub Pages workflow — matching upload-pages-artifact and deploy-pages version pairs to prevent silent deploy failures.
mycomyco-skill-lifecycle
Use this skill 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.
myconative-binary-distribution
Apply this skill when working on native binary installation, upgrade pipelines, daemon binary path management, or dev/prod daemon coexistence for the Myco native installer. Covers: the steady-state binary path model (e.g., issues with code-signing on macOS have now been addressed and should be reflected in plist self-heal), the looksLikeDevBuildExecutable() service-mutation guard, managedBinaryPath() usage, the MYCO_HOME physical boundary model (prod ~/.myco vs dogfood ~/.myco-dev) that replaced the deprecated detectDevBuild() pattern, upgrade-path validation (confirm plist self-heal before testing), beta rollout sequencing for install-path changes, and the self-propagation trap requiring GA-gating any upgrade-path fix. Use this skill whenever code touches binary paths, service install/uninstall, upgrade exemption, plist config, or daemon coexistence.
myconotification-system-operations
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.
mycooperate-skill-lifecycle-pipeline
Use this skill 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 vault_skill_candidates, vault_skill_records, or vault_write_skill — 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.
mycoplan-persistence-and-agent-directed-capture
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.
mycoplatform-architecture-and-extraction
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.
mycopower-management-scheduled-tasks
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.
mycorelease-provenance-settings
Use this skill when configuring or auditing Myco's release provenance settings — even if the user doesn't explicitly ask about the full setup. Covers five procedures: (1) selecting a release provenance preset and setting productionRef/integrationRef; (2) configuring the GitHub token as a machine-scoped-only credential (never per-Grove); (3) configuring monorepo package-to-tag mapping; (4) auditing or fixing config route scope isolation in daemon code (the `req.requestContext?.projectVaultDir ?? bootstrapVaultDir` invariant); (5) navigating the Settings UI by feature flow (Release Model → GitHub Evidence → Reconciliation Behavior → Advanced). The scope isolation pattern is an ongoing architectural invariant — any config route author must apply it.
mycorun-skill-survey
Use this skill when you need to run the Myco skill-survey agent task to surface new skill candidates from accumulated vault knowledge — or when you need to review, approve, or dismiss candidates that the survey has already produced. Activate even if the user doesn't explicitly say "skill-survey" — any time they ask "what skills should we add," "why aren't there more skills," "the Skills dashboard is empty," or "how do I get the agent to generate skills," this procedure applies. Also relevant when the survey has run but produced zero candidates, when candidates have piled up awaiting review, or when a previously dismissed candidate should be reconsidered.
mycosafe-config-updates
Apply this skill whenever you need to write, update, or modify Myco configuration — whether from a React settings form, a CLI command, a task, or any other code path. This covers the two linked invariants that prevent silent data loss: (1) all YAML writes must flow through updateConfig() in packages/myco/src/config/loader.ts, and (2) all React settings forms must spread the original config before overlaying form values in their formToConfig() function. Also covers the complete procedure for adding new configurable settings to Myco's three-tier scoped config system (machine/grove/project/personal) including scope assignment decisions, Zod schema extension, API endpoint integration, useScopedConfig hook wiring, and ScopedField component wrapping. Use this skill even if the user hasn't explicitly asked about config safety — any time you touch myco.yaml, add a settings field, modify a settings page, or add new configurable fields, these patterns apply.
mycosingle-source-of-truth-refactoring
Apply this skill whenever you encounter logic, values, or transformations duplicated across multiple files in the Myco codebase — even if the user doesn't explicitly ask for a refactor. Covers five recurring SSoT patterns: (1) extracting shared read projections to the shared read-projections module, (2) centralizing provider capabilities in the shared context-window module, (3) replacing magic strings with named constants in the shared constants module, (4) creating semantic wrapper functions in the config loader and settings-merge modules, and (5) adding path properties to service state objects (DaemonServiceState). Also covers two critical violation classes to detect during code review: parallel ownership predicates (is-this-mine? checks duplicated across files) and database query locality (direct DB calls in tool files that bypass the shared data access layer). The root discipline is: name the thing, own it in one place, let consumers reference it.
mycostop-hook-fragility
Use when prompt/response capture stops working, a Claude Code hook reports a silent non-blocking error, or you're modifying anything in packages/myco/src/hooks/, the global launcher, or the EventBuffer/ reconciliation path. Stop hooks are the most fragile point in Myco's capture chain — covers three distinct, independently-diagnosable failure modes: (1) hook path wiring breaking when ~/.myco/runtime/ is deleted even though the native daemon is active, (2) capture-critical hooks needing an EventBuffer fallback so daemon restarts mid-turn don't permanently drop the assistant response, and (3) the global launcher's catch-all masking real errors as a silent "non-blocking status code, no stderr" failure. Apply this even if the user just says "capture isn't working" or "hook is erroring" without naming a root cause — the procedure here is how you tell the three apart and fix or recover from each.
mycothree-tier-config-architecture
Comprehensive procedures for implementing and managing Myco's three-tier configuration architecture with Machine/Grove/Project scope hierarchy. Covers config storage design with scope enforcement patterns, TypeScript compile-time scope validation, multi-tier settings UI development, hierarchical config merging and override resolution strategies, and migration workflows for scope boundary evolution. Use this when implementing new configuration settings, refactoring config scope boundaries, building scope-aware editing interfaces, or migrating configuration data between tiers, even if the user doesn't explicitly ask for three-tier architecture guidance.
mycoui-development-and-visual-identity
Procedures for building, maintaining, and extending Myco's React daemon UI: the v7 component-composition system (AccentSurface/Panel primitives, page-wide selection state, master-detail and slideout layouts), the Grove-owned appearance system (6 themes, light/dark/system mode, three-role fonts, density), project-scoped request context, auth-gated attachments, and the Team Host degraded-presentation family for attached (hosted) projects. Use when building or troubleshooting UI components, extending the theme/appearance system, wiring project-scoped data, or presenting attached-project degradation, even if the user doesn't explicitly ask for UI development guidance.
mycoupgrade-path-safety
Apply this skill when validating, testing, or releasing any version-to-version upgrade, addressing critical missing paths and suspected fabrications. Covers five orthogonal procedures: (1) clean-state revert methodology before upgrade testing to simulate real-world conditions; (2) CI-as-primary-gate discipline when local tests are flaky or environment-contaminated; (3) merge→publish→test release sequencing to avoid blocking on local reliability; (4) detecting and handling the self-propagation trap, where a bug disables the auto-adopt mechanism that would deliver its own fix; (5) dev environment routing via pattern extension (runtime.command + runtime.home + manual channel) instead of bespoke knobs.
mycovault-schema-extension
Use this skill when adding or evolving Myco's SQLite vault database schema — even if the user doesn't explicitly ask for "schema work." Covers: authoring versioned migration scripts with correct error guards (IF NOT EXISTS, user_version bumps), evolving existing tables with ALTER TABLE in a backfill-safe sequence, creating and populating FTS5 full-text search indexes with auto-sync triggers, keeping the dormant team-sync worker's D1 mirror parity-test-clean for any table in its synced-table set (team sync itself is retired — there is no live D1 deployment), selecting the right query patterns (WHERE IN with json_each for dynamic ID sets, hydration joins instead of N+1 selects, cursor-based pagination instead of OFFSET), Grove multi-tenant database design for global daemon architecture, and updating the constants and query modules that complete the data layer surface. Every new Myco feature that stores data touches this domain.
mycovault-schema-migration
Use this skill whenever you need to add, modify, or remove tables, columns, or indexes in the Myco vault SQLite schema — even if the user just asks to "add a column" or "create a new table." The vault uses a versioned createSchema migration chain where each schema version is a numbered step that builds on the previous one. Because user vaults accumulate real data across machines, any schema change that breaks the migration chain can corrupt or destroy vault data. This skill covers how to add a new version to the chain, write safe migration SQL, handle backfill steps, bump the schema version constant, keep the dormant team-sync worker's D1 mirror parity-test-clean if your table is in the synced-table set, and verify the migration works end-to-end before shipping.
mycoworktree-aware-request-context
Implement callerRoot vs projectRoot separation in MycoRequestContext, design filesystem API patterns with proper root classification, establish request context propagation, and architect worktree-bleed prevention. Covers request context design, filesystem root classification, API boundary patterns, and worktree-bleed prevention architecture. Essential for maintaining proper separation between project identity and caller locality in worktree environments.
mycowrite-myco-skill
Create and validate a Myco-managed SKILL.md file using vault_write_skill. Use when authoring a new skill from scratch, updating an existing skill, or fixing a skill that failed the quality gate. Applies whenever you need to produce a valid .agents/skills/<name>/SKILL.md file that passes structural validation. Also load when vault_write_skill returns a rejection error — the error message identifies the failing constraint, but this skill explains the full field contract and the known contamination pitfalls.
building-myco-discipline
Use this skill when building any non-trivial change in Myco — new features, refactors, capability work, anything touching shared state, or anything that crosses module boundaries. It codifies how Myco is built and why: capability-first architecture for shared state, structural invariants rather than procedural ones, live smoke-testing rigor, detailed code review as a normal step, and the "what was this defending against?" audit that refactors must pass. Activate this skill even when the user just asks for "a small change" — the discipline is what keeps small changes from compounding into the bug classes that this codebase has fought through three migrations.
playwright-cli
Automate browser interactions, test web pages and work with Playwright tests.
tune-agent-task-cost
Use this skill whenever you are designing, modifying, or debugging the cost profile of a Myco agent pipeline task — vault-evolve, skill-evolve, skill-survey, canopy-describe, title-summary, or any new phased task. It covers the cost-tuning patterns that have crystallized across the codebase: origin discipline on batch reads, accelerator threshold sizing, the orchestrator-as-narrower rule, mechanical pre-filtering before LLM spend, per-stage preConditions, tier-not-model phase routing, the cheap-search/expensive-write phase-split pattern, per-run work caps, and output discipline. Apply whenever you touch `packages/myco/src/agent/definitions/tasks/*.yaml`, the orchestrator, accelerator config, or any code that feeds an intelligence task. This skill is hand-managed — do NOT register it with the Myco skill pipeline.
dogfood-worktree
Procedure for dogfooding Myco changes inside a git worktree so capture, MCP, and CLI route to the worktree's own build instead of the production binary. Use when developing Myco in a git worktree, when capture/MCP in a worktree behaves like production or points at the wrong build, or when wiring up `make dev-link-worktree` / `make dev-unlink-worktree`. Covers why `.myco/runtime.command` does not travel with `git worktree add`, why a build must happen first, the direct-CLI `MYCO_HOME` gotcha, the shared-vault schema rollup hazard across worktrees, and the vendor-asset build gotcha.
prompt-tune
This skill should be used when the user asks to "tune a prompt", "evaluate a prompt", "test prompt quality", "run prompt eval", "benchmark prompts", or mentions prompt tuning, prompt testing, or model comparison for Myco's LLM prompts. Development-only skill for the Myco project.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.