cc-codeconductor 0.2.1

package/presets/opencode/commands/cc-feature.md

@@ -0,0 +1,114 @@
+---
+description:
+  Run the full feature workflow — task validation, technical design,
+  implementation, testing, review, and documentation.
+---
+
+# Feature Workflow
+
+Feature request: $ARGUMENTS
+
+## Step 1 — Task Card validation (task-coach)
+
+Invoke `task-coach` with the feature description above.
+
+task-coach must produce a complete Task Card before any other agent runs. The
+Task Card is ready when it contains: title, type, risk classification, scope,
+context, acceptance criteria, and constraints.
+
+If any field is missing or ambiguous, task-coach must ask one clarifying
+question at a time and wait for the answer. Do not proceed with an incomplete
+Task Card.
+
+**STOP here. Show the completed Task Card and wait for human confirmation before
+continuing.**
+
+---
+
+## Step 2 — Technical Plan (architect)
+
+Invoke `architect` with the validated Task Card from Step 1.
+
+architect must produce a Technical Plan that covers:
+
+- Chosen approach and rationale
+- Affected files and modules
+- Data model changes (if any)
+- API contract changes (if any)
+- Identified risks and mitigations
+- Open questions that require a human decision
+
+**STOP here. Show the Technical Plan and wait for explicit human approval. Do
+not invoke implementer until the plan is approved.**
+
+---
+
+## Step 3 — Implementation (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:
+
+1. Read the Technical Plan before touching any file
+2. Apply the minimal diff — only what the plan specifies
+3. Run the project test suite after implementation
+4. Produce an Implementation Summary: what changed, which files, how to verify
+   locally
+
+---
+
+## Step 4 — Test coverage (tester)
+
+Invoke `tester` with the Implementation Summary and the Task Card.
+
+tester must:
+
+1. Write or extend tests to cover the new behavior
+2. Ensure all acceptance criteria from the Task Card have at least one test
+3. Run the full test suite and confirm it passes
+4. Produce a Coverage Summary: test files added or modified, cases covered
+
+---
+
+## Step 5 — Code review (reviewer)
+
+Invoke `reviewer` with the complete diff and the Task Card.
+
+reviewer must produce a Review Report with findings categorized as:
+
+- CRITICAL — must be fixed before merge
+- WARNING — must be resolved before merge
+- SUGGESTION — optional improvement
+
+If any CRITICAL findings exist, **STOP and report them**. Do not proceed until
+they are resolved and re-reviewed.
+
+---
+
+## Step 6 — Documentation (docs)
+
+Invoke `docs` only if any of the following changed:
+
+- A public API endpoint was added or modified
+- A public interface or module was introduced
+- Behavior visible to end users changed
+
+docs must update: README (if applicable), OpenAPI spec (if applicable),
+CHANGELOG (always), ADR (if an architectural decision was made).
+
+---
+
+## Completion
+
+Report the following to the human:
+
+- Task Card (final)
+- Technical Plan (approved)
+- Implementation Summary
+- Coverage Summary
+- Review Report (all findings resolved)
+- List of documentation files updated (if any)
+
+The feature is complete only when: all tests pass, no CRITICAL review findings
+remain, and documentation reflects the implemented behavior.

package/presets/opencode/commands/cc-fix.md

@@ -0,0 +1,123 @@
+---
+description:
+  Run the bug fix workflow — risk-based routing through task validation,
+  implementation, testing, and optional review.
+---
+
+# Bug Fix Workflow
+
+Bug description: $ARGUMENTS
+
+Provide the following information in $ARGUMENTS:
+
+- What is the incorrect behavior (actual)
+- What is the expected behavior
+- Steps to reproduce
+- Environment or version where the bug occurs (if known)
+- Any relevant error messages or stack traces
+
+---
+
+## Step 1 — Task Card validation (task-coach)
+
+Invoke `task-coach` with the bug description above.
+
+task-coach must produce a Task Card that includes:
+
+- A clear statement of actual vs. expected behavior
+- Reproduction steps (or a note that they are unknown)
+- Risk classification: `low`, `medium`, or `high`
+- Scope: which files or modules are likely affected
+
+If reproduction steps are missing, task-coach must ask for them before
+classifying risk. A bug without a reproduction path cannot be classified
+reliably.
+
+**STOP here. Show the Task Card and wait for human confirmation.**
+
+---
+
+## Step 2 — Route by risk
+
+Read the risk field from the Task Card and follow the corresponding route.
+
+### Low-risk route
+
+Applies when: the bug is isolated to a single component, existing tests cover
+the affected code, and no public API or shared state is involved.
+
+Route: `task-coach` → `implementer` → `tester`
+
+Proceed directly to Step 3a.
+
+### Medium or high-risk route
+
+Applies when: the bug touches shared state, a public API, auth or payment paths,
+database writes, or the root cause is not yet understood.
+
+Route: `task-coach` → `architect` → `implementer` → `tester` → `reviewer`
+
+Invoke `architect` before implementation. architect must:
+
+- Identify the root cause (or document that it is unknown)
+- Define the fix approach and affected files
+- Flag any regression risk to adjacent components
+- Produce a Technical Plan
+
+**STOP here if high-risk. Show the Technical Plan and wait for human approval
+before continuing.**
+
+---
+
+## Step 3a — 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. Locate the defect using the reproduction steps
+2. Apply the minimal fix — no unrelated changes
+3. Run the test suite
+4. Produce an Implementation Summary: root cause, fix applied, files changed
+
+---
+
+## Step 3b — 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.
+
+---
+
+## Step 4 — Regression tests (tester)
+
+Invoke `tester` for all risk levels.
+
+tester must:
+
+1. Write a regression test that reproduces the original bug (fails before the
+   fix, passes after)
+2. Verify that existing tests still pass
+3. Produce a Coverage Summary: test added, case covered
+
+---
+
+## Step 5 — Review (reviewer) — medium/high-risk only
+
+Invoke `reviewer` with the diff and Task Card.
+
+reviewer produces a Review Report with CRITICAL / WARNING / SUGGESTION findings.
+If any CRITICAL findings exist, **STOP**. Do not close the fix until they are
+resolved.
+
+---
+
+## Completion
+
+Report: Task Card, Implementation Summary, regression test added, Review Report
+(if applicable). The fix is complete only when: the regression test passes, the
+full suite passes, and no CRITICAL review findings remain.

package/presets/opencode/commands/cc-refactor.md

@@ -0,0 +1,148 @@
+---
+description:
+  Run the refactor workflow — mandatory architectural justification, test
+  verification, risk-based implementation, and scope enforcement.
+---
+
+# Refactor Workflow
+
+Refactor description: $ARGUMENTS
+
+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 agent is invoked, 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 to the human.
+2. Suggest invoking `/cc:test-plan` first to establish coverage.
+3. Do not proceed with the refactor until coverage is confirmed.
+
+---
+
+## Step 1 — Architectural justification (architect)
+
+Always invoke `architect` first, regardless of risk level. A refactor without a
+written justification is scope creep in disguise.
+
+architect must 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 architect identifies unrelated
+improvements, they must be listed 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)
+
+Invoke `implementer` with the approved Refactor Plan.
+Implementer creates a Git Worktree before touching any file; all edits happen inside it.
+
+implementer must:
+
+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)
+
+Same rules as 3a. Additionally:
+
+- implementer must document any unexpected complexity discovered during
+  implementation and pause if the complexity changes the risk assessment
+- If new risks are found, **STOP** and report to the human 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) — medium/high-risk only
+
+Invoke `reviewer` with the diff and Refactor Plan.
+
+reviewer must 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/opencode/commands/cc-review.md

@@ -0,0 +1,141 @@
+---
+description:
+  Run a structured code review — produces a Review Report with CRITICAL,
+  WARNING, and SUGGESTION findings; CRITICAL findings block merge.
+---
+
+# Code Review Workflow
+
+Review target: $ARGUMENTS
+
+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 1 — Diff collection
+
+Before invoking `reviewer`, collect the diff for the specified target.
+
+If $ARGUMENTS is empty or not provided:
+
+- Use `git diff HEAD` as the review target
+
+If $ARGUMENTS is a branch name:
+
+- Use `git diff main...$ARGUMENTS` (or `develop` if main is not the base)
+
+If $ARGUMENTS is a PR reference:
+
+- Retrieve the PR diff and the PR description for context
+
+If $ARGUMENTS is a file path:
+
+- Use `git diff HEAD -- $ARGUMENTS`
+
+Show the diff summary (files changed, lines added/removed) before invoking
+reviewer.
+
+---
+
+## Step 2 — Code review (reviewer)
+
+Invoke `reviewer` with:
+
+- The full diff
+- The Task Card or PR description (if available)
+- The target specification from $ARGUMENTS
+
+reviewer must 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^2) 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
+
+reviewer produces a structured Review Report with findings in three categories:
+
+```markdown
+## Review Report
+
+### CRITICAL
+
+[Findings that must be fixed before merge. Each finding includes:
+
+- Location (file:line)
+- Description of the problem
+- Suggested resolution]
+
+### WARNING
+
+[Findings that should be resolved before merge but are not blockers in
+exceptional cases with human approval. 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 to the human
+- Do not proceed until each CRITICAL finding is resolved
+- After resolution, invoke `/cc: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. Every
+finding must include a location and an actionable description.