Unclear scope and missing approval records make project decisions difficult to track. This skill guides request classification, charter writing, and lifecycle documentation through Executor.

Session changes can lose decisions, verification evidence, and unfinished implementation work. This skill guides human-controlled integration, durable pause records, and resumption checked against the current repository.

Long implementation plans can lose task state and accumulate unreviewed changes. This skill coordinates scoped subagents, review gates, and durable records across execution and recovery.

Unclear requirements and unsupported assumptions make technical decisions difficult. This skill guides structured discovery, evidence gathering, and approach comparisons before human approval.

Conflicting documents can carry incorrect decisions into later development phases. This skill coordinates independent audits, scoped repairs, and fresh re-audits before phase clearance.

Rough feature ideas can become specifications before alternatives and failure cases are examined. This skill structures research, independent concepts, critique, and human decisions into a recorded design.

Vague architecture leaves teams with incompatible interfaces and undocumented decisions. This skill structures architecture, decisions, contracts, and component designs for human review before specification.

Long coding projects lose context, decisions, and review evidence across sessions. Executor records initiative state and coordinates phase routing, task dispatch, and approval gates.

NestJS changes can introduce incompatible syntax, hidden side effects, and public API regressions. This skill guides repository inspection, focused implementation, and evidence-based verification.

Unclear responsibilities and unnecessary abstractions make NestJS code difficult to change and test. This skill guides evidence-based object design, pattern selection, and behavior-preserving refactoring.

Mixed changes and unclear publication requests can produce misleading commits or unintended remote updates. This skill guides verified Git changes and accurate messages within authorized scope.

NestJS runtime changes can create latency, security, and deployment failures when teams lack clear contracts and measurements. This skill guides component selection, bottleneck diagnosis, and reliable implementation using repository evidence and focused tests.

Source code alone cannot establish whether a NestJS feature satisfies its roadmap. This skill compares requirements with revision-specific evidence and reports completed work, gaps, legacy paths, bugs, and blockers.

NestJS repositories can hide boundary flaws and runtime risks that lint results alone cannot reveal. This skill combines local evidence collection and semantic review into one prioritized report.

Ending a long coding session can lose decisions, verified progress, and unresolved tasks. This skill organizes that context into a structured note for the next session.

Unclear module boundaries make NestJS changes harder to test and coordinate. This skill guides evidence-based architecture decisions, explicit ownership, and incremental boundary repairs.

Many application features need semantic judgments, but free-form model responses are difficult to combine reliably in code. TypeSafe helps developers design small typed judgments and compose them into routing, ranking, extraction, verification, and interactive workflows.

Trading ideas often lose context across tools and conversations. This skill stores validated thesis records, manages lifecycle changes, and produces reviews and postmortems.

Weekly charts can produce conflicting signals and vague forecasts. This skill structures chart evidence into trends, levels, patterns, and probability-weighted scenarios.

Manual trade decisions can bypass plans and risk controls. This skill checks local inputs and records a clear decision before broker entry.