cc-codeconductor 1.1.0 → 1.2.0

package/presets/gemini/commands/cc/refactor.toml

@@ -0,0 +1,158 @@
+description = "test verification, risk-based implementation, and scope enforcement."
+
+prompt = """
+# Refactor Workflow
+
+Refactor description: {{args}}
+
+Describe what you want to refactor and why. Include:
+
+- The current structure or pattern being changed
+- The target structure or pattern
+- The motivation (performance, readability, architectural alignment, etc.)
+- Known risk areas or dependencies
+
+---
+
+## Prerequisite — Test coverage check
+
+Before any role is adopted, verify that the code being refactored has adequate
+test coverage.
+
+A refactor without tests is not a refactor — it is a rewrite with unknown
+behavioral consequences.
+
+If coverage is insufficient:
+
+1. **STOP**. Report the coverage gap.
+2. Suggest running `/test-plan` first to establish coverage.
+3. Do not proceed with the refactor until coverage is confirmed.
+
+---
+
+## Step 0 — CCEP Bootstrap
+
+Command: `refactor` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command refactor "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command refactor "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile refactor --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command refactor --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+
+---
+
+## Step 1 — Architectural justification (Architect role)
+
+Invoke the `architect` subagent via the Task tool. Always invoke this step
+first, regardless of risk level. A refactor without a written justification is
+scope creep in disguise.
+
+Produce a Refactor Plan that includes:
+
+- Statement of the problem with the current structure
+- Proposed target structure and rationale
+- Affected files and module boundaries
+- Risk level: `low`, `medium`, or `high`
+- Behavioral invariants that must not change
+- Open questions requiring human input
+
+**Scope creep warning:** If during planning you identify unrelated improvements,
+list them separately as "Out of scope." They are not part of this refactor.
+
+**STOP here. Show the Refactor Plan and wait for explicit human approval. Do not
+proceed without written approval of the plan.**
+
+---
+
+## Step 2 — Route by risk
+
+Read the risk field from the Refactor Plan and follow the corresponding route.
+
+### Low-risk route
+
+Applies when: the refactor is purely internal, no public interfaces change, full
+test coverage exists for the affected code, and behavioral impact is isolated to
+the refactored module.
+
+Route: Architect (done) → Implementer
+
+Proceed to Step 3a.
+
+### Medium or high-risk route
+
+Applies when: module boundaries change, shared interfaces are affected,
+performance characteristics may change, or the refactor touches more than two
+files with behavioral impact.
+
+Route: Architect (done) → Implementer → Reviewer
+
+Proceed to Step 3b.
+
+---
+
+## Step 3a — Implementation, low-risk (Implementer role)
+
+Invoke the `implementer` subagent via the Task tool. Use the approved
+Refactor Plan.
+Implementer creates a Git Worktree before touching any file; all edits happen inside it.
+
+1. Read the Refactor Plan before opening any file.
+2. Apply only the changes specified in the plan.
+3. Run the full test suite before and after — both runs must pass.
+4. Produce an Implementation Summary: what changed, what did not change, test
+   results before and after.
+
+Any deviation from the plan — including "obvious improvements" encountered
+during implementation — must be flagged and held for a separate task.
+
+---
+
+## Step 3b — Implementation, medium/high-risk (Implementer role)
+
+Same rules as Step 3a. Additionally:
+
+- Document any unexpected complexity discovered during implementation.
+- Pause and report if complexity changes the risk assessment.
+- If new risks are found, **STOP** and report before continuing.
+
+---
+
+## Step 4 — Test suite verification
+
+For all risk levels, confirm:
+
+- All tests that existed before the refactor still pass.
+- No test was deleted or commented out to make the suite pass.
+- Behavior documented in the Task Card remains unchanged.
+
+If any test fails that was passing before, the refactor has introduced a
+regression. **STOP and report.**
+
+---
+
+## Step 5 — Code review (Reviewer role) — medium/high-risk only
+
+Invoke the `reviewer` subagent via the Task tool. Use the diff and Refactor
+Plan.
+
+Verify:
+
+- The implementation matches the approved plan.
+- No behavior was changed beyond the plan's scope.
+- No unrelated files were modified.
+
+Review Report must include CRITICAL / WARNING / SUGGESTION findings. CRITICAL
+findings block completion.
+
+---
+
+## Completion
+
+Report: Refactor Plan (approved), Implementation Summary, test results before
+and after, Review Report (if applicable).
+
+The refactor is complete only when: all pre-existing tests still pass, the
+implementation matches the approved plan exactly, and no CRITICAL review
+findings remain.
+"""

package/presets/gemini/commands/cc/review.toml

@@ -0,0 +1,150 @@
+description = "CRITICAL, WARNING, and SUGGESTION findings; CRITICAL findings block merge."
+
+prompt = """
+# Code Review Workflow
+
+Review target: {{args}}
+
+Specify what to review. Accepted formats:
+
+- A branch name: `feature/my-branch`
+- A file or set of files: `src/api/UserController.kt`
+- A pull request reference: `PR #42`
+- Empty — defaults to the current working diff (`git diff`)
+
+---
+
+## Step 0 — CCEP Bootstrap
+
+Command: `review` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command review "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command review "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile review --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command review --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+
+---
+
+## Step 1 — Diff collection
+
+Before adopting the Reviewer role, collect the diff for the specified target.
+
+If {{args}} is empty or not provided:
+
+- Use `git diff HEAD` as the review target.
+
+If {{args}} is a branch name:
+
+- Use `git diff main...{{args}}` (or `develop` if main is not the base).
+
+If {{args}} is a PR reference:
+
+- Retrieve the PR diff and the PR description for context.
+
+If {{args}} is a file path:
+
+- Use `git diff HEAD -- {{args}}`.
+
+Show the diff summary (files changed, lines added/removed) before proceeding.
+
+---
+
+## Step 2 — Code review (Reviewer role)
+
+Invoke the `reviewer` subagent via the Task tool.
+
+Evaluate the diff against the following checklist:
+
+**Correctness**
+
+- Does the implementation match the stated intent?
+- Are there logic errors, off-by-one errors, or unhandled edge cases?
+
+**Architecture alignment**
+
+- Does the change follow existing module boundaries?
+- Does it introduce unplanned coupling or layering violations?
+
+**Security**
+
+- Are inputs validated before use?
+- Is there any credential, token, or secret in the diff?
+- Are there SQL injection, XSS, or injection risks?
+
+**Performance**
+
+- Does the change introduce N+1 queries, blocking I/O, or O(n²) loops?
+
+**Test coverage**
+
+- Do tests exist for the new or changed behavior?
+- Are assertions meaningful (not just checking that no exception is thrown)?
+
+**Documentation**
+
+- Are public interfaces documented?
+- Is CHANGELOG updated if behavior changed?
+
+---
+
+## Step 3 — Review Report
+
+Produce a structured Review Report with findings in three categories:
+
+```markdown
+## Review Report
+
+### CRITICAL
+[Findings that must be fixed before merge — file:line, description, suggested resolution]
+
+### WARNING
+[Findings that should be resolved before merge — same format as CRITICAL]
+
+### SUGGESTION
+[Optional improvements — style, readability, future-proofing. These do not block merge.]
+
+### Summary
+- Files reviewed: N
+- Total findings: N (X critical, Y warnings, Z suggestions)
+- Merge recommendation: APPROVED | BLOCKED
+```
+
+---
+
+## Step 4 — Merge decision
+
+If any CRITICAL findings exist:
+
+- The Review Report status is **BLOCKED**.
+- Report all CRITICAL findings.
+- Do not proceed until each CRITICAL finding is resolved.
+- After resolution, run `/review` again on the same target.
+
+If no CRITICAL findings exist:
+
+- The Review Report status is **APPROVED**.
+- Report any WARNINGs and SUGGESTIONs for human awareness.
+- The human makes the final merge decision.
+
+---
+
+## Completion
+
+Deliver the complete Review Report. Never summarize or omit findings.
+
+---
+
+## Step 5 — Scorecard and outcome
+
+```bash
+npx cc-codeconductor scorecard create --from-diff --agent reviewer
+npx cc-codeconductor scorecard record --verdict PASS|REVISE|REJECT --score <weighted>
+npx cc-codeconductor scorecard regression
+```
+
+Map merge recommendation to scorecard verdict. Record outcome for trend tracking.
+
+Skills: `evaluation`. Handmade TDD JSON is rejected. Run `scorecard suite-run`
+or `scorecard record` before declaring the review closed.
+"""

package/presets/gemini/commands/cc/scorecard.toml

@@ -0,0 +1,77 @@
+description = "checklist, and aggregate stats."
+
+prompt = """
+# Scorecard Evaluation Workflow
+
+Scope: {{args}}
+
+---
+
+## Step 0 — CCEP Bootstrap
+
+Command: `scorecard` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command scorecard "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command scorecard "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile scorecard --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command scorecard --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+
+---
+
+## Step 1 — Identify task
+
+Use `{{args}}` as task id (e.g. `BC-001`) or read active item from `npx cc-codeconductor openspec status`.
+
+If a change folder exists, run `npx cc-codeconductor openspec analyze --output json` first. `--from-diff` overlays FR/SC coverage onto `acceptance` and TDD evidence onto `tests`.
+
+---
+
+## Step 2 — Create scorecard with auto-signals
+
+```bash
+npx cc-codeconductor scorecard create --task <id> --agent reviewer --from-diff
+```
+
+Review auto-suggested criteria (minimal diff, cc-gain). Complete remaining scores 0–3 per [`docs/agent-scorecard.md`](docs/agent-scorecard.md).
+
+---
+
+## Step 3 — Regression (optional)
+
+```bash
+npx cc-codeconductor scorecard regression
+```
+
+If required checks fail, **STOP** and report failures.
+
+---
+
+## Step 4 — Record outcome
+
+```bash
+npx cc-codeconductor scorecard record --task <id> --agent reviewer --model <model> --verdict PASS --score 2.5
+```
+
+Include `--cost` and `--tokens` when available from session metrics.
+
+---
+
+## Step 5 — Aggregate
+
+```bash
+npx cc-codeconductor scorecard aggregate
+```
+
+Report pass rate and average weighted score.
+
+---
+
+## Routing on verdict
+
+- **PASS** — accept deliverable; update backlog if applicable
+- **REVISE** — return to implementer/tester with findings
+- **REJECT** — route to task-coach for re-scoping
+
+Apply skill `evaluation`.
+"""

package/presets/gemini/commands/cc/security.toml

@@ -0,0 +1,177 @@
+description = "security-* skills, authorization gate, risk-based routing, hardening, and review."
+
+prompt = """
+# Defensive Security Workflow
+
+Security objective: {{args}}
+
+Provide the following information in {{args}}:
+
+- What must be reviewed or hardened, and why
+- Domain: a `security-*` skill id (recon, vuln-assessment, web, cloud, IR,
+  hunting, GRC, …) or `web-app` / `api` / `cloud-config` /
+  `dependency-supply-chain` / `secrets`
+- Authorization: who authorized this work on this target, and the scope boundary
+- Risk classification (`low`, `medium`, or `high`), if known
+- Scope: which files, modules, repos, or environments are in and out of bounds
+
+---
+
+## Scope and authorization
+
+This workflow performs **authorized defensive security work only**: threat
+modeling, hardening, secure configuration, dependency and supply-chain review,
+secret hygiene, and detection coverage.
+
+Refuse outright and offer the defensive equivalent instead (threat model,
+hardening, detection coverage, dependency audit):
+
+- Exploit or proof-of-concept development
+- Malware authoring, or malware analysis intended for reuse
+- Reverse engineering aimed at bypassing a control
+- Red-team playbooks
+- Any unauthorized-access procedure
+
+Scope is limited to the repository under analysis. Do not scan, probe, or
+perform reconnaissance against third-party hosts.
+
+Do not proceed without an authorization statement. Do not produce exploit
+payloads, malware, or attack procedures.
+
+---
+
+## Step 0 — CCEP Bootstrap
+
+Command: `security` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command security "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command security "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile security --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command security --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
+## Step 1 — Wayfinding (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "{{args}}"` (and
+`graphify path` / `graphify explain` when needed). Then invoke `repo-explorer`
+to map modules, conventions, and impact radius. Do not write code in this step.
+Record a Repo Map artifact before intake. Load the matching `security-*` skill
+for the named domain (see `.claude/skills/security-*/SKILL.md`). Keep the OWASP
+`security` skill for application-security reviews.
+
+---
+
+## Step 2 — Task Card validation (task-coach)
+
+Invoke `task-coach` with the security objective above.
+
+task-coach must produce a Task Card that includes:
+
+- Objective: what must be reviewed or hardened, in one sentence
+- Domain: which `security-*` skill applies, or `web-app` / `api` /
+  `cloud-config` / `dependency-supply-chain` / `secrets`
+- Authorization: who authorized this work on this target, and the scope boundary
+- Risk classification: `low`, `medium`, or `high`
+- Scope: which files or modules are likely affected
+
+If authorization is absent, unclear, or names a system the requester does not
+own or operate, **STOP and refuse. Do not route the task.**
+
+Redact secrets, tokens, and credentials from any evidence before it enters the
+Task Card. Summarize logs; do not paste env files.
+
+**STOP here. Show the Task Card and wait for human confirmation.**
+
+---
+
+## Step 3 — Route by risk
+
+Read the risk field from the Task Card and follow the corresponding route.
+
+### Low-risk route
+
+Applies when: the weakness is isolated, not exploitable in the current
+configuration, and no authentication, secret, or dependency boundary is
+involved.
+
+Route: `task-coach` → `tester` → `implementer`
+
+Proceed directly to Step 4 (tests), then Step 5a.
+
+### Medium or high-risk route
+
+Applies when: the work touches authentication, authorization, secrets,
+cryptography, trust-boundary input validation, or a dependency upgrade.
+
+Route: `task-coach` → `architect` → `tester` → `implementer` → `reviewer`
+
+Invoke `architect` before implementation. architect must:
+
+- Identify the weakness and the affected trust boundary
+- Define the hardening approach and affected files
+- Flag any regression risk to adjacent components
+- Produce a Technical Plan
+
+On **high** risk, also invoke `security-reviewer` before Reviewer.
+
+**STOP here if high-risk. Show the Technical Plan and wait for human approval
+before continuing.**
+
+---
+
+## Step 4 — Tests (tester)
+
+Invoke `tester` for all risk levels.
+
+tester must:
+
+1. Write a regression test that proves the weakness exists and confirm it fails
+   before any change (RED)
+2. Verify that existing tests still pass
+3. Produce a Coverage Summary: test added, case covered
+
+---
+
+## Step 5a — Implementation, low-risk (implementer)
+
+Invoke `implementer` with the Task Card.
+Implementer creates a Git Worktree before touching any file; all edits happen inside it.
+
+implementer must:
+
+1. Apply the minimal hardening change — no unrelated changes
+2. Run the suite and make the RED regression test pass
+3. Produce an Implementation Summary: weakness, change applied, files changed
+
+---
+
+## Step 5b — Implementation, medium/high-risk (implementer)
+
+Invoke `implementer` with the approved Technical Plan and the Task Card.
+Implementer creates a Git Worktree before touching any file; all edits happen inside it.
+
+implementer must follow the plan exactly. Any deviation requires a new Technical
+Plan approval. After implementation, run the full test suite. No exploit code.
+
+---
+
+## Step 6 — Review (Reviewer role) — medium/high-risk only
+
+Invoke `reviewer` with the diff and Task Card. The Reviewer must apply the OWASP
+rules in the `security` skill.
+
+reviewer produces a Review Report with CRITICAL / WARNING / SUGGESTION findings.
+If any CRITICAL findings exist, **STOP**. Do not close the task until they are
+resolved.
+
+---
+
+## Completion
+
+Report: Task Card, Implementation Summary, regression test added, Review Report
+(if applicable). The task is complete only when: the regression test passes, the
+full suite passes, and no CRITICAL review findings remain.
+"""