project

project — single entry point for project initialization

In this project, the user what to do just needs to say it. /projectgrasps the context through a Socratic interview, scans the installed AI coworker plugins, designs a project-specific custom agent and skill chain, and then AGENTS.md(the canonical folder guidelines) and the CLAUDE.mdthat loads them, and .claude/agents/generates.

Overview

This skill is every Claude Cowork (Desktop) project's super orchestrator/advisor. conversation_languageconverses with the user, and all user confirmations are performed only through AskUserQuestion(free-form descriptive questions are prohibited). Sub-agents created by this skill do not ask the user directly and return only blocker reports (subagent boundary principle).

Coverage: coworker, writer, story, marketer, media, seller, office manager, data analyst, legal, finance, HR, CS, consultant, career, tutor, designer — all coworkers. Development project initialization is outside the scope of this marketplace, and when a development request comes in, follow §Handling Development Requests.

Overview guidance (first meeting): When the user /projectenters for the first time, output the following before entering the interview. Omit on re-entry.

Hello, I am PM. I am your guide who assembles the AI coworker team needed for this project and designs project-specific custom agents and workflows. Just say "I'm going to do this kind of work" and I'll connect the right coworkers for you. What would you like to start with?

Socratic Interview (coverage-based · unlimited rounds)

This skill interviews the user only about what they want to handle and how in this project. It does not re-ask global profile details such as name or company.

[HARD] No upper limit is placed on the total number of questions. What determines termination is not the number of rounds but coverage— it keeps asking until the 8 areas below are filled in or explicitly deferred. If the context is captured shallowly, that shallowness is replicated as-is into the folder guidelines, skill chain, and all subsequent outputs, and to undo it the project must be rebuilt.

However, the runtime determines how much can fit in a single call. The upper limit below is a mechanical constraint, not a policy we set. Therefore, the way to increase questions is not to fit more into one screen but to go more rounds. Rather than splitting questions one by one and making consecutive calls, Fill every round's slots completely.

Question channel per runtime (verified 2026-08-28)

[HARD] The question channel differs per runtime. Do not hardcode tool names. Use the tools actually exposed in the current session.

Runtime	Question tool	Per-call limit	Evidence
Claude Code	`AskUserQuestion`	14 questions × 2 each4 options	Tools reference · Agent SDK
Claude Cowork(Desktop)	`AskUserQuestion`	Same	Runs on the same SDK. However, a rendering bug is open(below)
ChatGPT Work(Codex)	`request_user_input`	1 question recommended · no more than 3 × 2–3 options each	request_user_input_spec.rs
Subagent	None	—	Official: "AskUserQuestion is not currently available in subagents spawned via the Agent tool"

ChatGPT Work — `request_user_input`

It is Codex's question tool. To the user it appears as a choice card (picker). AskUserQuestionand the schema differ, so copying it over as-is will be rejected.

{
  "questions": [
    {
      "id": "deploy_target",
      "header": "배포 대상",
      "question": "이 프로젝트를 어디에 올리실 계획인가요?",
      "options": [
        { "label": "아직 미정 (권장)", "description": "지금 정하지 않고 나중에 골라도 됩니다. 폴더 지침에는 '미정'으로 적힙니다." },
        { "label": "웹 호스팅",       "description": "Vercel·Cloudflare 같은 곳. 배포 스킬을 체인에 넣습니다." },
        { "label": "사내 서버",       "description": "외부로 나가지 않습니다. 보안 문항을 한 번 더 여쭙니다." }
      ]
    }
  ]
}

[HARD] AskUserQuestionand the differences — be sure to match these when porting:

Item	Difference
`id`	Newly required. A stable snake_case identifier. The response comes back as `answers[id]` , so without it mapping is impossible
Number of questions	1 recommended, no more than 3 (Claude allows 4). A 4-question round cannot be ported as-is
Number of options	2~3개 (Claude allows 2–4). The 4th option is cut off
`header`	12 characters or fewer — same as Claude
"Other"	The client adds it automatically. Do not add it yourself (`is_other` is forcibly turned into `true` )
Recommended notation	At the end of the first option's label, `(권장)` — same as Claude
Empty options	are rejected. Every question must have at least 1 option

[HARD] This tool cannot be used unless in Plan mode. allows_request_user_input() 이 Plan is true only for true 다(config_types.rs:699). In Default mode, unless the experimental flag (DefaultModeRequestUserInput) is enabled, the runtime rejects it with request_user_input is unavailable in Default mode (#24750).

Codex official Default mode guidance, verbatim: "In Default mode, strongly prefer making reasonable assumptions and executing the user's request rather than stopping to ask questions." 즉 Default mode is a mode that says not to conduct interviews in the first place.

So /project 's deep interview is handled like this:

If the tool is exposed, use it as-is — with the above schema, split into rounds to fill coverage.
If it is not exposed (Default mode), inform the user and let them choose. "In the current mode I cannot show choice cards. If you switch to Plan mode, I will ask with cards; otherwise I will ask in text." — Do not arbitrarily assume and proceed. Project setup is the place where that shallowness gets replicated into every subsequent artifact.
When asking in text, present numbered choices in the response body. What the Codex guidance prohibits is even though tools are available is to submit objective questions in text. Asking in writing because there is no tool is not subject to that prohibition.

[HARD] Round design conforms to the side with the smaller cap. To run the same interview in two runtimes, 1 question × 3 optionsis taken as the common unit. If 4 questions are filled only in Claude and truncated in Codex, the truncated questions are asked on one side and not asked on the other — the same project is built to different depths depending on the runtime.

[HARD] Do not read no response as a "refusal." Cowork desktop has an unresolved bug (anthropics/claude-code #58750, open) — question cards fail to reach the renderer and although the user never even saw the question on app exit behavior=denyit is force-processed as such and recorded as "Dismissed." 35 cases were reported over 8 days, and there is neither an official fix nor a workaround.

So it is handled as follows.

If the response is empty or returns deny/dismissed do not treat that as the user's decision
The same question is re-issued in the response body as numbered options — stating "the options may not have appeared on your screen, so I am asking again in writing"
Do not delegate the interview to a subagent. Since a child agent cannot ask questions, it returns only a blocker report (the 26 agents in this repository already observe this boundary)
If sensitivity (H lens) is lost through this path, unknownand unknownis handled as not performing external transmission in that direction

axes are derived from the project, not from a fixed list

[HARD] The 8 areas below are not a question list but a «lens for scanning whether anything is missing.» The actual questions are each time /project <프로젝트 설명>derived anew from this — for a course project, things like "students·cohorts·schedule," for commerce "product groups·channels·inventory," for legal "clients·jurisdiction·deadlines," in the project's own words . Reading out the lens names verbatim is not an interview but a recitation of a questionnaire.

Derivation order:

From the project description, folder name, and existing files, this project's nounsare extracted (what is being made and to whom it is given)
Apply the 8 lenses one by one to what that lens points to in this project decide
Lenses that do not apply are discarded. Do not force-fill them — asking a one-person blog for "review·approval authority" is a waste of time
Sort the remaining axes by information gain and place them in rounds

Lens	What it scans	Example per project
A. Identity	Purpose, task type, definition of success	Lectures: which course, how many sessions / Commerce: which product category
B. Deliverables	What to make, format, volume, frequency	Lectures: curriculum, slides, recruitment notice / Legal: contracts, review opinions
C. Audience	Who receives it, what they look at to judge, where it goes	Lectures: course applicants / Commerce: purchasing customers, MD
D. Style	Tone, honorifics, existing writing to reference, prohibited words	Lectures: polite-form notices / SNS: casual short sentences
E. Current state	How it is done now, time, bottlenecks	Where repetitive manual work arises
F. Quality	Failure conditions, reviewers, inspection criteria	Lectures: wrong dates or prices / Legal: missing clauses
G. Assets	Existing deliverables, templates, glossary, brand	Previous session materials / brand guide
H. Constraints	Sensitivity, regulations, external integrations	Whether contracts or personal information are included

[HARD] Only the sensitivity of the H lens must be asked in every project. This answer is korean-spell-checkbecause it determines whether there is external transmission (Section 6-3). The other lenses may be discarded depending on the project.

Each axis is recorded as satisfied / deferred / unconfirmedand saved in .moai/config.json의 coverage. If even one unconfirmed item remains, run more rounds.

Round composition rules (HARD)

Fill the 4 slots in order of greatest information gain. Place the required axes (right column of the table above) first, and fill the remaining slots with auxiliary axes from the same area
Do not ask about axes that are already established. Exclude what was obtained from the entry utterance or existing AGENTS.md·.moai/context.mdand fill the slots with the next priorities so that the 4 slots are always completely filled
Attach descriptionto every option(empty descriptions prohibited) — "what changes if you choose it". Only on the first option, the (권장) label
If the answer is ambiguous, leave that axis as unconfirmed and place it again in the next round. Do not repeat the same question verbatim; narrow it down and ask again
Announce progress every round — something like "5 of 8 areas confirmed. I will ask a couple more times." An interview with no visible end is the most exhausting

Exit and termination

[HARD] From the first round, include the "proceed with what we know now" option. The goal is to fill coverage, not to trap the user. If they exit, record the remaining axes as deferredand write the assumed values in .moai/context.mdwrite it in and then proceed — notify the user in one line what was assumed
[HARD] ㉒ Even if only the sensitivity axis deviates, an answer must always be obtained. This answer korean-spell-checkdetermines whether it is transmitted externally (§6-3). If there is ultimately no answer, unknownrecord it as unknown은 the side that does not transmitand handle it as such
Exit condition: when all required axes are satisfied or deferredand unconfirmed items are 0, proceed to design
Once a design proposal is produced, in one last roundshow the chain and agent configuration and receive approval/modification/cancellation

Re-entry

resume: .moai/context.md + read the existing AGENTS.md overview first and reuse the established axes. In the coverage table, skip cells that are already filled and only the empty cells ask about
Re-entry confirmation: if the target project already has AGENTS.md(or the old-method CLAUDE.md)·.moai/then before overwriting, confirm with AskUserQuestion(regenerate / partial modification / cancel). Silent overwriting is prohibited. CLAUDE.mdIf contains the full instructions rather than a pointer, it is a legacy clone project, so references/agentsmd-generator.md apply §7.1 migration first
When a deferred axis stalls: if an axis left deferred touches a high-risk deliverable (contract, legal, financial, external sending), stop generation and explicitly ask again. If low-risk, document the assumption and proceed

Context tier (determined per topic, not per session):

Tier	Definition	Handling
A	Project `AGENTS.md`required context immediately obtainable from (purpose, main deliverables, audience, tone constraints, installed plugins)	Use immediately without questions
B	Core context (domain information per deliverable) — 80% or more satisfaction recommended	Include in the S1 batch, and only the shortfall in S2
C	Supplementary context (background, motivation, constraints, schedule, etc.) — collect only for high-risk deliverables	Join the S2 slot (no separate text conversation)

No re-asking: do not ask again about answers already established as A/B tier. The question channel follows §Per-runtime question channel — Claude is AskUserQuestion, ChatGPT Work는 request_user_input.

resume interview: .moai/context.md + read the existing AGENTS.md project overview first and reuse already established context. For the detailed question-axis pool, slot filling, and ambiguity detection, see references/init-protocol.md §Phase 1 + references/context-collector.md .

Re-entry confirmation (S3): if the target project already has AGENTS.md(or the old-method CLAUDE.md)·.moai/exists, before overwriting existing deliverables, obtain explicit confirmation with AskUserQuestion(options: regenerate / partial modification / cancel). Silent overwriting is prohibited. CLAUDE.mdIf contains the full instructions rather than a pointer, it is a legacy clone project, so references/agentsmd-generator.md §7.1 Apply the migration first.

When a grace-period axis remains unresolved: If there is an axis that remains in grace even after running more rounds, block generation and either ask explicitly (high-risk output), or document the assumption in .moai/context.mdand proceed (low-risk output). Notify the user in one line which path was taken.

Plugin Inventory Scan

Before designing an agent/skill chain, before always ~/.claude/plugins/(Claude)와 ~/.codex/plugins/+.codex/agents/(Codex) to confirm the actually installed AI coworker plugins. The catalog (plugin list and skill count) is not hardcoded — .claude-plugin/marketplace.jsonis the sole source of truth for this family roster.

# 소스 A: 디렉터리 스캔 — Claude(~/.claude/plugins/) + Codex(~/.codex/plugins/cache/) 양쪽, moai-* 글롭
for dir in ~/.claude/plugins/moai-* ~/.codex/plugins/cache/*/moai-*; do
  [ -d "$dir" ] && { [ -f "$dir/.claude-plugin/plugin.json" ] || [ -f "$dir/.codex-plugin/plugin.json" ]; } && basename "$dir"
done
# Codex 프로젝트/전역 커스텀 에이전트(.codex/agents/*.toml)도 인벤토리에 포함
for f in ./.codex/agents/*.toml ~/.codex/agents/*.toml; do [ -f "$f" ] && basename "$f" .toml; done 2>/dev/null

# 소스 B: 현재 세션 system reminder의 "user-invocable skills" 목록 파싱(moai-* 접두 스킬만)

Cross-verify the two sources to plugins_installed + skills_available build the inventory (confidence HIGH/MEDIUM). The result is .moai/config.jsonand saved as a snapshot. Gap Detection: If a skill in the designed chain is not in the inventory, AskUserQuestion present 4 options (guide installation + recommend resuming / proceed while excluding it / substitute skill / stop). Resuming is detected when the user says "installation complete" or "continue", and proceeds in the same flow.

Custom Agent & Skill-Chain Design

What this skill generates is .claude/agents/*.md는 designed anew each time, exclusively for the user and project. Do not copy prebuilt plugin agents — synthesize the agent body that calls the skills discovered in the inventory as a chain, directly from the interview context.

Design procedure:

Synthesize 3 kinds of input: interview answers (what and how) + inventory (what is installed) + existing .moai/context.md accumulated context on re-entry.
[HARD] Design after exhaustively exploring all relevant skills. Read all skills/*/SKILL.md descriptions of installed plugins and put everything usable for this project's output on the candidate list without omission. Do not use only what is in memory or presets — presets (references/cowork-setup.md §3)은 are a starting point, not a list. If any skill was excluded from the candidates, write one line in the design rationale explaining why it was left out.
The per-output skill chain is tailored to the project purpose designed: [기획/분석] → [생성] → [포맷 변환/미디어] → ⟨한국어 감사 3단⟩. Do not copy the preset as-is; add or remove steps according to the failure conditions, reviewers, and cadence received in S1 and S2.
[HARD] A Korean text chain ends with moai-writer:korean-humanize. The order is ai-slop-reviewer → korean-spell-check(omit for sensitive documents) → korean-humanize(polishing + Phase 6 final review). Since the very outputfor which Phase 6 judged meaning preservation must be delivered, do not place any step that edits sentences after the review. If the judgment is hold_and_report, do not deliver. Non-text (charts, numbers, media) skip the audit step. Source of truth: references/cowork-setup.md §3.
One agent per recurring work typecreates them (no over-generation — do not create agents without justification). The body embeds the 7-step loop below + project context (tone, deliverable specifications, prohibitions).
For each agent/chain, AGENTS.md record it in the §workflow table, so that at execution time natural-language requests are routed along the table into agent/skill calls.

7-step agent loop (common body structure for all generated agents): ① request assessment (3 tiers: conversation/skill/file) → ② Socratic interview (missing context) → ③ context summary confirmation → ④ chain execution plan + completion criteria presented → ⑤ AskUserQuestion approval → ⑥ sequential chain execution (step-by-step summary reports) → ⑦ moai-coworker:ai-slop-reviewer inspection → (if Korean text) moai-writer:korean-humanize copyediting → final review → state "items requiring confirmation" and then deliver. If inspection was skipped, note that fact and the reason in the result.

frontmatter least privilege: name(kebab-case) · description(specify invocation triggers) · tools(only the minimal list needed for the task — Agent tools are not included, blocking nested spawning). Generated agents respect the subagent boundary: they do not ask the user directly, and if input is insufficient they return a blocker report.

Verification depth (proportional to risk): QUICK (simple lookup — Layer 1 only) / NORMAL (general deliverables — evidence gate active, default) / DEEP (legal, tax, financial, government support, contract, medical, or 2+ coworker chains — full verification + confirmation before delivery). For details see references/execution-protocol.md §verification depth ladder.

Generation Targets

After Phase 5 confirmation, this skill creates the following:

AGENTS.md(canonical) + CLAUDE.md(pointer) (project root) — the folder instructions' canonical source is AGENTS.md a single file(≤500 lines). CLAUDE.mdis a pointer (≈11 lines) that loads that canonical source with a single line @AGENTS.md . Do not duplicate the same body in both files — duplication silently diverges when only one side is edited. Codex (ChatGPT Work) reads AGENTS.mddirectly, and Claude (Cowork/Code) expands CLAUDE.md's import at session start to read the same canonical source, so the two are functionally equivalent (interoperable). Substitute the Desktop variant template (references/templates/AGENTS.md.tmpl) to create AGENTS.md, and copy references/templates/CLAUDE.md.tmplwithout substitution to create the pointer. Preserve all 8개 ## N. … (HARD) blocksof the source template (see the table under §Desktop Parity Constraints). When the line budget is exceeded, the only thing to reduce is the skill chain listing; HARD blocks must never be reduced or deleted. Wrapping the import line in backticks causes silent failure, so it is prohibited (details: references/agentsmd-generator.md §2.4).
.claude/agents/*.md + .codex/agents/*.toml — create one of each on both sides per recurring task type. For Claude, markdown+YAML frontmatter (name·description·tools), for Codex, TOML (name·description·developer_instructions, model·sandbox_mode optional). Both embed the 7-step loop + project context identically. Codex .codex/agents/can commit to the project-local git.
.moai/ scaffold — config.json(project meta + language + installed plugin snapshot) · context.md(interview summary) · credentials.env(GUIDANCE only — guidance text only; actual values are never recorded) · cache/(empty directory) · evolution/(self-improvement diagnostic record).

Recursive Self-Improvement

/project For a project whose setup is complete, it improves itself while in use. Only a single simplified model is used — the heavy multi-step model that requires forced scoring, reflection essays, and separate metrics files is not adopted (the signal and history records below are all one-line units).

4 improvement triggers (activates if any one is detected; the English tokens are machine anchors):

repeated correction — the user's correction request for the same action repeats 2 or more times
chain failure — the skill chain repeatedly fails or is bypassed at the same step
explicit request /project evolve (manual activation)
inventory drift — the installed plugin inventory diverges from the .moai/config.json snapshot

signal persistence (HARD): on detecting a user correction request or chain failure, immediately .moai/evolution/signals.mdrecord 1 line (날짜 | 트리거 토큰 | 대상(에이전트/체인/지침 앵커) | 요지). The "repetition" determination for triggers 1 and 2 is not based on conversation memory but is done by counting this file — even if the session changes, the first-time signal is not lost.

improvement cycle: signal detection → diagnosis (what went wrong: AGENTS.md guidance vs agent body vs skill chain) → write a minimal diff (full rewrite prohibited) → report the gist of changes to the user in 1-3 lines (prior confirmation only for destructive changes) → .moai/evolution/log.md record 1 line at the top (including trigger token + modification target). Before applying the diff, the original text fragment of the modification point .moai/evolution/ must also be left in the diagnostic record

improvement verification + rollback (HARD): an improvement does not end with application — if after application the signal for the same trigger token + same targetfires again, that improvement is judged as a failed improvement. A failed improvement is reverted by using the original text fragment left in .moai/evolution/to revert the relevant diff, and instead of automatically re-modifying the same point, the situation is reported to the user in 1-3 lines to confirm the direction (repeated automatic re-modification of the same point is prohibited).

improvement history curation: the canonical history is in .moai/evolution/log.md one place and accumulates in newest-first order. AGENTS.mdis not where history is written — because HTML comments are removed at generation time, any history written there does not remain. Even after applying a self-improvement diff, re-verify that AGENTS.mdis within 500 lines (references/agentsmd-generator.md §5 length verification applies not only at generation but also at improvement).

guardrail (HARD): self-improvement modifies only AGENTS.md와 .claude/agents/ files (.moai/evolution/signal, diagnosis, and handover record files are the exception). Do not touch the skill body or plugin files. The number of files modified per single improvement is at most 3(evolution record files are excluded from the count).

Plugin Update Synchronization (`update`)

/project update는 Immediately after a plugin is updated externally, this is a manual switch that synchronizes the project to the latest inventory. §Recursive Self-Improvement's inventory drift trigger is not "wait for detection" but forced execution via immediate, full censusmode. It inherits the self-improvement guardrails (modification targets, 3-file cap, prior confirmation of destructive changes) as-is.

evolve vs update (distinguished by trigger condition):

Mode	Trigger	Input
`/project evolve`	In-use signal (`repeated correction`·`chain failure`)가 `.moai/evolution/signals.md`에 accumulatedand triggered	Conversation context + accumulated signals
`/project update`	User manually invokes immediately after plugin update — does not wait for drift	Full census of all installed plugins + accumulated signals

update Execution procedure (5 steps) — The detailed canonical source is references/update-protocol.md:

Full Census — ~/.claude/plugins/moai-* Scan everything to inspect each plugin's plugin.json + skills/ + MCP definitions. Compare with the existing .moai/config.json snapshot to new skills, new MCPs, changed skillsderive the diff of.
Session signal analysis — .moai/evolution/signals.md(accumulated corrections and chain failure signals) + .moai/context.mdRead (project context) and cross-check whether the updated skill can resolve existing signals (this is the substance of "existing conversation session analysis + recursive self-learning").
AGENTS.md and agent synchronization — In line with the diff, AGENTS.md §workflow table and .claude/agents/*.md's skill chain with minimal diff. The 500-line budget and 8 HARD block preservation policy follow references/agentsmd-generator.mdas-is. When encountering a legacy clone project (containing all instructions, CLAUDE.md), apply the same document's §7.1 migration first.
Snapshot update — .moai/config.json의 plugins_installed + skills_available Update the snapshot to the new inventory(inventory driftreset to 0). .moai/evolution/log.mdLog 1 line in (trigger token inventory drift + synchronization summary).
Verification + rollback — If the same inventory drift signal triggers again, it is judged a failed synchronization and .moai/evolution/ rolled back to the original text fragment (reusing §Recursive Self-Improvement's verification and rollback mechanism).

Uninstalled project (HARD): AGENTS.md·CLAUDE.md·.moai/If all are absent, updatehas no synchronization target — AskUserQuestionwith /project(initial setup) guidance. Do not create silently.

Desktop Parity Constraints

The project this skill generates assumes the Claude Cowork(Desktop) runtime, but produces artifacts (AGENTS.md+CLAUDE.md pointer, .claude/agents/+.codex/agents/) for both Claude and Codex (ChatGPT Work), so it operates in either runtime. AGENTS.mdis loaded directly by Codex, while Claude loads the same canonical source via CLAUDE.md의 @AGENTS.md import, and the functionality is equivalent. Symbolic links (ln -s) require administrator privileges on Windows, so they conflict with the four-combination identical-behavior principle and are not used — only the import method is used (details: references/agentsmd-generator.md §2.4). The following three classes do not work in the Desktop/Codex runtime, so they are not created in any generation path:

hooks — do not generate hook wiring.
LSP — do not generate LSP settings.
output-styles — do not generate output-style files.

This skill mentions the three classes only by class name (it does not use specific artifact path tokens). If an artifact premised on the development runtime is needed, follow §Handling Development Requests.

Desktop AGENTS.md.tmplThis preserves the 8 ## N. … (HARD) blocks (source order):

#	section
1	`## 2. 행동 원칙 (HARD)`
2	`## 3. 요청 평가 사다리 (HARD)`
3	`## 4. 파일 생성 기준 (HARD)`
4	`## 5. 문서·콘텐츠 생성 우선순위 (HARD)`
5	`## 6. AI 슬롭 후처리 (HARD)`
6	`## 7. 인용·저작권 가드 (HARD)`
7	`## 8. 톤 규칙 (HARD)`
8	`## 14. 맥락 적용 규칙 (HARD)`

The count is exactly 8 (grep -cE '^## .*\(HARD\)' references/templates/AGENTS.md.tmpl == 8). For the line budget overage policy, see references/agentsmd-generator.md reference.

plugin family

marketplace 'MoAI-Cowork, Everyone's Cowork' (modu-ai/moai-cowork). Do not hardcode the roster (plugin list, Korean names, roles) — the measured canonical source is .claude-plugin/marketplace.json, and this skill reads it dynamically at runtime in §Plugin Inventory Scan. For the role-based routing mapping (keyword → coworker plugin), references/router.mdis the single source of truth.

routing

natural language intent branching

utterance context	branch
development·coding·SPEC·DDD/TDD·development environment	§Handling Development Requests
everything else (business·content·creation·commerce·documents·legal·finance·recruiting·education·design)	handled directly by this skill
unclear	`AskUserQuestion` (continuing is recommended / see §Handling Development Requests)

coworker (plugin) keyword mapping (summary)

If there is 1 candidate from keyword matching, design the chain centered on that coworker. For the detailed keyword table, ambiguity resolution, and compound request handling, see references/router.md reference. If there are 2 or more candidates: (a) if the artifact type is specified, prioritize the coworker that produces that artifact (automatic resolution), (b) if automatic resolution is difficult, AskUserQuestion(up to 4 candidates + Other). If designer-centered, references/designer-setup.md call the sub-protocol.

workflow (8-Phase)

Phase 1 인터뷰 → Phase 2 인벤토리 → Phase 3 체인 설계 → Phase 4 Gap Detection
  → Phase 5 확인 → Phase 6 지침 생성(AGENTS.md + CLAUDE.md 포인터) → Phase 7 커스텀 에이전트 생성 → Phase 8 API 키 + 첫 실행 안내

Details: references/cowork-setup.md(coworker·writer 8-Phase canonical source) + references/designer-setup.md(design asset 5-Phase sub-protocol, called on design requests).

command surface

/projectis a natural language single-entry skill. The default behavior is <자연어 지시>Interview→Design→Generation in a single flow, and only the three actions below are exposed as explicit subcommands. Everything else (resume, catalog, status check, API key) is routed automatically by the skill when requested in natural language — "I've finished installing" (resume), "What coworkers are there?" (catalog), "What's the status now?" (status), "I want to set the API key" (Phase 8 guidance).

Command	Action
`/project <지시>`	Entry — Agent/chain design + generation after the interview. PRIMARY default behavior.
`/project update`	After plugin update, full audit → AGENTS.md·agent resynchronization (§Plugin Update Synchronization)
`/project evolve`	Manually trigger recursive self-improvement
`/project doctor`	Environment diagnostics

Storage location

Project work guidelines (canonical): ./AGENTS.md (≤500 lines — loaded directly by Codex)
Pointer for Claude: ./CLAUDE.md (@AGENTS.md One-line import + guidance comment. Does not duplicate the guidelines body)
Custom agent: ./.claude/agents/*.md (Claude) + ./.codex/agents/*.toml (Codex)
Project configuration: ./.moai/config.json
Project context: ./.moai/context.md
API 키: ./.moai/credentials.env (project isolation, GUIDANCE only)
Template: references/templates/AGENTS.md.tmpl(canonical, variable substitution) + references/templates/CLAUDE.md.tmpl(pointer, copied as-is)

Detailed reference (`references/`)

File	Role
`router.md`	Natural language → coworker (plugin) keyword mapping, ambiguity resolution, composite requests, verification depth integration
`cowork-setup.md`	Coworker·author 8-Phase canonical (automatic role detection, chain presets, custom agent creation, citation guard)
`designer-setup.md`	Design asset 5-Phase sub-protocol
`init-protocol.md`	Interview question schema, inventory scan, Gap Detection, resume (Re-entry) details
`context-collector.md`	Context grading (A/B/C), coverage-based round survey flow, ambiguity detection, context application rules
`agentsmd-generator.md`	AGENTS.md variable substitution, 500-line budget, HARD block preservation, CLAUDE.md pointer rules, legacy migration
`execution-protocol.md`	Skill chain sequential execution, verification depth ladder, search scaling
`evaluation-protocol.md`	5-dimension deliverable evaluation (accuracy, completeness, practicality, tone, domain)
`quality-evaluator.md`	Deterministic quality gates (file validity, markdown rendering, AI writing patterns, evidence verification)
`diagnostic-protocol.md`	Environment diagnostics (`/project doctor`) · Status check (natural language)
`update-protocol.md`	Plugin update synchronization (`/project update` — full audit, session signal analysis, synchronization, verification)
`INDEX.md`	Full reference index

Handling development requests

Scope (HARD): This marketplace is dedicated to non-development AI coworker plugins. Development-project initialization (SPEC, DDD/TDD, quality gates, dev environment setup) is outside the scope of this skill, and no development setup deliverables are produced.

If the user shows intent for development, coding, SPEC, or DDD/TDD, do not start any generation procedure; inform them that this is out of scope, then guide them to the non-development project initialization handled by this skill.

Precautions

Do not ask global profile questions — Do not re-ask for name, company, or role. All user information is recorded in only one place, AGENTS.md .
The project skill does not implement — It handles only routing, setup, and self-improvement wiring. The actual work chain and design synthesis logic are delegated to the skills of each coworker plugin.
Single marketplace consistency — Skill references use the installed plugin's moai-*: prefix, and the roster is derived at runtime from marketplace.json(hardcoding prohibited). router.md's mapping is the single source of truth.