---
artifact_type: repair-plan
name: ccpe-system-core-repair-plan
created: 2026-05-31
updated: 2026-05-31
status: draft
based_on: CCPE System
---

# CCPE System Core Repair Plan

## 1. Problem

The current CCPE System is strong at artifact governance: classifying, splitting, indexing, and maintaining Lite prompts, Agent Specs, Skills, Runtimes, and Model Cards.

It is weaker at preserving the original CCPE 2.0 prompt-construction kernel for mature single-agent expert prompts.

This creates two failure modes:

```text
1. Existing mature agents may be structurally upgraded but perform worse than their original CCPE 2.0 versions.
2. New deep expert agents may be over-agentified before their single-agent prompt core is strong enough.
```

## 2. Repair Principle

```text
Scenario first, artifact layers second.
Lite kernel first for single-agent expert use.
Agent / Skill / Runtime only when the scenario requires them.
```

## 3. Core Additions

### 3.1 Scenario Probe

Before creating, auditing, or refactoring an artifact, CCPE Forge must identify:

```text
- current or planned usage scenario
- target platform
- single-agent vs multi-agent use
- manual orchestration vs automation
- Web-like direct chat vs Codex callable behavior
- whether a Skill is needed for Codex invocation
- depth-oriented vs automation-oriented work
```

### 3.2 Mature Agent Minimal Expansion Rule

For mature, proven, single-agent expert prompts:

```text
default_output: Lite + optional Model Card
do_not_default_to: Agent + Skill + Runtime
```

Expand only when there is a real usage need:

```text
Skill: Codex callable method or reusable procedure
Agent: durable workflow role with collaboration contract
Runtime: multi-agent process, state, handoff, or automation
```

### 3.3 CCPE-Lite Construction Kernel

Lite is not merely a shortened Agent Spec.

For Web / GPT / Gemini / Claude style deployment, Lite should preserve the CCPE 2.0 working core:

```text
Core Layer
Execution Layer
Constraint Layer
Operation Layer
```

Use Outside-In construction:

```text
1. Alignment: purpose and usage scene
2. Scope: input, output, appendix / knowledge scope
3. Specification: output format and delivery standard
4. Core Construction: role, capability, constraints
5. Logic Design: workflow that produces the specified output
```

### 3.4 Regression Testing

When migrating a mature agent, validation must compare the new artifact against the old one:

```text
- Does the new Lite preserve the old agent's practical effect?
- Does it preserve the original voice and workflow?
- Does it improve defects without weakening production behavior?
- If tested, does it match or exceed old outputs in the intended scenario?
```

## 4. Files to Repair

```text
ccpe-protocol/ccpe-classification-rules.md
ccpe-protocol/ccpe-migration-policy.md
ccpe-protocol/ccpe-operating-modes.md
ccpe-protocol/ccpe-quality-rubric.md
.codex/skills/ccpe-forge/SKILL.md
.codex/skills/ccpe-forge/references/creator-mode.md
.codex/skills/ccpe-forge/references/refactor-mode.md
.codex/skills/ccpe-forge/templates/ccpe-lite.prompt.md
README.md
AGENTS.md
```

## 5. Non-Goals

```text
- Do not create the article review committee Runtime yet.
- Do not force Cognitive Imaging into Agent / Skill / Runtime in this repair pass.
- Do not rewrite the entire CCPE System.
- Do not change canonical model promotion in this pass unless separately requested.
```

## 6. Success Criteria

```text
- Scenario Probe appears in core workflow rules.
- Mature Agent Minimal Expansion Rule appears in classification and migration policy.
- CCPE-Lite template uses the four-layer CCPE 2.0 kernel.
- Quality Rubric evaluates scenario fit and Lite regression.
- Forge Creator and Refactor modes require scenario-based layer selection.
- Documentation warns against default four-layer expansion.
```