@delegance/claude-autopilot 5.0.2 → 5.0.4

package/dist/src/adapters/council/openai.js

@@ -3,6 +3,16 @@ import { GuardrailError } from "../../core/errors.js";
 import { classifyError } from "../review-engine/prompt-builder.js";
 const SYSTEM_PROMPT = `You are a technical advisor reviewing a software design decision. Evaluate the provided context and question critically. Be direct and specific. Surface tradeoffs, risks, and your recommendation.`;
 const MAX_OUTPUT_TOKENS = 2048;
+// Models that ONLY work via the Responses API (not chat.completions).
+// Codex variants and the o-series reasoning models all 404 on chat.completions.
+// Without this branch, putting `gpt-5.3-codex` (the typical default) in
+// council.models throws model_not_found, AND the synthesizer (also typically
+// gpt-5.3-codex) fails the same way — so the whole council returns `partial`
+// with no synthesis. That regression made the marketed multi-model differentiator
+// unusable for any user who only had OPENAI_API_KEY.
+function isResponsesOnlyModel(model) {
+    return /codex|^o[1-9]|^gpt-5\.3-/i.test(model);
+}
 export function makeOpenAICouncilAdapter(model, label) {
     return {
         label,
@@ -12,27 +22,36 @@ export function makeOpenAICouncilAdapter(model, label) {
                 throw new GuardrailError('OPENAI_API_KEY not set', { code: 'auth', provider: 'openai' });
             }
             const client = new OpenAI({ apiKey });
-            let response;
+            const userInput = `## Context\n\n${context}\n\n## Question\n\n${prompt}`;
             try {
-                response = await client.chat.completions.create({
+                if (isResponsesOnlyModel(model)) {
+                    const response = await client.responses.create({
+                        model,
+                        instructions: SYSTEM_PROMPT,
+                        input: userInput,
+                        max_output_tokens: MAX_OUTPUT_TOKENS,
+                    });
+                    return response.output_text ?? '';
+                }
+                const response = await client.chat.completions.create({
                     model,
                     max_tokens: MAX_OUTPUT_TOKENS,
                     messages: [
                         { role: 'system', content: SYSTEM_PROMPT },
-                        { role: 'user', content: `## Context\n\n${context}\n\n## Question\n\n${prompt}` },
+                        { role: 'user', content: userInput },
                     ],
                 });
+                return response.choices[0]?.message?.content ?? '';
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 const code = classifyError(message);
-                throw new GuardrailError(`OpenAI council call failed: ${message}`, {
+                throw new GuardrailError(`OpenAI council call failed (model=${model}): ${message}`, {
                     code,
                     provider: 'openai',
                     retryable: code === 'rate_limit',
                 });
             }
-            return response.choices[0]?.message?.content ?? '';
         },
     };
 }

package/dist/src/adapters/review-engine/codex.js

@@ -4,6 +4,12 @@ import { GuardrailError } from "../../core/errors.js";
 import { buildSystemPrompt, classifyError } from "./prompt-builder.js";
 const DEFAULT_MODEL = process.env.CODEX_MODEL ?? 'gpt-5.3-codex';
 const MAX_OUTPUT_TOKENS = 4096;
+// Per-million-token rates for gpt-5.3-codex (override via env for other models).
+// Computed client-side because the OpenAI Responses API returns token counts
+// but no $-cost field. Without this, every codex run logged costUSD=0 even
+// though tokens were tracked correctly.
+const COST_PER_M_INPUT = Number(process.env.CODEX_COST_INPUT_PER_M ?? 1.25);
+const COST_PER_M_OUTPUT = Number(process.env.CODEX_COST_OUTPUT_PER_M ?? 10.0);
 const SYSTEM_PROMPT_TEMPLATE = `You are a senior software architect providing feedback on designs, proposals, and ideas.
 
 The codebase context:
@@ -62,10 +68,16 @@ export const codexAdapter = {
             });
         }
         const rawOutput = response.output_text ?? '';
+        const costUSD = response.usage
+            ? (response.usage.input_tokens / 1_000_000) * COST_PER_M_INPUT +
+                (response.usage.output_tokens / 1_000_000) * COST_PER_M_OUTPUT
+            : undefined;
         return {
             findings: parseReviewOutput(rawOutput, 'codex'),
             rawOutput,
-            usage: response.usage ? { input: response.usage.input_tokens, output: response.usage.output_tokens } : undefined,
+            usage: response.usage
+                ? { input: response.usage.input_tokens, output: response.usage.output_tokens, costUSD }
+                : undefined,
         };
     },
 };

package/dist/src/cli/scan.js

@@ -6,6 +6,7 @@ import { runReviewPhase } from "../core/pipeline/review-phase.js";
 import { detectStack } from "../core/detect/stack.js";
 import { loadIgnoreRules, parseConfigIgnore, applyIgnoreRules } from "../core/ignore/index.js";
 import { saveCachedFindings } from "../core/persist/findings-cache.js";
+import { appendCostLog } from "../core/persist/cost-log.js";
 import { detectLLMKey, LLM_KEY_HINTS } from "../core/detect/llm-key.js";
 const C = {
     reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
@@ -184,6 +185,17 @@ export async function runScan(options = {}) {
     }
     // Persist findings so `guardrail fix` can read them
     saveCachedFindings(cwd, findings);
+    // Persist run to cost log so `claude-autopilot costs` reflects scans, not
+    // just full pipeline runs. Previously scan never wrote to the log, so the
+    // costs report stayed frozen at whatever the last `run` invocation produced.
+    appendCostLog(cwd, {
+        timestamp: new Date().toISOString(),
+        files: files.length,
+        inputTokens: result.usage?.input ?? 0,
+        outputTokens: result.usage?.output ?? 0,
+        costUSD: result.costUSD ?? 0,
+        durationMs: result.durationMs,
+    });
     if (result.costUSD !== undefined) {
         console.log(fmt('dim', `  $${result.costUSD.toFixed(4)} · ${result.durationMs}ms`));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "5.0.2",
+  "version": "5.0.4",
   "type": "module",
   "description": "Autonomous development pipeline for Claude Code: brainstorm → spec → plan → implement → migrate → validate → PR → review → merge. Multi-model, local-first, every phase a skill you can intervene in.",
   "keywords": [

package/presets/generic/guardrail.config.yaml

@@ -33,3 +33,15 @@ chunking:
 pipeline:
   runReviewOnStaticFail: true
   runReviewOnTestFail: false
+# Optional: multi-model council. Uncomment + set ANTHROPIC_API_KEY and/or
+# OPENAI_API_KEY. Models are dispatched in parallel; the synthesizer reads
+# their responses and writes the consensus. Both APIs supported (chat-completions
+# and Responses API for codex/o-series models — auto-detected by name).
+# Usage: claude-autopilot council --prompt "..." --context-file <path>
+# council:
+#   models:
+#     - { adapter: claude, model: claude-opus-4-7, label: opus }
+#     - { adapter: openai, model: gpt-5.3-codex,  label: codex }
+#   synthesizer: { adapter: claude, model: claude-sonnet-4-6, label: synth }
+#   timeout_ms: 30000
+#   min_successful_responses: 1