cc-devflow 4.2.0 → 4.4.1

package/docs/examples/pdca-loop/changes/REQ-001-copy-invite-link/planning/tasks.md

@@ -0,0 +1,73 @@
+# TASKS
+
+## Plan Meta
+
+- Requirement version: `REQ-001.v1`
+- Design version: `design.v1`
+- CC-Plan skill version: `3.5.3`
+- Source roadmap item: `RM-001`
+- Source roadmap version: `roadmap.v1`
+
+## Execution Handoff
+
+- Canonical design: `design.md`
+- Execution mode: `single-path`
+- Frozen decisions:
+  - copy from the existing invite URL source
+  - keep the patch inside the current dialog
+  - leave richer feedback for a future requirement if needed
+- Read first:
+  - `design.md`
+  - `src/features/share/ShareDialog.tsx`
+  - `src/features/share/ShareDialog.test.tsx`
+- Commands to trust:
+  - `npm test -- src/features/share/ShareDialog.test.tsx`
+  - `npm run lint -- src/features/share/ShareDialog.tsx`
+- Do not re-decide:
+  - dialog structure
+  - invite URL source
+  - share-service contracts
+- Parallel boundaries: none; this patch is intentionally serial
+
+> 顶部 handoff 只保留执行者必须知道的现实，不重复讲背景故事。
+
+## Phase 1: Foundation
+
+- [x] T001 [TEST] Add a failing dialog test for the missing copy action (dependsOn:none) `src/features/share/ShareDialog.test.tsx`
+  Goal: 证明当前 share dialog 还不能一键复制 invite link。
+  Files: `src/features/share/ShareDialog.test.tsx`
+  Read first: `design.md`, `src/features/share/ShareDialog.tsx`
+  Verification: `npm test -- src/features/share/ShareDialog.test.tsx`
+  Evidence: failing output that shows the missing button / action
+  Ready when: 没有上游依赖，且现有 dialog test 已可运行
+
+- [x] T002 [IMPL] Add the copy button and copied-state confirmation (dependsOn:T001) `src/features/share/ShareDialog.tsx`
+  Goal: 用最小实现让 T001 转绿，并保持当前 share contract 不变。
+  Files: `src/features/share/ShareDialog.tsx`
+  Read first: `design.md`, `src/features/share/ShareDialog.test.tsx`
+  Verification: `npm test -- src/features/share/ShareDialog.test.tsx`
+  Evidence: passing output + checkpoint + review notes
+  Ready when: T001 已经见红，且当前 touched files 没有外部依赖阻塞
+
+## Phase 2: Verify
+
+- [x] T003 Run targeted checks and collect fresh evidence (dependsOn:T002) `share dialog quality gates`
+  Goal: 为 `cc-check` 准备本次实现的真实验证证据。
+  Files: `src/features/share/ShareDialog.tsx`, `src/features/share/ShareDialog.test.tsx`
+  Read first: `tasks.md`, `task-manifest.json`
+  Verification:
+  - `npm test -- src/features/share/ShareDialog.test.tsx`
+  - `npm run lint -- src/features/share/ShareDialog.tsx`
+  Evidence: passing test output + clean lint output
+  Ready when: T002 已完成，且 review gate 已可补齐
+
+> `[P]` 只表示“依赖满足后有资格并行”，不表示可以无脑同时开发。
+
+## Task Quality Bar
+
+一个好的 task block 至少让执行者立刻知道：
+
+- 现在为什么轮到它做
+- 做完后现实会发生什么变化
+- 用哪条命令证明它完成
+- 要留下什么证据给 `cc-check`

package/docs/examples/pdca-loop/changes/REQ-001-copy-invite-link/review/report-card.json

@@ -0,0 +1,44 @@
+{
+  "changeId": "REQ-001",
+  "verdict": "pass",
+  "overall": "pass",
+  "summary": "verdict=pass quick=2/2 strict=0/0 review=pass",
+  "quickGates": [
+    {
+      "name": "targeted-tests",
+      "status": "pass",
+      "command": "npm test -- src/features/share/ShareDialog.test.tsx",
+      "summary": "share dialog targeted tests passed"
+    },
+    {
+      "name": "lint",
+      "status": "pass",
+      "command": "npm run lint -- src/features/share/ShareDialog.tsx",
+      "summary": "lint passed for the touched dialog file"
+    }
+  ],
+  "strictGates": [],
+  "review": {
+    "status": "pass",
+    "summary": "Task review proof and requirement-level diff review both passed",
+    "details": "T001-T003 have matching spec/code review proof and the diff stays inside the approved tiny-design boundary.",
+    "taskReviews": {
+      "status": "pass",
+      "required": true,
+      "summary": "All completed tasks carry spec/code proof",
+      "reviewers": [],
+      "findings": []
+    },
+    "diffReview": {
+      "status": "pass",
+      "required": false,
+      "summary": "No blocking requirement-level findings",
+      "reviewers": [],
+      "findings": []
+    },
+    "findings": []
+  },
+  "blockingFindings": [],
+  "reroute": "none",
+  "timestamp": "2026-04-15T11:20:00.000Z"
+}

package/docs/examples/pdca-loop/roadmap-tracking.json

@@ -0,0 +1,114 @@
+{
+  "version": 2,
+  "lastSyncedAt": "2026-04-19",
+  "backlogMeta": {
+    "roadmapVersion": "roadmap.v1",
+    "skillVersion": "4.3.1",
+    "currentFocusStage": "Stage 1"
+  },
+  "dependencyHandoff": {
+    "serialSpine": "RM-001 -> RM-002",
+    "parallelReadyNextWave": "none until RM-001 proves the copy action shape",
+    "notesOnBlockers": "RM-002 should reuse the final interaction contract from RM-001, not race it"
+  },
+  "items": [
+    {
+      "rmId": "RM-001",
+      "item": "Add one-click copy action to the share dialog",
+      "stage": "Stage 1",
+      "priority": "P1",
+      "primaryCapability": "cap-invite-links",
+      "secondaryCapabilities": [],
+      "expectedSpecDelta": "tighten invite-link copy truth",
+      "dependsOn": [],
+      "status": "In review",
+      "req": "REQ-001",
+      "progress": "100%",
+      "backlog": {
+        "capabilityGap": "share dialog exposes invite URL but not direct copy action",
+        "evidence": "repeated support friction",
+        "parallelWith": [],
+        "unknowns": "copied-state feedback shape",
+        "nextDecision": "freeze tiny design and execute",
+        "ready": true,
+        "whyNow": "it removes the first visible collaboration friction in the beta flow",
+        "successSignal": "users can copy the invite link with one click",
+        "entryConstraints": "no backend changes, no share dialog redesign",
+        "openRisks": "clipboard failure copy may still need follow-up UX",
+        "firstPlanningQuestion": "can this stay a tiny-design patch without changing contracts?",
+        "requiredContextToLoad": "current share dialog, current invite URL source, existing tests",
+        "whyReadyNow": "the ask is narrow, the evidence is real, and the dependency surface is already known",
+        "parked": false,
+        "parkedReason": "",
+        "triggerToReopen": "",
+        "missingEvidence": ""
+      }
+    },
+    {
+      "rmId": "RM-002",
+      "item": "Add copied-state feedback to the share dialog",
+      "stage": "Stage 1",
+      "priority": "P2",
+      "primaryCapability": "cap-invite-links",
+      "secondaryCapabilities": [],
+      "expectedSpecDelta": "extend invite-link feedback truth",
+      "dependsOn": [
+        "RM-001"
+      ],
+      "status": "Planned",
+      "req": "",
+      "progress": "0%",
+      "backlog": {
+        "capabilityGap": "invite links lack durable copied-state feedback after action completion",
+        "evidence": "likely useful after RM-001",
+        "parallelWith": [],
+        "unknowns": "toast vs inline state",
+        "nextDecision": "decide after first patch ships",
+        "ready": false,
+        "whyNow": "",
+        "successSignal": "",
+        "entryConstraints": "",
+        "openRisks": "",
+        "firstPlanningQuestion": "",
+        "requiredContextToLoad": "",
+        "whyReadyNow": "",
+        "parked": false,
+        "parkedReason": "",
+        "triggerToReopen": "",
+        "missingEvidence": ""
+      }
+    },
+    {
+      "rmId": "RM-004",
+      "item": "Collaboration analytics follow-up",
+      "stage": "",
+      "priority": "",
+      "primaryCapability": "",
+      "secondaryCapabilities": [],
+      "expectedSpecDelta": "",
+      "dependsOn": [],
+      "status": "",
+      "req": "",
+      "progress": "",
+      "backlog": {
+        "capabilityGap": "",
+        "evidence": "",
+        "parallelWith": [],
+        "unknowns": "",
+        "nextDecision": "",
+        "ready": false,
+        "whyNow": "",
+        "successSignal": "",
+        "entryConstraints": "",
+        "openRisks": "",
+        "firstPlanningQuestion": "",
+        "requiredContextToLoad": "",
+        "whyReadyNow": "",
+        "parked": true,
+        "parkedReason": "collaboration analytics is premature before Stage 1 and 2 prove usage",
+        "triggerToReopen": "repeated invite usage after beta activation",
+        "missingEvidence": "stable collaboration volume"
+      }
+    }
+  ]
+}

package/docs/examples/scripts/check-example-bindings.sh

@@ -0,0 +1,116 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+# ------------------------------------------------------------
+# 校验 examples 与当前 skill 版本链是否仍然对齐
+# ------------------------------------------------------------
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
+BINDINGS_FILE="${EXAMPLE_BINDINGS_FILE:-$ROOT_DIR/docs/examples/example-bindings.json}"
+
+if [[ ! -f "$BINDINGS_FILE" ]]; then
+  echo "Missing bindings file: $BINDINGS_FILE" >&2
+  exit 1
+fi
+
+skill_version() {
+  local skill="$1"
+  local file="$ROOT_DIR/.claude/skills/$skill/SKILL.md"
+  if [[ ! -f "$file" ]]; then
+    echo "Missing skill file: $file" >&2
+    exit 1
+  fi
+
+  sed -n 's/^version: //p' "$file" | head -n 1
+}
+
+assert_contains() {
+  local file="$1"
+  local needle="$2"
+  if ! rg -F --quiet -- "$needle" "$file"; then
+    echo "Expected '$needle' in $file" >&2
+    exit 1
+  fi
+}
+
+ROADMAP_VERSION="$(skill_version cc-roadmap)"
+REQ_PLAN_VERSION="$(skill_version cc-plan)"
+INVESTIGATE_VERSION="$(skill_version cc-investigate)"
+REQ_DO_VERSION="$(skill_version cc-do)"
+REQ_CHECK_VERSION="$(skill_version cc-check)"
+REQ_ACT_VERSION="$(skill_version cc-act)"
+
+for pair in \
+  "cc-roadmap:$ROADMAP_VERSION" \
+  "cc-plan:$REQ_PLAN_VERSION" \
+  "cc-investigate:$INVESTIGATE_VERSION" \
+  "cc-do:$REQ_DO_VERSION" \
+  "cc-check:$REQ_CHECK_VERSION" \
+  "cc-act:$REQ_ACT_VERSION"
+do
+  skill="${pair%%:*}"
+  version="${pair##*:}"
+  expected="$(jq -r --arg skill "$skill" '.skills[$skill]' "$BINDINGS_FILE")"
+  if [[ "$expected" != "$version" ]]; then
+    echo "Binding mismatch for $skill: bindings=$expected current=$version" >&2
+    exit 1
+  fi
+done
+
+while IFS= read -r encoded; do
+  example_id="$(jq -r '.id' <<<"$encoded")"
+  readme="$ROOT_DIR/$(jq -r '.readme' <<<"$encoded")"
+  root="$ROOT_DIR/$(jq -r '.root' <<<"$encoded")"
+  change_dir="$ROOT_DIR/$(jq -r '.changeDir' <<<"$encoded")"
+  planning_dir="$change_dir/planning"
+  review_dir="$change_dir/review"
+  handoff_dir="$change_dir/handoff"
+
+  for file in "$readme" "$root/ROADMAP.md" "$root/BACKLOG.md" "$root/roadmap-tracking.json" "$planning_dir/design.md" "$planning_dir/tasks.md" "$planning_dir/task-manifest.json"; do
+    if [[ ! -f "$file" ]]; then
+      echo "Example $example_id is missing required file: $file" >&2
+      exit 1
+    fi
+  done
+
+  assert_contains "$root/ROADMAP.md" "- Skill version: \`$ROADMAP_VERSION\`"
+  assert_contains "$root/ROADMAP.md" "- Tracking source: \`roadmap-tracking.json\`"
+  assert_contains "$root/BACKLOG.md" "- Skill version: \`$ROADMAP_VERSION\`"
+  assert_contains "$root/BACKLOG.md" "- Tracking source: \`roadmap-tracking.json\`"
+  assert_contains "$root/BACKLOG.md" "| RM-ID | Title | Source Stage | Priority | Primary Capability | Secondary Capabilities | Capability Gap | Expected Spec Delta | Evidence | Depends On | Parallel With | Unknowns | Next Decision | Ready |"
+  assert_contains "$root/BACKLOG.md" "## Ready For Req-Plan"
+  assert_contains "$root/BACKLOG.md" "  - Primary Capability:"
+  assert_contains "$root/BACKLOG.md" "  - Expected spec delta:"
+  jq -er '.version == 2 and (.items | length) > 0 and (.backlogMeta | type == "object") and (.dependencyHandoff | type == "object") and any(.items[]; .backlog != null)' "$root/roadmap-tracking.json" >/dev/null
+  assert_contains "$planning_dir/design.md" "- CC-Plan skill version: \`$REQ_PLAN_VERSION\`"
+  assert_contains "$planning_dir/tasks.md" "- CC-Plan skill version: \`$REQ_PLAN_VERSION\`"
+
+  jq -er --arg roadmap "$ROADMAP_VERSION" --arg reqplan "$REQ_PLAN_VERSION" '
+    (.sourceRoadmap.roadmapSkillVersion // $roadmap) == $roadmap and
+    (.planningMeta.reqPlanSkillVersion // $reqplan) == $reqplan
+  ' "$planning_dir/task-manifest.json" >/dev/null
+
+  assert_contains "$readme" "## Example Meta"
+  assert_contains "$readme" "\`cc-roadmap@$ROADMAP_VERSION\`"
+  assert_contains "$readme" "\`cc-plan@$REQ_PLAN_VERSION\`"
+  assert_contains "$readme" "\`cc-do@$REQ_DO_VERSION\`"
+  assert_contains "$readme" "\`cc-check@$REQ_CHECK_VERSION\`"
+
+  if jq -e '.covers | index("cc-act")' <<<"$encoded" >/dev/null; then
+    assert_contains "$readme" "\`cc-act@$REQ_ACT_VERSION\`"
+  fi
+
+  if [[ -f "$review_dir/report-card.json" ]]; then
+    "$ROOT_DIR/.claude/skills/cc-check/scripts/verify-gate.sh" --report "$review_dir/report-card.json" >/dev/null
+  fi
+
+  if jq -e '.covers | index("cc-act")' <<<"$encoded" >/dev/null; then
+    if [[ ! -f "$handoff_dir/pr-brief.md" && ! -f "$handoff_dir/resume-index.md" && ! -f "$handoff_dir/release-note.md" && ! -f "$handoff_dir/status.md" ]]; then
+      echo "Example $example_id is missing a final handoff file under $handoff_dir" >&2
+      exit 1
+    fi
+  fi
+done < <(jq -c '.examples[]' "$BINDINGS_FILE")
+
+echo "Example bindings are in sync with current skill versions"

package/docs/guides/getting-started.md

@@ -4,202 +4,167 @@
 
 ---
 
-## 📋 Overview
+## Overview
 
-This guide will help you get started with cc-devflow, from installation to your first requirement development.
+CC-DevFlow has two entry paths:
 
-## 🚀 Prerequisites
+- `cc-devflow init`: install the whole `.claude` pack into your project
+- `cc-devflow adapt`: generate platform outputs such as Codex rules
 
-- [Claude Code](https://claude.ai/code) installed and configured
-- Git repository initialized
-- Node.js project (optional, for additional quality checks)
+The workflow itself is driven by six visible skills:
 
-## 📦 Installation
+```text
+cc-roadmap
 
-### Quick Install
-
-```bash
-# Clone .claude configuration to your project
-pnpm dlx tiged Dimon94/cc-devflow/.claude .claude
+PDCA: cc-plan -> cc-do -> cc-check -> cc-act
+IDCA: cc-investigate -> cc-do -> cc-check -> cc-act
 ```
 
-### Manual Install
-
-```bash
-# Download and extract
-curl -L https://github.com/Dimon94/cc-devflow/archive/main.zip -o cc-devflow.zip
-unzip cc-devflow.zip
-cp -r cc-devflow-main/.claude .claude
-rm -rf cc-devflow.zip cc-devflow-main
-```
+The public skills are the visible harness. Each distributed `SKILL.md` now carries structured frontmatter plus a `Harness Contract`, and each `PLAYBOOK.md` carries the stage transition rules in a `Visible State Machine` section.
 
-## ✅ Verify Installation
-
-Run the verification script:
-
-```bash
-.claude/scripts/verify-setup.sh
-```
+## Prerequisites
 
-This script will check:
-- All required files and directories exist
-- Scripts have execute permissions
-- Git repository is properly configured
+- Node.js 18+
+- A Git repository
+- Claude Code or another supported agent environment
 
-## 🎯 Your First Requirement
+## Install
 
-### Step 1: Run the Mainline Flow
+### Whole Pack Install
 
 ```bash
-/flow:init "REQ-001|User Authentication|https://docs.example.com/auth"
-/flow:spec "REQ-001"
-/flow:dev "REQ-001"
-/flow:verify "REQ-001" --strict
-/flow:release "REQ-001"
+npx cc-devflow init --dir /path/to/your/project
 ```
 
-This will:
-1. Initialize requirement context package
-2. Generate executable task-manifest
-3. Dispatch task execution with checkpoints
-4. Run quick/strict quality gates
-5. Generate release note and cleanup runtime logs
+The whole-pack install includes the six visible workflow skills plus `cc-spec-init` and `cc-simplify` as maintenance helpers.
 
-### Step 2: Check Progress
+### Single Skill Install
 
 ```bash
-/flow:status REQ-001
+npx skills add https://github.com/Dimon94/cc-devflow --skill cc-roadmap
 ```
 
-### Step 3: Resume If Interrupted
+## Adapt For A Platform
 
 ```bash
-/flow:dev "REQ-001" --resume
+npx cc-devflow adapt --cwd /path/to/your/project --platform codex
+npx cc-devflow adapt --cwd /path/to/your/project --platform cursor
+npx cc-devflow adapt --cwd /path/to/your/project --platform qwen
+npx cc-devflow adapt --cwd /path/to/your/project --platform antigravity
 ```
 
-## 🛠️ Core Scripts
+## Verify Installation
 
-### Environment Check
-```bash
-bash .claude/scripts/check-prerequisites.sh
-```
+Check that the expected skill folders exist:
 
-### View Task Status
 ```bash
-bash .claude/scripts/check-task-status.sh --verbose
+find .claude/skills -mindepth 1 -maxdepth 1 -type d | sort
+find .claude/skills -mindepth 2 -maxdepth 2 -name SKILL.md | sort
 ```
 
-### Mark Task Complete
-```bash
-bash .claude/scripts/mark-task-complete.sh T001
-```
+If you adapted for Codex, verify the mirrored skill folders:
 
-### Generate Status Report
 ```bash
-bash .claude/scripts/generate-status-report.sh --format markdown
+find .codex/skills -mindepth 2 -maxdepth 2 -name SKILL.md | sort
 ```
 
-## 🧪 Running Tests
+## First Workflow
 
-### Script Tests
-```bash
-# Run all tests
-bash .claude/tests/run-all-tests.sh --scripts
+Use the skills in this order:
 
-# Run specific test
-bash .claude/tests/scripts/test_check_prerequisites.sh
+```text
+1. cc-roadmap
+2. choose cc-plan or cc-investigate
+3. cc-do
+4. cc-check
+5. cc-act
+6. repeat
 ```
 
-### Constitution Tests
-```bash
-bash .claude/tests/constitution/run_all_constitution_tests.sh
-```
+Typical outputs:
 
-## 📊 Interactive Demo
+- `cc-roadmap` writes `devflow/ROADMAP.md` and `devflow/BACKLOG.md`; helper sync can also maintain `devflow/roadmap-tracking.json` as the shared roadmap/backlog truth source
+- `cc-spec-init` writes `devflow/specs/INDEX.md`, capability specs, and `change-meta.json`
+- `cc-plan` writes `planning/design.md`, `planning/tasks.md`, `task-manifest.json`, and `change-meta.json`
+- `cc-investigate` writes `planning/analysis.md`, `planning/tasks.md`, `task-manifest.json`, and `change-meta.json`
+- `cc-check` writes `report-card.json`
+- `cc-act` writes exactly one final handoff file: `handoff/pr-brief.md`, `handoff/resume-index.md`, or `handoff/release-note.md`
 
-Run the interactive demo to see the complete workflow:
+Capability truth lives in `devflow/specs/`.
+Change truth lives in `devflow/changes/<change>/`.
 
-```bash
-python3 .claude/scripts/demo.py
-```
+- Keep `INDEX.md` plus capability markdown under `devflow/specs/`.
+- Name new change directories as `REQ-<number>-<description>` for requirements or `FIX-<number>-<description>` for bug fixes; old lowercase directories are compatibility reads only.
+- Keep `change-state.json`, `change-meta.json`, planning docs, `task-manifest.json`, optional `team-state.json`, task `checkpoint.json`, `report-card.json`, and one final handoff file under each `devflow/changes/<change>/`.
+- Worker prompts, journals, assignments, and session logs belong under `devflow/workspaces/<change>/` as ephemeral scratch.
 
-## 🔧 Configuration
+Typical public contract fields:
 
-### Minimum Configuration
+- `triggers`, `reads`, structured `writes`, `effects`
+- `entry_gate`, `exit_criteria`
+- `reroutes`, `recovery_modes`, `tool_budget`
 
-Edit `.claude/settings.json`:
+If you want to see complete artifact chains before using the skills, start with [../examples/START-HERE.md](../examples/START-HERE.md). If you are updating examples alongside skills, run [../examples/scripts/check-example-bindings.sh](../examples/scripts/check-example-bindings.sh).
 
-```json
-{
-  "permissions": {
-    "allowGitOperations": true,
-    "allowNetworkRequests": true,
-    "allowSubprocesses": true
-  }
-}
-```
+## Upgrade
 
-### Environment Variables
+Refresh the whole pack with the latest packaged CLI:
 
 ```bash
-# Quality gates
-export MIN_TEST_COVERAGE=80
-export STRICT_TYPE_CHECKING=true
-
-# Flow behavior
-export FLOW_AUTO_APPROVE=false
+npx cc-devflow@latest init --dir /path/to/your/project
 ```
 
-## 📚 Next Steps
-
-- [Command Reference](../commands/README.md) - Learn all available commands
-- [Workflow Guide](./workflow-guide.md) - Understand the development workflow
-- [Best Practices](./best-practices.md) - Follow recommended practices
+Refresh generated platform outputs:
 
-## 🚨 Troubleshooting
+```bash
+npx cc-devflow adapt --cwd /path/to/your/project --all
+```
 
-### Issue: Scripts not executable
+Refresh one installed skill:
 
 ```bash
-chmod +x .claude/scripts/*.sh
-chmod +x .claude/hooks/*.sh
+npx skills update
 ```
 
-### Issue: Git not initialized
+## Troubleshooting
+
+### `.claude` already exists
 
 ```bash
-git init
-git add .
-git commit -m "Initial commit"
+npx cc-devflow init --dir /path/to/your/project --force
 ```
 
-### Issue: Tests failing
+`--force` force-upgrades only the distributed cc-devflow skills. It does not delete existing `.claude/commands`, custom skills, or other project-owned files.
 
-```bash
-# Check prerequisites
-bash .claude/scripts/check-prerequisites.sh
+### No Codex output generated
 
-# Run tests with verbose output
-VERBOSE=true bash .claude/tests/run-all-tests.sh --scripts
-```
+Run:
 
-## 💡 Tips
+```bash
+npx cc-devflow adapt --cwd /path/to/your/project --platform codex
+```
 
-1. **Always check progress** with `/flow:status` before continuing work
-2. **Use `/flow:verify`** to check quality gates and consistency
-3. **Enable debug mode** if you encounter issues: `export FLOW_DEBUG=1`
-4. **Read the Constitution** to understand quality standards
+If your project has no optional `.claude/commands/` input, this is expected: the compiler will still generate the skills registry and mirror the distributed skill set for Codex.
 
-## 🆘 Getting Help
+Codex mirrors the distributed skills from `.claude/skills/<skill>/` into `.codex/skills/<skill>/`. That set includes the six public workflow skills plus `cc-spec-init` and `cc-simplify`, and the mirror is additive-only: existing project-owned Codex skills are preserved instead of being deleted.
 
-- [GitHub Issues](https://github.com/Dimon94/cc-devflow/issues)
-- [Documentation](../../docs/)
-- [Contributing Guide](../../CONTRIBUTING.md)
+### Keep skills and examples in sync
 
----
+```bash
+npm run verify
+```
 
-**Ready to start? Run your first command:**
+If you are preparing a publishable pack, run:
 
 ```bash
-/flow:init "REQ-001|My First Feature"
+npm run verify:publish
 ```
+
+## Next Steps
+
+- [CLI And Skills](../commands/README.md)
+- [Workflow Guide](./workflow-guide.md)
+- [Best Practices](./best-practices.md)
+- [Example Entry Page](../examples/START-HERE.md)
+- [Compact Example List](../examples/README.md)
+- [Project README](../../README.md)