trailmark

Homework validator — checks that user completed the QUICKSTART tutorial correctly. Runs 5 SQL/file checks (routing.db populated, project registered, demo workspace, skill invocations logged, task folder structure) plus an optional 6th self-audit step. Reports ✅/❌ per check with remediation hints. Use when: after completing QUICKSTART § 5 walkthrough, "/tutorial-check", "check my setup", "проверь мою установку", "run homework checks".

Protocol for architecturally clean execution of complex multi-block tasks. Decomposition into blocks → research before library-first → explicit decision pinning → clear scope vs out-of-scope → report after each block. Principle: every architectural decision is pinned explicitly, no ambiguity, epics don't sprawl. Use when: task has 5+ blocks; DB migration; rewriting skills; any task where architectural cleanliness must be preserved over distance

Automatic linking of an artifact to project architecture elements. Two modes: file-mode (by file paths, for fast-track flows) and feature-mode (by artifact text, for briefs/specs). Merge logic: appends to existing arch_ref, does not overwrite. Propagate: final arch_ref written up the chain epic → spec → brief. Use when: after plan-first in fast-track / pipeline; after saving brief / spec artifact

Audit-before-fix protocol — first find all gaps across 7 planes, prioritize, pin the gap table, and only then fix. Principle: never touch code until the full picture of problems is understood. Gap table → approval → flow-first per gap → library-first → plan → code. Use when: task begins with looking for problems ("find gaps in X", "audit security", "what's wrong with Y"), not with a specific fix

Meta-orchestrator: assigns skill-chain cadence per block (Tier 1/2/3) via Q1-Q6 rules. Reads target task_blocks + task.md, writes cadence-decisions-{R}.md artifact. Standalone (executor invokes) or Batch (generator hand-off). Use when: deciding cadence for a batch of blocks, generator hand-off from decomposition skills

Coverage validation protocol before a final approval gate. Reads requirements from any structured requirements document, matches them against the proposed decomposition units (blocks, epics, tasks), outputs a coverage table. If gaps exist — stops, waits for user decision. If everything is covered — continues without pause. Use when: after proposing any decomposition of work (blocks / epics / tasks) before committing to execution — as a safety net that no requirement fell through the cracks.

Makes an architectural / project / scope decision using a 5-part model INSTEAD of asking the user. Structure: 🎯 Decision / Why / 🛡 Security / 📈 Scalability / Alternatives / Plain-language analogy. 1 question = 1 atomic artifact. Use when: the agent is about to ask an architectural / scope question; "/decision-first", "decide it yourself", "apply the decision model"

Autonomous orchestrator of the per-block go-fast cycle. Takes over after arch-first/audit-first when "autopilot" mode is chosen. Runs every block: flow-first → library-first → plan-first → execute without manual approvals. Validates each skill's artifact against built-in rules. On blockers — escalates to a chat bot and waits for a reply. Use when: arch-first or audit-first asks "how do we work?" and the user chooses autopilot mode; "/dev-auto-first", "autopilot", "run automatically"

Understanding-alignment protocol before library-first. Asks the user for 2-3 anchors (file, table, route, service), reads only those (not the whole project), fills a 4×3 table (Landscape / Problem / Solution / Result × UI / DB / Integrations), waits for approval — and only then hands off to library-first. Use when: automatically as a step between task creation and library analysis; manually before any task that needs an understanding check

Adds a new conceptual guide to a project's knowledge folder. Runs in three modes: interactive (user-invoked), from-task (auto-invoked from ship-first after a fast-track completes), from-epic (from epic closure). Storage: local `.md` file under `project-knowledge/guides/{topic}/`, registered via git commit + push. No database, no admin panel — the file itself is the artifact, discoverable via file tree or search. Flow: project selection → topic selection → title → text → .md creation → git push. Use when: "/go-guide", "add guide", "new guide", "save concept", or auto-invoked at the end of ship-first when work produced a reusable concept worth documenting.

Takes the agent's last message and explains it in plain language — without technical jargon, with concrete examples and analogies. Invoked manually when the user did not understand what the agent just wrote. Use when: "/human-first", "explain in plain language", "didn't get what you wrote", "explain simpler"

Entry point of the self-organizing skill chain. Launched right after task creation. Asks 5-7 questions, determines task type (product / feature / fix), waits for approval — then proposes the next skill per branch: product → habit-first, feature → arch-first, fix → audit-first. Principle: without a defined type, the downstream skills are built on guesses. idea-first closes this gap before all the others. Use when: automatically as the first step after task creation; manually before any task needing type + scope check

Mandatory protocol before executing any fast-track task. Analyzes the task, builds a table: what we do / where it comes from / how many lines of code. Principle: maximum reuse of existing libraries and components, minimum new code. Waits for explicit user approval — does nothing until confirmed. Use when: fast-track task, quick task, before starting implementation

Saves the last assistant message as a note attached to the current task. Auto-numbered (note-01, note-02...), bidirectional link with task.md. Invoked manually by the user. Use when: "/note-first", "save a note", "remember this", "save the last message"

Mandatory protocol before any document creation, code writing, refactoring, DB migration, test plan, or git operation. Shows a plan table → picks a mode → waits for confirmation → executes step by step. Use when: before writing/refactoring code, migrating DB, writing tests, git commit/PR; "/plan-first", "make a plan first"

Final task completion protocol: report → user-note → deploy → smoke test → close? → guide? → routing.db → propagate → STATUS → sessions. Invoked from fast-track and pipeline flows after task execution, not directly by the user. Use when: invoked after the execute step of a fast-track or pipeline task

Final audit of a large task before closure — finds which operations are available only via code / curl / SQL and decides per each: automate with a skill or AI agent (A) or create a UI task (B). Protects against invisible usability debt. Walks through each implemented block: reads task.md + reports + guides + code → forms a sub-table with operations → A/B classification → master table + phased roadmap. Does not implement findings — records them as roadmap items. Use when: final step of an arch-first task before closure; review of a closed large task; "/ui-ai-first", "usability audit", "what's still only via code"

Session startup skill. Reads platform docs, builds context, asks which project we're working on, reads project docs — and is ready to work. Also handles continuation of a stuck task by restoring context from the interrupted session. Use when: start of a new terminal session, load context, resume interrupted work