@hunyed15/codecgc 0.1.0

package/codecgc/cgc/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: cgc
+description: Root entry for CodeCGC. Use when the user wants to understand the CodeCGC workflow, does not know which cgc-* command to use, or gives an open-ended request that needs routing to installation, planning, feature delivery, issue fixing, or review.
+---
+
+# cgc
+
+`cgc` is the product entry for CodeCGC.
+It routes the request and does not execute workflow work itself.
+
+## Read First
+
+Before answering:
+
+1. check whether the project already has `codecgc/`
+2. read `codecgc/reference/shared-conventions.md`
+3. read `codecgc/reference/workflow-scaffold.md`
+4. scan `codecgc/features/`, `codecgc/issues/`, `codecgc/roadmap/`, `codecgc/requirements/`, and `codecgc/architecture/`
+5. read `codecgc/reference/operation-guide.md`
+
+## Route Table
+
+- installing or repairing CodeCGC in a repo: `cgc-install` and `cgc-onboard`
+- shaping or clarifying a request: `cgc-plan`
+- starting or continuing feature delivery: `cgc-build`
+- starting or continuing issue fixing: `cgc-fix`
+- acceptance, audit, write-back, final review: `cgc-review`
+- updating durable architecture docs: `cgc-arch`
+- updating stable requirement docs: `cgc-req`
+- expanding roadmap-scale planning: `cgc-roadmap`
+- recording durable decisions: `cgc-decide`
+- recording reusable lessons or pitfalls: `cgc-learn`
+- behavior-preserving structural improvement: `cgc-refactor`
+
+## Output Rule
+
+Return only:
+
+- the recommended next `cgc-*` command
+- one short reason
+- one short note on what happens next
+
+Do not write specs, code, or acceptance content here.
+
+When a concrete feature or issue artifact already exists, prefer routing based
+on the current artifact state instead of free-form judgment.

package/codecgc/cgc-arch/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: cgc-arch
+description: Maintain long-lived current-state architecture assets for CodeCGC or an installed project. Use when accepted work changed system structure, runtime topology, integration boundaries, or durable technical constraints and those changes must be written back into codecgc/architecture/.
+---
+
+# cgc-arch
+
+This skill maintains `codecgc/architecture/` as the current-state system map.
+
+## Goal
+
+Produce one of these outcomes:
+
+- update an existing architecture document
+- create one missing architecture document
+- confirm that no architecture write-back is needed
+
+## Read First
+
+Read:
+
+- `codecgc/architecture/README.md`
+- `codecgc/reference/shared-conventions.md`
+- `codecgc/reference/workflow-scaffold.md`
+
+Then inspect:
+
+- accepted feature or issue artifacts related to the change
+- relevant files under `scripts/`, `bin/`, `.claude/`, `codexmcp/`, `geminimcp/`
+- existing docs under `codecgc/architecture/`
+
+## What Belongs Here
+
+Write here only when the repository or installed project now has a durable new state:
+
+- module boundaries
+- runtime topology
+- integration maps
+- technical constraints already adopted
+
+Do not write:
+
+- speculative redesign
+- one-off implementation notes
+- executor audit output
+- temporary task checklist detail
+
+## Core Rule
+
+Architecture docs record accepted reality, not future intent.
+
+If the change is still under discussion, keep it out of `codecgc/architecture/`.
+
+## Output Rule
+
+When updating architecture, return:
+
+- which architecture doc was updated or created
+- one short summary of the durable system change
+- whether requirements or roadmap should also be updated
+

package/codecgc/cgc-build/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: cgc-build
+description: Entry for feature delivery in CodeCGC. Use when the user wants to add or continue a feature and the work must move from planning into design, executable step packaging, delegated implementation, and review under forced multi-model routing.
+---
+
+# cgc-build
+
+This skill owns feature delivery for CodeCGC.
+
+## Goal
+
+Move a feature through:
+
+1. design readiness
+2. step isolation
+3. forced delegated execution
+4. review handoff
+
+## Read First
+
+Read:
+
+- `codecgc/reference/shared-conventions.md`
+- `codecgc/reference/execution-model.md`
+- `codecgc/reference/checklist-contract.md`
+- `codecgc/reference/build-flow.md`
+- `codecgc/reference/execution-audit.md`
+- `codecgc/reference/flow-execution.md`
+- `codecgc/reference/operation-guide.md`
+
+Inspect the relevant feature directory under `codecgc/features/`.
+
+## Hard Rules
+
+- code-writing steps must not be executed directly by Claude
+- every executable code step must have a valid `codecgc` block
+- mixed frontend/backend/shared scope must be split before execution
+- the workflow wrapper must call `scripts/run_codecgc_flow_step.py`
+
+## Current Product Boundary
+
+This skill must use design and checklist artifacts under `codecgc/features/`
+and interpret them through CodeCGC rules.
+
+## Exit Rule
+
+The output of this skill is one of:
+
+- a delegated execution result ready for `cgc-review`
+- a request to return to planning or design
+- a refusal because the step is not executable yet
+
+When execution succeeds, keep the audit path with the result package.

package/codecgc/cgc-decide/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: cgc-decide
+description: Record durable technical or product decisions after they have been accepted. Use when a choice about architecture, workflow policy, command surface, model routing, or long-lived convention must be written back into codecgc/compound/ or a related durable asset.
+---
+
+# cgc-decide
+
+This skill records durable accepted decisions for future humans and models.
+
+## Goal
+
+Produce one of these outcomes:
+
+- append or create a durable decision artifact
+- update an existing durable decision section
+- confirm that the choice is not final yet and should not be archived
+
+## Read First
+
+Read:
+
+- `codecgc/compound/README.md`
+- `codecgc/reference/shared-conventions.md`
+- accepted design, review, or architecture artifacts that contain the final choice
+
+## What Counts As A Decision
+
+Good candidates:
+
+- command-surface policy
+- routing or ownership convention
+- architecture constraint
+- product-level workflow choice
+- long-lived migration rule
+
+Bad candidates:
+
+- tentative brainstorming
+- unreviewed implementation preference
+- one-step local workaround
+
+## Core Rule
+
+Only archive decisions that are already accepted.
+
+If the team is still debating, do not write a durable decision note.
+
+## Output Rule
+
+When recording a decision, return:
+
+- where it was recorded
+- the decision itself in one line
+- what future behavior it constrains
+

package/codecgc/cgc-fix/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: cgc-fix
+description: Entry for issue fixing in CodeCGC. Use when the user wants to diagnose, continue, or apply a scoped bug fix and the code change must be delegated through the forced frontend or backend executor instead of direct Claude editing.
+---
+
+# cgc-fix
+
+This skill owns issue repair for CodeCGC.
+
+## Goal
+
+Move a bug fix through:
+
+1. scope confirmation
+2. one-executor packaging
+3. forced delegated execution
+4. fix-note and review handoff
+
+## Read First
+
+Read:
+
+- `codecgc/reference/shared-conventions.md`
+- `codecgc/reference/execution-model.md`
+- `codecgc/reference/checklist-contract.md`
+- `codecgc/reference/fix-flow.md`
+- `codecgc/reference/execution-audit.md`
+- `codecgc/reference/flow-execution.md`
+- `codecgc/reference/operation-guide.md`
+
+Inspect the relevant issue directory under `codecgc/issues/`.
+
+## Hard Rules
+
+- do not directly edit routed business code with Claude
+- do not expand a fix into mixed-scope implementation
+- if the fix touches shared or mixed scope, split it first
+- execute code changes through `scripts/run_codecgc_flow_step.py`
+
+## Exit Rule
+
+This skill ends with:
+
+- a delegated fix result ready for `cgc-review`
+- or a return to planning because the fix scope is still mixed or underspecified
+
+When execution succeeds, keep the audit path with the fix result.

package/codecgc/cgc-learn/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: cgc-learn
+description: Capture reusable lessons, pitfalls, and repeatable practices discovered during delivery. Use when an accepted feature, issue, review, or failure mode exposed a durable learning that should be remembered across future work.
+---
+
+# cgc-learn
+
+This skill captures durable lessons for future delivery loops.
+
+## Goal
+
+Produce one of these outcomes:
+
+- add a reusable learning artifact
+- append a pitfall or practice to an existing artifact
+- confirm that the observation is too local or temporary to record
+
+## Read First
+
+Read:
+
+- `codecgc/compound/README.md`
+- the accepted workflow artifacts or failed execution evidence that produced the lesson
+
+## Good Learning Candidates
+
+- repeated failure mode
+- routing mistake worth preventing
+- review pitfall
+- install or runtime trap
+- practice that should become a default habit
+
+## Core Rule
+
+Learnings should be reusable.
+
+Do not record raw narrative of one task unless it changes how future work should be done.
+
+## Output Rule
+
+When recording a learning, return:
+
+- where it was recorded
+- whether it is a pitfall or a preferred practice
+- one short instruction for future work
+

package/codecgc/cgc-onboard/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: cgc-onboard
+description: Initialize or rebuild the CodeCGC workflow layer in a project. Use when a repository needs the new CodeCGC structure, references, and product-level workflow rules instead of older command surfaces.
+---
+
+# cgc-onboard
+
+This skill initializes or repairs the CodeCGC project integration layer.
+
+## Goal
+
+Create a project that has:
+
+- `codecgc/` workflow references
+- the active `cgc-*` command surface
+- routing-aware execution rules
+- active artifact storage under `codecgc/`
+
+## Read First
+
+Read:
+
+- `codecgc/reference/shared-conventions.md`
+- `codecgc/reference/execution-model.md`
+- `codecgc/reference/workflow-scaffold.md`
+
+Also inspect:
+
+- `.mcp.json`
+- `.claude/settings.json`
+- `.claude/hooks/route-edit.ps1`
+- `model-routing.yaml`
+
+## Rules
+
+- Do not preserve old `cs-*` command compatibility
+- Do not keep active artifact writes under legacy directories
+- Do not keep legacy branding in the active workflow layer
+
+## Expected Result
+
+After onboarding, the repo should be ready to use:
+
+- `cgc`
+- `cgc-install`
+- `cgc-status`
+- `cgc-doctor`
+- `cgc-plan`
+- `cgc-build`
+- `cgc-fix`
+- `cgc-review`
+- `cgc-route`

package/codecgc/cgc-plan/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: cgc-plan
+description: Clarify, shape, and split work before execution in CodeCGC. Use when a request is still fuzzy, too large, mixed across frontend and backend, or not yet ready to become a one-executor coding step.
+---
+
+# cgc-plan
+
+This skill replaces the old split between vague brainstorming and feature entry.
+
+## Goal
+
+Produce one of these outcomes:
+
+- ready for `cgc-build`
+- ready for `cgc-fix`
+- needs roadmap-level decomposition
+- needs more user clarification
+
+## Read First
+
+Read:
+
+- `codecgc/reference/shared-conventions.md`
+- `codecgc/reference/execution-model.md`
+- `codecgc/reference/checklist-contract.md`
+- `codecgc/reference/workflow-scaffold.md`
+- `codecgc/reference/operation-guide.md`
+
+Inspect relevant existing artifacts if they exist.
+
+## Core Rule
+
+Do not let mixed execution scope leak into implementation.
+
+If a request mixes frontend, backend, or shared change, split it before it can
+be executed by CodeCGC.
+
+## Exit Rule
+
+A request may leave this skill only when it is clear:
+
+- what problem is being solved
+- whether it is build or fix work
+- whether it is feature-sized or roadmap-sized
+- whether the next executable step has one-model ownership
+
+When the artifact directory does not exist yet, create the minimal scaffold
+before handing work to `cgc-build` or `cgc-fix`.

package/codecgc/cgc-refactor/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: cgc-refactor
+description: Run a controlled behavior-preserving refactor flow under CodeCGC rules. Use when the request is about structure, readability, maintainability, or performance without changing product behavior, and the work still needs planning, routing, execution, and review discipline.
+---
+
+# cgc-refactor
+
+This skill owns controlled refactor work for CodeCGC.
+
+## Goal
+
+Move a refactor through:
+
+1. scope confirmation
+2. behavior-preserving plan
+3. routed execution
+4. review and write-back
+
+## Read First
+
+Read:
+
+- `codecgc/reference/shared-conventions.md`
+- `codecgc/reference/execution-model.md`
+- `codecgc/reference/operation-guide.md`
+
+Then inspect:
+
+- relevant source files
+- current feature or issue artifacts if the refactor is adjacent to accepted work
+
+## Hard Rules
+
+- refactor must not hide a new feature
+- refactor must not hide a bug fix requirement
+- mixed frontend/backend scope must be split before execution
+- code-writing still follows the same routed ownership model
+
+## Exit Rule
+
+This skill ends with one of:
+
+- a routed refactor step ready for execution
+- a return to `cgc-plan` because the request is actually feature or issue work
+- a refusal because behavior-preserving scope is not credible yet
+

package/codecgc/cgc-req/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: cgc-req
+description: Write back stable current-state product requirements into codecgc/requirements/. Use when accepted feature or issue work changed the durable product surface, command contract, business rule, or scope boundary and that reality should be recorded as a long-lived requirement artifact.
+---
+
+# cgc-req
+
+This skill maintains `codecgc/requirements/` as the current-state requirement layer.
+
+## Goal
+
+Produce one of these outcomes:
+
+- update an existing requirement doc
+- create one missing requirement doc
+- confirm that no requirement write-back is needed
+
+## Read First
+
+Read:
+
+- `codecgc/requirements/README.md`
+- `codecgc/reference/shared-conventions.md`
+- `codecgc/reference/workflow-scaffold.md`
+
+Then inspect:
+
+- accepted feature or issue artifacts
+- user-facing command or capability changes
+- existing requirement docs under `codecgc/requirements/`
+
+## What Belongs Here
+
+Write here only when the capability is now part of stable current behavior:
+
+- current user-visible capabilities
+- business rules already in force
+- stable scope boundaries for established modules
+- accepted command-surface behavior
+
+Do not write:
+
+- brainstorming
+- temporary bug analysis
+- one-off implementation notes
+- future roadmap intent
+
+## Core Rule
+
+Requirements docs explain what the product now does and where its stable boundaries are.
+
+They do not explain how one temporary feature step was implemented.
+
+## Output Rule
+
+When updating requirements, return:
+
+- which requirement doc was updated or created
+- the stable capability or rule that changed
+- whether architecture should also be updated
+

package/codecgc/cgc-review/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: cgc-review
+description: Final review, acceptance, audit, and write-back for CodeCGC. Use when delegated execution has completed and Claude needs to verify results, summarize risk, update workflow artifacts, and decide whether the work is truly complete.
+---
+
+# cgc-review
+
+This skill owns the final control point of CodeCGC.
+
+## Goal
+
+Verify that delegated execution is complete and safe to close.
+
+## Read First
+
+Read:
+
+- `codecgc/reference/shared-conventions.md`
+- `codecgc/reference/execution-model.md`
+- `codecgc/reference/execution-audit.md`
+- `codecgc/reference/review-writeback.md`
+- `codecgc/reference/operation-guide.md`
+
+Then inspect:
+
+- delegated execution result
+- execution audit artifact
+- changed paths
+- relevant feature or issue artifact directory
+
+## Responsibilities
+
+- compare result against step acceptance criteria
+- verify executor ownership was respected
+- identify remaining risk
+- prepare summary for artifact write-back
+- write the review result back into acceptance or fix-note artifacts
+
+## Hard Rule
+
+Acceptance is not only "code exists".
+
+It must also confirm:
+
+- the correct executor handled the step
+- the path scope was respected
+- the step actually satisfied its local acceptance target
+- follow-up work is clearly separated
+
+## Output
+
+Return a concise review result with:
+
+- accepted or not accepted
+- scope and ownership check
+- remaining risks
+- required next step if not done

package/codecgc/cgc-roadmap/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: cgc-roadmap
+description: Create or expand roadmap-scale planning when a request is too large for one feature or issue flow. Use when work must be decomposed into phases, child tracks, or multiple follow-up workflows under codecgc/roadmap/.
+---
+
+# cgc-roadmap
+
+This skill owns roadmap-scale decomposition for CodeCGC.
+
+## Goal
+
+Produce one of these outcomes:
+
+- initialize a new roadmap pack
+- expand an existing roadmap with clearer phases or child tracks
+- confirm that the request is feature-sized and should return to `cgc-plan`
+
+## Read First
+
+Read:
+
+- `codecgc/roadmap/README.md`
+- `codecgc/reference/shared-conventions.md`
+- `codecgc/reference/workflow-scaffold.md`
+- `codecgc/reference/operation-guide.md`
+
+Then inspect:
+
+- current request
+- related feature or issue artifacts
+- existing roadmap docs under `codecgc/roadmap/`
+
+## Core Rule
+
+Roadmap is for work that is too large, too mixed, or too long-lived for one executable workflow.
+
+Do not create roadmap just because the task feels important.
+
+## Required Outcomes
+
+A valid roadmap result should make these points clear:
+
+- what the parent problem is
+- why one feature or issue flow is not enough
+- what phases or tracks exist
+- what child workflows should be created next
+
+## Output Rule
+
+When roadmap is the right answer, return:
+
+- roadmap slug or path
+- parent problem summary
+- next child workflow or next planning step
+

package/codecgc/cgc-test/SKILL.md

@@ -0,0 +1,21 @@
+# CodeCGC `cgc-test`
+
+`cgc-test` 用于执行已经进入主工作流的测试步骤。
+
+它不是独立于 `feature / issue` 之外的新体系，而是：
+
+- 读取当前 workflow 中的测试 step
+- 按前端测试 / 后端测试继续走 Gemini / Codex
+- 复用现有 `execution audit -> review` 闭环
+
+默认入口：
+
+```bash
+cgc-test --flow <feature|issue> --slug <slug>
+```
+
+如果已经知道准确 step，也可以：
+
+```bash
+cgc-test --flow <feature|issue> --slug <slug> --step-number <n>
+```

package/codecgc/reference/api-cgc-review-libdoc.md

@@ -0,0 +1,13 @@
+# 补一份 API 文档，说明 cgc-review 的输出结构
+
+- 表面类型: public-api
+- 摘要: 补一份 API 文档，说明 cgc-review 的输出结构
+- 来源: cgc-entry 治理分诊
+
+## 1. 入口
+
+待补充。
+
+## 2. 公开契约
+
+待补充。