cc-codeconductor 1.4.1 → 1.5.0

package/docs/generated/cli.md

@@ -24,6 +24,14 @@ Initialize low-level CodeConductor configuration.
 cc-codeconductor init [--locale en|es]
 ```
 
+## usage
+
+Show installation examples for presets, council, and LSP.
+
+```text
+cc-codeconductor usage
+```
+
 ## install
 
 Install harness components.
@@ -184,6 +192,18 @@ Verify task completion with evidence.
 cc-codeconductor verify --task <id>
 ```
 
+## rdd
+
+Capture and validate Receipt-Driven Development evidence.
+
+```text
+cc-codeconductor rdd capture --task <id> [--phase red|green|review]
+cc-codeconductor rdd verify --receipt <id>
+cc-codeconductor rdd status [--task <id>]
+cc-codeconductor rdd git-check
+cc-codeconductor rdd install-hooks
+```
+
 ## seo
 
 Audit SEO and generate llms.txt.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-codeconductor",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
   "keywords": [
     "ai",

package/presets/agy/AGENTS.md

@@ -472,4 +472,10 @@ When the orchestrator receives a GoalGraph, it delegates tasks in dependency ord
 ### Monorepo Workspaces
 - Focus operations strictly within the specified sub-package or workspace directory in the Task Card scope. Do not modify files or run commands outside this package directory.
 
+## Receipt integrity
+
+- For any implementation, test, review, handoff, or delivery decision, capture or verify the current RDD receipt with `bun run dev rdd`.
+- A receipt is valid only for its exact candidate. If code, tests, contracts, or runner configuration changed, repeat the affected verification.
+- TDD and Mutation Testing retain their existing gates; RDD verifies that their observed evidence still belongs to the current candidate.
+
 <!-- CODECONDUCTOR:END managed -->

package/presets/agy/README.md

@@ -39,7 +39,7 @@ To configure permissions, models, and execution modes for the Antigravity CLI, u
 Recommended settings:
 ```json
 {
-  "model": "gemini-3.5-pro",
+  "model": "gemini-3.8-flash-medium",
   "toolPermission": "request-review",
   "enableTerminalSandbox": true,
   "allowNonWorkspaceAccess": false

package/presets/agy/hooks.json

@@ -17,7 +17,7 @@
     "enabled": true,
     "PreToolUse": [
       {
-        "matcher": "run_command|write_to_file|replace_file_content|multi_replace_file_content",
+        "matcher": "run_command|view_file|write_to_file|replace_file_content|multi_replace_file_content",
         "hooks": [
           {
             "type": "command",

package/presets/agy/scripts/invoke-hook.cjs

@@ -2,8 +2,8 @@
 'use strict';
 
 const { spawnSync } = require('node:child_process');
-const { existsSync } = require('node:fs');
-const { join, resolve } = require('node:path');
+const { existsSync, readFileSync, realpathSync } = require('node:fs');
+const { delimiter, join, resolve } = require('node:path');
 
 const VALID_EVENTS = ['pre-tool', 'post-tool', 'session-start'];
 const SPAWN_TIMEOUT = 10000;
@@ -21,9 +21,10 @@ const isAgy = process.argv.some((a) => a === '--format=agy') || extra.includes('
 function findProjectRoot() {
   const candidates = [
     process.env.PROJECT_ROOT,
+    process.env.CLAUDE_PROJECT_DIR,
     process.env.WORKSPACE_DIR,
-    resolve(__dirname, '..', '..'),
     process.cwd(),
+    resolve(__dirname, '..', '..'),
   ].filter(Boolean);
 
   for (const dir of candidates) {
@@ -40,6 +41,8 @@ function findProjectRoot() {
 }
 
 const projectRoot = findProjectRoot();
+// Buffer once: each fallback attempt must receive the same host payload.
+const input = process.stdin.isTTY ? '' : readFileSync(0, 'utf8');
 
 /**
  * Run one candidate runner. Stdout/stderr are captured (not inherited) so a
@@ -54,7 +57,8 @@ function tryRun(bin, runArgs) {
   try {
     const result = spawnSync(bin, runArgs, {
       cwd: projectRoot,
-      stdio: ['inherit', 'pipe', 'pipe'],
+      stdio: ['pipe', 'pipe', 'pipe'],
+      input,
       windowsHide: true,
       env: process.env,
       encoding: 'utf8',
@@ -111,7 +115,18 @@ try {
     tryRun(process.execPath, [localDist, 'hook', event, ...extra]);
   }
 
-  tryRun('npx', ['--no-install', 'cc-codeconductor', 'hook', event, ...extra]);
+  // Locate global npm installs without invoking npx or Windows .cmd shims.
+  for (const binDir of (process.env.PATH || '').split(delimiter).filter(Boolean)) {
+    const candidates = [
+      join(binDir, 'node_modules', 'cc-codeconductor', 'dist', 'index.js'),
+      join(binDir, '..', 'lib', 'node_modules', 'cc-codeconductor', 'dist', 'index.js'),
+    ];
+    const executable = join(binDir, 'cc-codeconductor');
+    if (existsSync(executable)) candidates.push(realpathSync(executable));
+    for (const candidate of candidates) {
+      if (existsSync(candidate)) tryRun(process.execPath, [candidate, 'hook', event, ...extra]);
+    }
+  }
 } catch {
   // Ignore errors in runner attempts
 }

package/presets/agy/settings.json

@@ -1,5 +1,5 @@
 {
-  "model": "gemini-3.5-pro",
+  "model": "gemini-3.8-flash-medium",
   "toolPermission": "request-review",
   "enableTerminalSandbox": true,
   "allowNonWorkspaceAccess": false,

package/presets/agy/skills/api-versioning/SKILL.md

@@ -0,0 +1,394 @@
+---
+id: api-versioning
+name: api-versioning
+description: >
+  Provides expert knowledge for designing, implementing, and managing REST API
+  versioning strategies with deprecation workflows.
+
+user-invokable: true
+license: MIT
+metadata:
+  author: lgzarturo
+  category: api
+
+compatibility:
+  tools: [claude, codex, gemini, agy, opencode]
+  stacks:
+    languages: [kotlin, java, typescript, python, go]
+    frameworks: [spring-boot, spring-mvc, express, fastapi]
+
+risk:
+  level: high
+  can_execute_shell: false
+  can_modify_files: true
+  requires_network: false
+
+inputs:
+  - source_files
+  - openapi spec files
+  - existing controller classes
+
+outputs:
+  - versioned controller classes
+  - OpenAPI spec updates
+  - deprecation headers
+  - changelog entries
+  - contract test scaffolding
+
+quality:
+  reviewed_by: codeconductor-core
+  version: 0.1.0
+---
+
+# API Versioning
+
+## Versioning Strategies
+
+### URL Path Versioning (recommended for breaking changes)
+
+```text
+GET /api/v1/users
+GET /api/v2/users
+```
+
+Tradeoffs:
+
+- Explicit and visible in logs, proxies, and browser history
+- Easy to cache at the CDN level — the URL uniquely identifies the resource
+  version
+- Easy to route at the load balancer
+- Results in some duplication of controller code
+- Changing the URL violates REST HATEOAS principles, though in practice this is
+  acceptable
+
+Use this when: you have breaking changes and need maximum visibility and
+cacheability.
+
+### Header Versioning
+
+```text
+GET /api/users
+Accept: application/vnd.myapp+json;version=1
+```
+
+Tradeoffs:
+
+- Cleaner URLs
+- Harder to test manually — browsers and curl require extra flags
+- Cannot be bookmarked or linked directly
+- CDN caching requires `Vary: Accept` header, which reduces cache hit rates
+
+Use this when: you need clean URLs and your clients are all programmatic (no
+browsers).
+
+### Query Parameter Versioning (avoid)
+
+```text
+GET /api/users?version=1
+```
+
+This approach contaminates resource URLs with transport concerns. The version is
+not part of the resource identity. Do not use it. The only valid exception is
+temporary backward-compat support during a migration window.
+
+## When to Version
+
+Version when the change is breaking. Not every change requires a version bump.
+
+**Breaking — requires new version:**
+
+- Removing a field from a response
+- Renaming a field
+- Changing a field's type (e.g., `string` to `object`)
+- Changing the meaning of an existing field
+- Removing an endpoint
+- Changing required fields in a request
+- Changing status codes in a non-additive way
+
+**Not breaking — no version bump needed:**
+
+- Adding an optional field to a response
+- Adding a new endpoint
+- Adding an optional request parameter
+- Deprecating a field (marking it, but still returning it)
+- Performance improvements
+- Bug fixes that restore documented behavior
+
+## Deprecation Process
+
+When a version or endpoint is being phased out, follow this process:
+
+**Step 1: Mark in OpenAPI.**
+
+```yaml
+paths:
+  /api/v1/users/{id}:
+    get:
+      deprecated: true
+      description: |
+        Deprecated since 2026-05-07. Use /api/v2/users/{id} instead.
+        Sunset date: 2026-11-07.
+      summary: Get user by ID (deprecated)
+```
+
+**Step 2: Add deprecation headers to responses.**
+
+```kotlin
+@GetMapping("/{id}")
+fun getUserV1(@PathVariable id: UUID, response: HttpServletResponse): ResponseEntity<UserV1Response> {
+    response.addHeader("Deprecation", "date=\"Wed, 07 May 2026 00:00:00 GMT\"")
+    response.addHeader("Sunset", "Mon, 07 Nov 2026 00:00:00 GMT")
+    response.addHeader("Link", "</api/v2/users/$id>; rel=\"successor-version\"")
+    return ResponseEntity.ok(userService.getById(id).toV1Response())
+}
+```
+
+**Step 3: Document in CHANGELOG.**
+
+```markdown
+## Deprecated
+
+- `GET /api/v1/users/{id}` — deprecated in favor of `GET /api/v2/users/{id}`.
+  Sunset: 2026-11-07.
+```
+
+**Step 4: Maintain dual support.**
+
+Keep at least two active major versions at all times. When v3 ships, v1 can be
+removed (v2 and v3 remain active).
+
+**Step 5: Communicate the sunset date.**
+
+Notify consumers before the sunset date through:
+
+- API changelog
+- Developer portal announcements
+- Deprecation headers (machine-readable)
+- Direct contact if you have consumer registration data
+
+Do not remove a version without a minimum 6-month notice period. 3 months is the
+absolute minimum if forced.
+
+## OpenAPI Conventions
+
+### One file per version (simple cases)
+
+```text
+openapi-v1.yaml
+openapi-v2.yaml
+```
+
+Each file is self-contained and independently valid.
+
+### Single file with version in info (evolving APIs)
+
+```yaml
+openapi: '3.1.0'
+info:
+  title: Users API
+  version: '2.0.0'
+```
+
+Use `$ref` to share schemas across versions without duplication.
+
+### Cross-version schema reuse
+
+```yaml
+# schemas/user-base.yaml
+UserBase:
+  type: object
+  properties:
+    id:
+      type: string
+      format: uuid
+    email:
+      type: string
+
+# openapi-v1.yaml
+components:
+  schemas:
+    UserResponse:
+      allOf:
+        - $ref: './schemas/user-base.yaml#/UserBase'
+        - properties:
+            full_name:
+              type: string
+
+# openapi-v2.yaml — splits full_name into first_name + last_name
+components:
+  schemas:
+    UserResponse:
+      allOf:
+        - $ref: './schemas/user-base.yaml#/UserBase'
+        - properties:
+            first_name:
+              type: string
+            last_name:
+              type: string
+```
+
+### Documenting breaking changes
+
+Put the breaking change in the endpoint description, not just in a changelog:
+
+```yaml
+/api/v2/users/{id}:
+  get:
+    description: |
+      Returns user details.
+
+      Breaking changes from v1:
+      - `full_name` has been replaced by `first_name` and `last_name`
+```
+
+## Spring Boot Implementation
+
+### URL path versioning
+
+```kotlin
+// V1 controller — never modify once published
+@RestController
+@RequestMapping("/api/v1/users")
+class UserV1Controller(private val userService: UserService) {
+
+    @GetMapping("/{id}")
+    @Deprecated("Use /api/v2/users/{id}", ReplaceWith("UserV2Controller.getUser()"))
+    fun getUser(
+        @PathVariable id: UUID,
+        response: HttpServletResponse
+    ): ResponseEntity<UserV1Response> {
+        response.addHeader("Deprecation", "date=\"Wed, 07 May 2026 00:00:00 GMT\"")
+        response.addHeader("Sunset", "Mon, 07 Nov 2026 00:00:00 GMT")
+        return when (val result = userService.getById(id)) {
+            is UserResult.Found -> ResponseEntity.ok(result.user.toV1Response())
+            is UserResult.NotFound -> ResponseEntity.notFound().build()
+        }
+    }
+}
+
+// V2 controller — new version, new controller, shared service
+@RestController
+@RequestMapping("/api/v2/users")
+class UserV2Controller(private val userService: UserService) {
+
+    @GetMapping("/{id}")
+    fun getUser(@PathVariable id: UUID): ResponseEntity<UserV2Response> {
+        return when (val result = userService.getById(id)) {
+            is UserResult.Found -> ResponseEntity.ok(result.user.toV2Response())
+            is UserResult.NotFound -> ResponseEntity.notFound().build()
+        }
+    }
+}
+```
+
+Rules:
+
+- Create a new controller for each new version — do not modify the existing one
+- The service layer is shared across versions — only the controller and DTO
+  change
+- DTO mapper functions are version-specific: `toV1Response()`, `toV2Response()`
+- Never delete a versioned controller until after the sunset date
+
+### DTO versioning
+
+```kotlin
+// V1 — original shape
+data class UserV1Response(
+    val id: UUID,
+    val email: String,
+    val full_name: String
+)
+
+// V2 — breaking change: split full_name
+data class UserV2Response(
+    val id: UUID,
+    val email: String,
+    val first_name: String,
+    val last_name: String
+)
+
+// Extension functions for mapping
+fun User.toV1Response(): UserV1Response = UserV1Response(
+    id = id,
+    email = email,
+    full_name = "$firstName $lastName"
+)
+
+fun User.toV2Response(): UserV2Response = UserV2Response(
+    id = id,
+    email = email,
+    first_name = firstName,
+    last_name = lastName
+)
+```
+
+## Contract Testing
+
+Contract tests verify that your API does not break existing consumers before
+changes reach production.
+
+**When to run:** in CI, before merging any change that touches a controller,
+DTO, or OpenAPI spec.
+
+**Tool: Pact (consumer-driven contracts)**
+
+Consumer writes a pact:
+
+```kotlin
+// In the consumer service test
+@ExtendWith(PactConsumerTestExt::class)
+class UserServiceConsumerTest {
+
+    @Pact(consumer = "order-service", provider = "user-service")
+    fun getUserPact(builder: PactDslWithProvider): RequestResponsePact {
+        return builder
+            .given("user with id exists")
+            .uponReceiving("a request for user by id")
+            .path("/api/v1/users/123e4567-e89b-12d3-a456-426614174000")
+            .method("GET")
+            .willRespondWith()
+            .status(200)
+            .body(LambdaDsl.newJsonBody { body ->
+                body.uuid("id")
+                body.stringType("email")
+                body.stringType("full_name")
+            }.build())
+            .toPact()
+    }
+}
+```
+
+Provider verifies the pact:
+
+```kotlin
+@Provider("user-service")
+@PactFolder("pacts")
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class UserServiceProviderTest {
+
+    @TestTarget
+    lateinit var target: HttpTestTarget
+
+    @BeforeEach
+    fun setUp(@LocalServerPort port: Int) {
+        target = HttpTestTarget("localhost", port)
+    }
+}
+```
+
+**Rule:** run contract tests in CI before any merge that touches an API surface.
+A broken contract test means a consumer will break in production.
+
+## Test Structure Per Version
+
+Each API version must have its own test class:
+
+```text
+src/test/kotlin/{package}/user/
+  controller/
+    UserV1ControllerTest.kt   # tests for v1 endpoints
+    UserV2ControllerTest.kt   # tests for v2 endpoints
+```
+
+Do not share test cases across versions. V1 behavior must be tested
+independently from V2 — they can diverge.