Codymaster cm-start

Start the CM Workflow to execute your objective from idea to production code.

install

source · Clone the upstream repo

git clone https://github.com/tody-agent/codymaster

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/tody-agent/codymaster "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/cm-start" ~/.claude/skills/tody-agent-codymaster-cm-start && rm -rf "$T"

manifest: skills/cm-start/SKILL.md

source content

Command:

/cm-start [your objective]

Role: Workflow Orchestrator — You assess complexity, select the right workflow depth, and drive execution from objective to production code.

When this workflow is called, the AI Assistant should execute the following action sequence in the spirit of the CodyMaster Kit:

Load Working Memory: Per
```
_shared/helpers.md#Load-Working-Memory
```
— use Smart Spine order:
1. Check
```
.cm/context-bus.json
```
  → any active pipeline? any prior skill output to reuse?
2. Load L0 indexes:
```
learnings-index.md
```
  (~100 tok) +
```
skeleton-index.md
```
  (~500 tok)
3. Scope-filter learnings via
```
cm_query
```
  — only load what matches current objective
4. Read
```
CONTINUITY.md
```
  → set Active Goal to the new objective
5. Run token budget check:
```
cm continuity budget
```
  → confirm no category is over soft limit
⚡ Total context load: ~700 tokens. Full load used to be ~3,200. Only escalate to L2 (full files) if L0 index explicitly flags a match. 0.5. Skill Coverage Check (Adaptive Discovery):
- Scan the objective for technologies, frameworks, or patterns mentioned
- Cross-reference with
```
cm-skill-index
```
  Layer 1 triggers
- If gap detected → trigger Discovery Loop from
```
cm-skill-mastery
```
  Part C:
```
npx skills find "{keyword}"
```
  → review → ask user → install if approved
- Log any discovered skills to
```
.cm-skills-log.json
```

0.7. Code Intelligence Setup (cm-codeintell): - ALWAYS: Run skeleton indexer →

bash scripts/index-codebase.sh

→

.cm/skeleton.md

- Read

.cm/skeleton.md

(~5K tokens) → instant codebase understanding - Count source files → determine intelligence level (MINIMAL/LITE/STANDARD/FULL) - IF level >= LITE: generate architecture diagram →

.cm/architecture.mmd

- IF level >= STANDARD: check CodeGraph →

codegraph status

→ index if needed - IF level >= STANDARD: also check qmd (cm-deep-search) for existing semantic vector databases and initialize/update if needed. - Log intelligence level to

CONTINUITY.md

Understand Requirements (Planning & JTBD):
- Read the objective provided in the
```
/cm-start
```
  command.
- Analyze requirements, ask clarifying questions if needed (apply
```
cm-planning
```
  ).
- Consider multi-language support (i18n) from the start if the project requires it.
Detect Project Level: Per
```
_shared/helpers.md#Project-Level-Detection
```
- Analyze the objective to determine L0/L1/L2/L3 complexity
- Present detected level and recommended skill chain to the user
- Let user confirm or override the level
Execute Based on Level:

L0 (Micro): Code + Test only
- Skip planning. Apply
```
cm-tdd
```
  directly →
```
cm-quality-gate
```
L1 (Small): Planning lite → Code → Deploy
- Apply
```
cm-planning
```
  (lightweight implementation plan)
- Apply
```
cm-tdd
```
  +
```
cm-execution
```
  →
```
cm-quality-gate
```
L2 (Medium): Full analysis flow
- Init OpenSpec (create
```
openspec/changes/[initiative-name]/
```
  folder and artifacts manually)
- Apply
```
cm-brainstorm-idea
```
  if problem is ambiguous
- Apply
```
cm-planning
```
  (full implementation plan with OpenSpec
```
tasks.md
```
  )
- Create
```
cm-tasks.json
```
  from
```
tasks.md
```
  → launch RARV autonomous execution
- Apply
```
cm-quality-gate
```
  →
```
cm-safe-deploy
```
L3 (Large): Full + PRD + Architecture + Sprint
- Init OpenSpec (create
```
openspec/changes/[initiative-name]/
```
  folder and artifacts manually)
- Apply
```
cm-brainstorm-idea
```
  (mandatory)
- Apply
```
cm-planning
```
  with FR/NFR requirement tracing
- Sprint planning →
```
openspec/changes/[objective]/tasks.md
```
  sync with
```
cm-tasks.json
```
- Apply
```
cm-execution
```
  (Mode E: TRIZ-Parallel for speed)
- Apply
```
cm-quality-gate
```
  →
```
cm-safe-deploy
```
Track Progress:
- Create
```
openspec/changes/[objective]/tasks.md
```
  (for standardized spec tracking)
- Create or update
```
cm-tasks.json
```
  (for autonomous agent execution)
- Suggest
```
/cm-dashboard
```
  for visual tracking
- Suggest
```
/cm-status
```
  for quick terminal summary
Complete: Per
```
_shared/helpers.md#Update-Continuity
```
- Record any new learnings or decisions made during this workflow
- If inside a skill chain:
```
cm continuity bus
```
  → verify context bus reflects completed step
- Refresh L0 indexes:
```
cm continuity index
```
  (auto-runs on
```
addLearning
```
  , manual refresh here)

Note for AI: If this is a brand new project, suggest running
cm-project-bootstrap
first. If the working environment has a risk of accidentally switching accounts/projects, remind about
cm-identity-guard
(Per
_shared/helpers.md#Identity-Check
).