---
artifact_type: ccpe-runtime
name: CCRA Local Review Runtime
runtime_id: ccra-local-review
author: CCPE System
version: 0.1.2
created: 2026-06-19
updated: 2026-06-19
status: draft
runtime_type: hybrid-runtime
target_platform: Codex local child session / platform-neutral Markdown
based_on: CCPE System
related_agents:
  - ccra-local-reviewer
related_skills:
  - ccra-findings-classification
  - model-lifecycle-scope-guard
  - review-bundle-audit
  - routing-behavior-diff-audit
  - regression-validation-gate-runner
  - lifecycle-status-guard-scan
  - review-context-builder
related_integrations:
  - ccra-local-review-skills-vault-helpers
related_models:
  - qpi-front-routing-boundary
related_protocols:
  - agent-invocation-packet
---

# CCRA Local Review Runtime

## 1. Runtime Overview

### 1.1 Purpose

Define how a project session invokes `ccra-local-reviewer` as a real local reviewer with file-first evidence, child-session isolation, durable run records, and explicit Owner/Web CCRA authority boundaries.

This Runtime supports repeated local tuning loops before Web CCRA final review.

### 1.2 Runtime Type

```text
hybrid-runtime
```

### 1.3 Operating Mode

```text
hybrid-mode
```

### 1.4 Success Criteria

```text
Local CCRA reviewer is invoked in a real child session or equivalent isolated participant context.
The child reviewer reads local evidence directly.
The review run directory records invocation packet, returned output, report, helper outputs, and resume state.
The report quality can be compared against Web CCRA quality during pilot.
The Runtime supports repeated local tuning before Web final review.
The Runtime supports two-turn same-child-session review and planning.
The review report combines Web-style product diagnosis with file-first local audit.
Owner and Web CCRA authority boundaries remain explicit.
```

### 1.5 Non-Goals

```text
Do not implement skills-vault helpers.
Do not modify project files.
Do not create review bundles.
Do not approve lifecycle status.
Do not replace Owner decision.
Do not replace Web CCRA final review for major milestones.
Do not use main-session roleplay as formal Local CCRA output.
```

## 2. Participants

### 2.1 Human Role

The Owner decides:

```text
which round/pass to review
whether a child-session output is accepted as valid Local CCRA output
which findings become accepted work
whether local tuning is complete
whether the round is ready for Web CCRA final review
whether lifecycle status changes are allowed
whether a Local CCRA report can be included in a Web upload package
```

### 2.2 Agents

```text
- agent_id: ccra-local-reviewer
  role: formal local CCRA reviewer
  responsibility: read local evidence, inspect review quality, classify findings, recommend local tuning or Web final review readiness
  invocation_condition: after local review run directory and invocation packet are prepared
  required_invocation_record: agent-invocation-packet.md
  required_return_record: returned-output.md, 04_LOCAL_CCRA_REVIEW_REPORT.md, next-review-requirements.md, or comparison note according to turn_type
  persistent_required: true for pilot and tuning loops when follow-up calibration is expected
```

### 2.3 Skills

CCPE evaluation Skills:

```text
- skill_id: ccra-findings-classification
  purpose: classify Local CCRA findings and recommendations.
  invocation_condition: during report writing.

- skill_id: model-lifecycle-scope-guard
  purpose: inspect lifecycle, scope, and authority overclaims.
  invocation_condition: whenever review material claims completion, stability, acceptance, or promotion.
```

Registered skills-vault automation helpers:

```text
- skill_id: review-context-builder
  status: installed
  installed_path: C:\Users\wangq\.agents\skills\review-context-builder
  purpose: build a file-first review context index and manifest.
  invocation_condition: run initialization.

- skill_id: review-bundle-audit
  status: installed
  installed_path: C:\Users\wangq\.agents\skills\review-bundle-audit
  purpose: deterministic review bundle completeness audit.
  invocation_condition: preflight.

- skill_id: routing-behavior-diff-audit
  status: installed
  installed_path: C:\Users\wangq\.agents\skills\routing-behavior-diff-audit
  purpose: deterministic before/after routing comparison.
  invocation_condition: after selector/routing/QPI changes.

- skill_id: regression-validation-gate-runner
  status: installed
  installed_path: C:\Users\wangq\.agents\skills\regression-validation-gate-runner
  purpose: run or verify declared validation gates.
  invocation_condition: when engineering evidence is part of review.

- skill_id: lifecycle-status-guard-scan
  status: installed
  installed_path: C:\Users\wangq\.agents\skills\lifecycle-status-guard-scan
  purpose: scan files for lifecycle overclaims.
  invocation_condition: when lifecycle/status claims are in scope.
```

#### 2.3.1 Public Helper Usage In This Runtime

These helpers are public `skills-vault` automation Skills. This Runtime uses them as evidence-producing steps, not as CCRA-specific judgment modules.

```text
review-context-builder:
  Runtime stage: Stage 1.
  Input: configured project files, `knowledge_assets/`, review bundle roots, include/exclude patterns, review metadata.
  Output: review-context.md and review-file-manifest.json.
  CCRA use: navigation index for the child reviewer and audit trail for what context was offered.

review-bundle-audit:
  Runtime stage: Stage 1.
  Input: review bundle directory.
  Output: helper-outputs/bundle-audit.md and helper-outputs/bundle-audit.json.
  CCRA use: evidence of package completeness or missing review materials.
  Profile contract: use `ccra_mindscape_review_bundle` when available; otherwise record `generic` plus profile limitations.

routing-behavior-diff-audit:
  Runtime stage: Stage 1 when before/after routing outputs exist.
  Input: before/after routing result files and field mapping config.
  Output: helper-outputs/routing-behavior-diff.md and helper-outputs/routing-behavior-diff.json.
  CCRA use: evidence for non-target behavior changes and calibration needs.
  Requirement: mandatory for patch verification when before/after routing evidence exists; otherwise require a manual equivalent table.

regression-validation-gate-runner:
  Runtime stage: Stage 1 when declared gates are part of review evidence.
  Input: project-defined gate manifest.
  Output: helper-outputs/gate-run-report.md, helper-outputs/gate-run-report.json, and logs.
  CCRA use: evidence of which checks ran, passed, failed, or were skipped.
  Execution policy: governed by `gate_execution_mode`.

lifecycle-status-guard-scan:
  Runtime stage: Stage 1 when lifecycle/status claims are in scope.
  Input: configured scan root and lifecycle guard config.
  Output: helper-outputs/lifecycle-status-guard-scan.md and helper-outputs/lifecycle-status-guard-scan.json.
  CCRA use: candidate overclaim list for Agent judgment.
  Scope policy: governed by `lifecycle_scan_scope`; whole-repo scans are broad audit mode, not default blocker mode.
```

The Local CCRA Agent must cite helper outputs when used, but must still perform judgment in the Agent report.

### 2.4 Tools

```text
- tool_name: filesystem_read
  purpose: read specified project files and review bundles.
  permission: read only confirmed input paths.

- tool_name: filesystem_write_run_dir
  purpose: write invocation records, helper outputs, reports, and run notes.
  permission: write only inside local_ccra_reviews/<round>/<local-pass>/.

- tool_name: skills-vault-installed-helpers
  purpose: deterministic helper execution through registered installed skills-vault Skills.
  permission: only through explicit Skill execution records.
```

## 3. Context Layer

### 3.1 Input Contract

```yaml
runtime_id: ccra-local-review
client_project_root:
knowledge_base_path: C:\Users\wangq\Documents\Codex\work-projects\the-mindscape-of-bro-tsong\knowledge_assets
review_round:
local_pass:
turn_type: review_turn | planning_turn | comparison_turn
review_goal:
review_scope:
non_goals:
review_bundle_paths:
local_review_run_dir:
primary_question:
previous_turn_report_path:
next_review_target:
required_project_docs:
required_evidence_files:
optional_evidence_files:
helper_outputs:
bundle_audit_profile: ccra_mindscape_review_bundle | generic | not_applicable
gate_execution_mode: dry_run | run | owner_waived | not_applicable
routing_diff_policy: required | skipped_no_after_evidence | manual_equivalent_required | not_applicable
lifecycle_scan_scope: current_review_bundle | changed_files | knowledge_assets | model_library_state | whole_repo
expected_routing_diff_categories:
  - target_behavior_changes
  - non_target_behavior_changes
  - accepted_collateral_changes
  - unexpected_regressions
  - unchanged_expected_behavior
  - cases_needing_owner_or_web_calibration
child_session_required: true
persistent_child_session_required: true
output_report_path: local_ccra_reviews/<round>/<local-pass>/04_LOCAL_CCRA_REVIEW_REPORT.md
returned_output_summary_path: local_ccra_reviews/<round>/<local-pass>/returned-output.md
planning_output_path: local_ccra_reviews/<round>/<local-pass>/next-review-requirements.md
comparison_output_path: local_ccra_reviews/<round>/<local-pass>/05_WEB_LOCAL_CCRA_COMPARISON.md
web_final_review_policy: owner_must_approve_inclusion
```

### 3.2 Required Context

```text
client project README / AGENTS / PROJECTS
client project knowledge base: knowledge_assets/
workflow and decision docs relevant to the round
review bundle directory
reports, tests, selector/routing files, regression cases, validation outputs, and diffs relevant to the review
prior Owner or Web CCRA decisions when used as authority
local run directory path
```

### 3.3 Optional Context

```text
prior Local CCRA reports
Web CCRA planning discussion excerpts
skills-vault helper outputs
known accepted risk records
```

### 3.4 Shared Context

Inside the run directory:

```text
agent-invocation-packet.md
turn-prompts/
review-context.md
review-file-manifest.json
helper-outputs/
04_LOCAL_CCRA_REVIEW_REPORT.md
next-review-requirements.md
returned-output.md
05_WEB_LOCAL_CCRA_COMPARISON.md
run-notes.md
owner-decision.md
```

### 3.5 Source Policy

Project files and review bundle evidence are authoritative. Main-session summaries are routing context only. The reviewer must cite actual files or explicitly state when evidence was not available.

## 4. Authority Layer

### 4.1 Autonomous Actions

The runtime operator may:

```text
create the local review run directory
prepare invocation packet
prepare prompt-to-send if needed
run implemented skills-vault helpers when explicitly available and allowed
collect returned Local CCRA output
record run notes
```

The Local CCRA child reviewer may:

```text
read specified files
write the review report
classify findings
recommend local tuning, deferral, stop, or Web final review readiness
```

### 4.2 Actions Requiring Confirmation

```text
accept Local CCRA findings as work
include Local CCRA report in Web CCRA upload
close a round
upgrade lifecycle status
route new deterministic helpers to skills-vault
change the review scope after invocation
```

### 4.3 Forbidden Actions

```text
modify project source files
edit selector rules
edit model cards
edit model JSON
edit regression cases
create review bundles
upgrade lifecycle status
add a third model
introduce LLM selector, RAG, database, frontend, backend, user system, or platform behavior
accept main-session roleplay as formal Local CCRA output
```

### 4.4 Human Decision Gates

```text
Gate Start:
- Trigger: proposed Local CCRA run.
- Human decision required: approve round/pass, review goal, scope, and run directory.
- Possible outcomes: proceed / revise scope / stop.

Gate Invocation:
- Trigger: child-session invocation record is prepared or returned.
- Human decision required: accept whether invocation evidence is valid when uncertain.
- Possible outcomes: accept / rerun / manual handoff / stop.

Gate Findings:
- Trigger: Local CCRA report is returned.
- Human decision required: accept, reject, or defer each finding.
- Possible outcomes: implement accepted work / request reviewer follow-up / send to Web CCRA / stop.

Gate Web Final:
- Trigger: Local tuning appears complete.
- Human decision required: decide whether to submit to Web CCRA final review.
- Possible outcomes: submit / tune more / defer.

Gate Lifecycle:
- Trigger: any lifecycle status change is proposed.
- Human decision required: approve or reject lifecycle change.
- Possible outcomes: update in project / defer / reject.

Gate skills-vault Routing:
- Trigger: repeated deterministic helper need is identified.
- Human decision required: approve outbound supplier request.
- Possible outcomes: create request / keep manual / product-local helper / stop.
```

### 4.5 Risk Levels

```text
Low:
  create run directory, context index, invocation packet.

Medium:
  run deterministic helper scans and write helper outputs.

High:
  accept findings as work or include report in Web upload.

Critical:
  lifecycle status changes, round closure, or treating Local CCRA as Owner/Web approval.
```

## 5. Workflow Layer

### 5.1 Runtime Stages

```text
Stage 0: Run Setup
- Purpose: create or confirm local review run directory and scope.
- Actor: main project session.
- Input: owner instruction, round/pass, review bundle path.
- Output: run directory, run-notes.md shell.
- Human gate: Gate Start.

Stage 1: Deterministic Context And Helper Outputs
- Purpose: collect file-first context and optional helper outputs.
- Actor: main project session or skills-vault helpers.
- Input: project files, review bundle, helper configs, bundle audit profile, gate execution mode, routing diff policy, lifecycle scan scope.
- Output: review-context.md, review-file-manifest.json, helper-outputs/*.
- Human gate: only if helper execution is not already authorized.

Stage 2: Local CCRA Invocation Packet
- Purpose: invoke the formal reviewer.
- Actor: main project session.
- Input: canonical Agent path, context files, output contract.
- Output: agent-invocation-packet.md and prompt-to-send.md if needed.
- Human gate: Gate Invocation if invocation evidence is uncertain.

Stage 3A: Child Reviewer Review Turn
- Purpose: formal Local CCRA review of current material.
- Actor: ccra-local-reviewer child session.
- Input: invocation packet, project files, helper outputs.
- Output: 04_LOCAL_CCRA_REVIEW_REPORT.md and returned-output.md.
- Human gate: none during execution unless blocked.

Stage 3B: Same-Session Planning Turn
- Purpose: plan next review requirements and submitted-material package after the review report.
- Actor: same ccra-local-reviewer child session.
- Input: same child_session_id, Turn 1 report, Owner decisions when present, next review target.
- Output: next-review-requirements.md and returned-output.md update.
- Human gate: Gate Findings should happen before treating the planning output as actionable.

Stage 3C: Optional Comparison Turn
- Purpose: compare Local CCRA output with Web CCRA/GPT feedback when Owner asks.
- Actor: same child session when available, otherwise a new session with prior reports supplied.
- Input: Local CCRA report, Web CCRA source/range, Owner comparison question.
- Output: 05_WEB_LOCAL_CCRA_COMPARISON.md or project-defined comparison path.
- Human gate: comparison output is advisory only.

Stage 4: Owner Decision
- Purpose: decide what the report means for project work.
- Actor: Owner with main project session.
- Input: Local CCRA report.
- Output: owner-decision.md and accepted work list.
- Human gate: Gate Findings.

Stage 5: Tuning Loop
- Purpose: execute accepted local repairs in the project repository and rerun Local CCRA as needed.
- Actor: project main session, not the reviewer.
- Input: accepted findings.
- Output: revised project files and new local pass.
- Human gate: Gate Web Final when local tuning appears complete.

Stage 6: Web Final Review Handoff
- Purpose: prepare final review material for Web CCRA.
- Actor: project main session.
- Input: final review bundle, optional Local CCRA report with Owner approval.
- Output: Web CCRA upload package.
- Human gate: Gate Web Final.
```

### 5.2 Main Workflow

```text
1. Owner asks the project session to run Local CCRA on an existing or current round.
2. Project session creates local_ccra_reviews/<round>/<local-pass>/.
3. Project session writes run-notes.md and prepares context.
4. Project session runs available deterministic helpers according to `bundle_audit_profile`, `gate_execution_mode`, `routing_diff_policy`, and `lifecycle_scan_scope`, or records that they are unavailable.
5. Project session writes agent-invocation-packet.md.
6. Project session invokes ccra-local-reviewer in a child session or equivalent isolated participant context with `turn_type: review_turn`.
7. Child reviewer writes 04_LOCAL_CCRA_REVIEW_REPORT.md.
8. Project session records the compact Owner-facing returned-output.md summary or links report as returned output.
9. Owner reviews findings and records accepted work or open decisions.
10. If the Owner asks for next review planning, project session sends `turn_type: planning_turn` to the same child_session_id with the Turn 1 report path and next review target.
11. Child reviewer writes next-review-requirements.md without re-reviewing unchanged material.
12. Project session performs accepted tuning in the project repository.
13. Repeat Local CCRA passes until Owner decides Web final review is appropriate.
14. Owner decides whether Local CCRA report enters Web upload material.
```

### 5.3 Branch Logic

```text
Historical pilot:
  Use Round 03 or Round 04 material.
  Primary validation is invocation authenticity, session continuity, and Web CCRA quality comparison.
  Routing diff may be skipped only when no before/after evidence is allowed by the no-hindsight scope.

Round 05 readiness:
  Use current Round 05 bundle and full project evidence.
  Primary validation is whether local tuning has satisfied planning goals before Web final review.

Post-patch pass:
  Require routing behavior diff or a manual equivalent table, plus regression/validation evidence appropriate to `gate_execution_mode`.
  A dry-run gate report may support planning only; it cannot support a pass claim.

Lifecycle-sensitive pass:
  Require lifecycle guard review, declared lifecycle scan scope, and triage before any lifecycle finding blocks readiness.
```

### 5.4 Loop Rules

```text
Repeat Stage 3 only when new evidence, accepted repairs, or reviewer follow-up questions exist.
Do not rerun with unchanged evidence unless the prior invocation was invalid.
Each tuning loop gets a new local_pass directory.
Persistent child session should continue when the review lens is being calibrated.
Within one local_pass, `review_turn` and `planning_turn` should use the same child_session_id.
`planning_turn` must reference 04_LOCAL_CCRA_REVIEW_REPORT.md and Owner decisions when present.
If persistence is unavailable, the next pass must include previous report and owner-decision.md.
```

### 5.5 Stop Conditions

```text
Owner stops the run.
Child-session invocation cannot be made real.
Required evidence is missing.
Review scope becomes unclear.
Reviewer would need prohibited write access.
Findings require Owner or Web CCRA decision.
Local report is written and no immediate follow-up is requested.
```

### 5.6 Escalation Conditions

Escalate when:

```text
Local CCRA quality falls below Web CCRA expectation.
Tool/helper outputs conflict with reviewer judgment.
Lifecycle promotion is proposed.
The round goal changes during review.
The Runtime cannot preserve child-session identity for a tuning loop that needs continuity.
```

## 6. State Layer

### 6.1 Working State

```text
review_round
local_pass
review_goal
scope_statement
helper_status
invocation_status
child_session_id
report_status
owner_decision_status
web_final_review_readiness
```

### 6.2 Persistent State

Persistent state lives in:

```text
local_ccra_reviews/<round>/<local-pass>/
```

Recommended run directory:

```text
local_ccra_reviews/<round>/<local-pass>/
  run-notes.md
  agent-invocation-packet.md
  prompt-to-send.md
  turn-prompts/
    review-turn.prompt.md
    planning-turn.prompt.md
    comparison-turn.prompt.md
  review-context.md
  review-file-manifest.json
  helper-outputs/
    bundle-audit.md
    bundle-audit.json
    routing-behavior-diff.md
    routing-behavior-diff.json
    gate-run-report.md
    gate-run-report.json
    lifecycle-status-guard-scan.md
    lifecycle-status-guard-scan.json
  04_LOCAL_CCRA_REVIEW_REPORT.md
  next-review-requirements.md
  returned-output.md
  05_WEB_LOCAL_CCRA_COMPARISON.md
  owner-decision.md
```

### 6.3 Decision Log

Owner decisions should be recorded in:

```text
owner-decision.md
```

### 6.4 Artifact Log

`run-notes.md` should list generated files and whether helper outputs were manual, unavailable, or produced by a registered skills-vault Skill.

### 6.5 Resume Rules

Resume by reading:

```text
run-notes.md
agent-invocation-packet.md
review-context.md
review-file-manifest.json
helper-outputs/*
04_LOCAL_CCRA_REVIEW_REPORT.md
next-review-requirements.md when present
owner-decision.md
```

If the child session is persistent, resume in the same child session. If not, start a new child session with the previous report and Owner decisions included as context.

## 7. Collaboration Layer

### 7.1 Handoff Protocol

Use:

```text
runtimes/hybrid/agent-invocation-packet.protocol.md
```

Minimum invocation record:

```text
canonical_artifact_path
invocation_mode
carrier_type
child_session_id or equivalent metadata
turn_type
task_context
input_files
context_files
output_contract
continuity_policy
return_path
no_simulation_requirement
```

### 7.2 Role Differentiation

```text
Runtime operator:
  prepares context, invokes reviewer, records decisions, later implements accepted work.

CCRA Local Reviewer:
  reviews, classifies, and recommends, but does not edit.

skills-vault helpers:
  produce deterministic evidence artifacts.

Owner:
  accepts findings and decides lifecycle / Web final review.

Web CCRA:
  supports planning and final review / terminal cross-check.
```

### 7.3 Conflict Resolution

When Local CCRA, skills-vault helper outputs, Owner notes, and Web CCRA notes conflict:

```text
preserve all sources
identify conflict type
do not silently synthesize away disagreement
route authority conflicts to Owner
route final-review conflicts to Web CCRA when needed
```

### 7.4 Synthesis Rules

Main-session synthesis may integrate returned outputs and accepted decisions, but must not rewrite Local CCRA findings as if the Agent said something else.

## 8. Output Layer

### 8.1 Runtime Outputs

```text
Local CCRA review run directory
agent invocation packet
helper output records
Local CCRA review report
same-session next-review requirements when requested
optional Web/Local comparison note
Owner decision record
readiness statement for Web final review
```

### 8.2 Intermediate Outputs

```text
review-context.md
review-file-manifest.json
helper-outputs/*
prompt-to-send.md when needed
turn-prompts/*
run-notes.md
```

### 8.3 Output Format

The child reviewer writes according to `turn_type`:

```text
review_turn:
  04_LOCAL_CCRA_REVIEW_REPORT.md

planning_turn:
  next-review-requirements.md

comparison_turn:
  05_WEB_LOCAL_CCRA_COMPARISON.md or project-defined comparison path
```

Every turn that returns to the main project session must also update:

```text
returned-output.md
```

Minimum Owner-facing summary fields:

```text
review_round
local_pass
turn_type
child_session_id
main_conclusion
final_action_recommendation
blocks_web_review
blocks_owner_acceptance
required_next_action
output_paths
evidence_limitations
```

Use these templates:

```text
runtimes/hybrid/ccra-local-review-report.template.md
runtimes/hybrid/ccra-local-review-next-review-requirements.template.md
```

### 8.4 Archival Rules

All run-specific outputs belong in the client project:

```text
local_ccra_reviews/<round>/<local-pass>/
```

Do not store project-specific run reports in CCPE System.

## 9. Evaluation Layer

### 9.1 Validation Checklist

```text
Run directory created?
Review scope explicit?
Child-session invocation real?
Persistent session requirement recorded?
Reviewer read files directly?
Helper outputs recorded or marked unavailable?
Bundle audit profile recorded?
Versioned review-bundle manifest recognized or profile mismatch documented?
Gate execution mode recorded?
Dry-run gate output excluded from pass claims?
Routing diff required when before/after evidence exists?
Manual equivalent routing table required when helper cannot run?
Lifecycle scan scope recorded?
Lifecycle findings triaged before blocking review readiness?
Turn type and output path recorded?
Same child session preserved for planning turn when required?
Findings classified?
Issue mechanism diagnosis present?
Patch-scope judgment present?
Helper-output confidence present?
Before/after behavior review present when post-patch evidence exists?
Lifecycle/scope guard applied?
Engineering pass and product judgment separated?
Owner/Web authority boundaries explicit?
Report written to expected path?
Short returned-output summary written?
Owner decision pending or recorded?
```

### 9.2 Quality Rubric

```text
Invocation authenticity
Evidence completeness
File-first behavior
Review independence
Finding precision
Lifecycle discipline
Round-scope control
Collateral-change detection
Local tuning utility
Web final review readiness
```

### 9.3 Failure Modes

```text
main session writes reviewer output
reviewer reads only summary
helper outputs are treated as judgment
pilot cannot preserve child session
report is too generic compared with Web CCRA
reviewer audits after-the-fact but does not diagnose product failure mechanism
planning turn repeats a full review instead of planning next-review requirements
report misses full local evidence advantage
local output is treated as final approval
```

### 9.4 Recovery Rules

```text
If invocation is invalid, rerun with a real child session.
If child persistence fails, include previous report and Owner decisions in a new invocation packet and mark that same-session continuity was not preserved.
If evidence is missing, classify as blocker or rerun after context repair.
If report quality is below Web CCRA, tune Agent prompt, report template, or helper outputs before Round 05.
If authority boundary is violated, mark affected output invalid for formal synthesis.
```

## 10. Runtime Environment

### 10.1 Platform

Codex local workspace first.

### 10.2 File Access

Read:

```text
confirmed project docs
review bundles
reports
tests
selector/routing files
regression cases
diffs
helper outputs
prior decision files
```

Write:

```text
local_ccra_reviews/<round>/<local-pass>/
```

### 10.3 Tool Access

Registered helpers are available through `ccra-local-review-skills-vault-helpers`, but helper output remains evidence only and may be stale, generic, skipped, dry-run, broad-scope noisy, missing, or profile-mismatched.

### 10.4 Network Access

Not required.

### 10.5 Logging

Log:

```text
invocation metadata
files read
helper outputs
missing evidence
report path
owner decisions
resume instructions
```

### 10.6 Versioning

Use:

```text
runtime_version: 0.1.2
agent_version: 0.1.2
```

### 10.7 Expected Duration

Local CCRA is a deep file-first review, not a quick chat summary.

Expected mature-run duration:

```text
5-10 minutes
```

Several minutes of file reading, helper inspection, archive checks, or validation command execution are not abnormal by themselves. Record observed duration in `run-notes.md`.

## 11. Automation Boundary

### 11.1 Allowed Automation

```text
create run directory
build context index
audit bundle completeness
compare routing before/after
run declared validation gates
scan lifecycle status fields
record helper outputs
```

### 11.2 Requires Confirmation

```text
running non-declared commands
including Local CCRA report in Web upload
accepting findings as work
closing a round
changing lifecycle status
routing new helper capabilities to skills-vault
```

### 11.3 Forbidden Automation

```text
project file edits by reviewer
automatic lifecycle promotion
automatic Owner approval
automatic Web CCRA approval
automatic selector/rule/model edits
```

## 12. Deployment Notes

### 12.1 Codex

Use the main project session as orchestrator only. The Local CCRA report must come from a real child session or equivalent isolated participant context.

### 12.2 Claude Code

Use the same file contracts. If true child session is unavailable, produce prompt-to-send and block until returned output exists.

### 12.3 OpenClaw

Use staged runtime execution with explicit run directory and invocation packet.

### 12.4 Manual Operation

The Owner may manually run a reviewer using `prompt-to-send.md`, but the result is formal only if returned output is saved with source metadata and simulation is false.

## 13. Version Notes

```text
v0.1.0:
- Initial Local CCRA Runtime.
- Defines Local CCRA as formal local review/tuning lane before Web CCRA final review.

v0.1.1:
- Adds Patch 1 same-child-session turn protocol.
- Defines `review_turn`, `planning_turn`, and `comparison_turn`.
- Requires Web-style issue mechanism diagnosis, patch-scope judgment, helper-output confidence, and before/after behavior review.
- Documents expected mature-run duration as 5-10 minutes.

v0.1.2:
- Adds Patch 2 hardening for helper reliability after Round 04 pilot-02.
- Defines bundle audit profile contract, `gate_execution_mode`, conditional routing diff requirement, lifecycle scan scope/triage, and compact `returned-output.md` summary.
- Does not add round-level automation or change the Patch 1 same-child-session pattern.
```