indusagi-coding-agent 0.2.11 → 0.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indusagi-coding-agent",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "Indusagi coding agent — a terminal-first AI coding agent, built from scratch on the indusagi framework.",
   "author": "Varun Israni",
   "license": "AGPL-3.0",
@@ -22,44 +22,49 @@
     "node": ">=20"
   },
   "main": "./dist/index.js",
-  "types": "./dist/types/index.d.ts",
   "bin": {
     "indus": "dist/entry.js",
-    "indusagi": "dist/entry.js"
+    "indusagi": "dist/entry.js",
+    "indusagi-review": "dist/review-server.js"
   },
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
       "import": "./dist/index.js"
     },
     "./guardrails": {
-      "types": "./dist/types/guardrails.d.ts",
       "import": "./dist/guardrails.js"
     },
+    "./review-agent": {
+      "import": "./dist/review-agent.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist",
     "src",
+    "supabase",
+    ".env.review.example",
     "CHANGELOG.md",
     "CREDITS.md",
     "NOTICE",
-    "README.md"
+    "README.md",
+    "REVIEW_AGENT.md"
   ],
   "scripts": {
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "build": "node build.mjs",
-    "lineage-scan": "node scripts/lineage-scan.mjs",
     "test": "vitest --run",
     "test:watch": "vitest",
+    "prepublishOnly": "npm test && npm run build",
     "start": "node dist/entry.js",
-    "start:help": "node dist/entry.js --help"
+    "start:help": "node dist/entry.js --help",
+    "review:server": "node dist/review-server.js"
   },
   "dependencies": {
     "@sinclair/typebox": "^0.34.49",
     "chalk": "^5.6.2",
     "highlight.js": "^11.11.1",
-    "indusagi": "^0.13.10",
+    "indusagi": "0.13.11",
     "ink": "^5.2.1",
     "jiti": "^2.7.0",
     "marked": "^18.0.4",
@@ -75,4 +80,4 @@
     "typescript": "^5.7.2",
     "vitest": "^2.1.8"
   }
-}
+}

package/src/boot/contract.ts

@@ -131,7 +131,7 @@ export interface Invocation {
     readonly cwd?: string;
     /** Named credential account to authenticate with (`--account`). */
     readonly account?: string;
-    /** Reasoning effort (`--thinking`): off / minimal / low / medium / high / xhigh. */
+    /** Reasoning effort (`--thinking`): off / minimal / low / medium / high / xhigh / max (model-dependent). */
     readonly thinking?: string;
     /** Replacement system prompt (`--system`); a path is read as a file, else literal text. */
     readonly system?: string;

package/src/boot/runners/session.ts

@@ -58,6 +58,8 @@ import { createAuthVault } from "../auth-vault.js";
 import { TOKEN_FILE, hasValidServerToken, getServerToken } from "../server-token.js";
 import { resolveServerMode, resolveServerGatewayUrls, serverTierProviders } from "./server-mode.js";
 import { DiskMemoryStore, memoryDirFor, loadMemoryDoc } from "./memdir.js";
+import { isReasoningEffortSupported } from "../../models.js";
+import type { CodingAgentThinkingLevel } from "../../conductor/contract.js";
 import { buildAddonHost, wrapToolsWithAddons, concatAddonTools } from "./addon-wiring.js";
 import type { BootContext, Invocation } from "../contract.js";
 
@@ -219,10 +221,12 @@ function buildKeyResolver(
   };
 }
 
-const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh"]);
+const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 
-function resolveThinkingLevel(raw: string | undefined): string | undefined {
-  return raw !== undefined && THINKING_LEVELS.has(raw) ? raw : undefined;
+export function resolveThinkingLevel(raw: string | undefined, modelId?: string): CodingAgentThinkingLevel | undefined {
+  return raw !== undefined && THINKING_LEVELS.has(raw) && isReasoningEffortSupported(modelId, raw)
+    ? raw as CodingAgentThinkingLevel
+    : undefined;
 }
 
 function resolveText(value: string): string {
@@ -597,7 +601,7 @@ export async function buildSessionConductor(ctx: BootContext) {
   const tools = wrapToolsWithAddons(concatAddonTools(deck, addons), addons);
   const skills = gatherModelSkills(cwd);
   const system = composeSystem(tools, inv, cwd, skills, memoryDoc);
-  const thinking = resolveThinkingLevel(inv.thinking);
+  const thinking = resolveThinkingLevel(inv.thinking, modelId);
   const fallbackModelId = inv.fallbackModelId;
   const planReachable = inv.mode === "repl";
   const canUseTool = buildPermissionGate(permissionRules, permissionMode, tools, planReachable);

package/src/boot/stages.ts

@@ -29,6 +29,7 @@ import { tokenizeInvocation } from "./invocation.js";
 import { applyUpgrades } from "./upgrade/apply.js";
 import { ensureDirs } from "../workspace/locator.js";
 import type { BootContext, Stage } from "./contract.js";
+import { createCodingAgentModelRegistry } from "../models.js";
 
 /**
  * Materialise the resolved workspace directories on disk.
@@ -110,11 +111,7 @@ async function loadDefaultSettings(): Promise<unknown> {
 }
 
 async function loadModelRegistry(): Promise<unknown> {
-  const mod = (await import("indusagi/ai")) as { ModelRegistry?: unknown; modelRegistry?: unknown };
-  if (typeof mod.ModelRegistry === "function") {
-    return new (mod.ModelRegistry as new () => unknown)();
-  }
-  return mod.modelRegistry;
+  return createCodingAgentModelRegistry();
 }
 
 /**
@@ -164,4 +161,4 @@ export async function runStages(initial: BootContext, stages: readonly Stage[] =
   return ctx;
 }
 
-export { locateWorkspace, upgrade, buildInvocation, resolveResources, selectRunnerStage };
+export { locateWorkspace, upgrade, buildInvocation, resolveResources, selectRunnerStage, loadModelRegistry };

package/src/conductor/catalog/catalog.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
-import { getModels, getProviders } from "indusagi/ai";
+import { getModels, getProviders, modelRegistry } from "indusagi/ai";
 import type { KnownProvider, Model } from "indusagi/ai";
 import type { ModelCardRef } from "../contract.js";
+import { applyCodingAgentModelOverlay } from "../../models.js";
 
 export interface CatalogCard {
   readonly id: string;
@@ -29,6 +30,7 @@ const rawModelGate = z.object({
 });
 
 const EXCLUDED_PROVIDERS = new Set(["mock"]);
+applyCodingAgentModelOverlay(modelRegistry);
 const frameworkSource: CatalogSource = {
   providers: () => getProviders().filter((provider) => !EXCLUDED_PROVIDERS.has(String(provider))),
   models: (provider) => getModels(provider as KnownProvider),

package/src/conductor/conductor.ts

@@ -4,7 +4,7 @@ import { createZeroUsage } from "indusagi/ai";
 import type { Model, Usage } from "indusagi/ai";
 import * as path from "node:path";
 import { conductorFault } from "./contract.js";
-import type { ApprovalResolver, ConductorFault, ConductorPhase, ConductorState, PermissionMode, SessionConductor, SessionConductorOptions, SessionHead } from "./contract.js";
+import type { ApprovalResolver, CodingAgentThinkingLevel, ConductorFault, ConductorPhase, ConductorState, PermissionMode, SessionConductor, SessionConductorOptions, SessionHead } from "./contract.js";
 import { ModelCatalog, ModelMatcher } from "./catalog/index.js";
 import type { CatalogCard } from "./catalog/index.js";
 import { SignalHub, translateAgentEvent } from "./signal-hub/index.js";
@@ -15,6 +15,7 @@ import { writePlan } from "../capability-deck/cards/plan-file.js";
 import { AUTO_CONDENSE_POLICY, isOverBudget } from "../window-budget/index.js";
 import { DiagnosticsEngine, formatDiagnosticsSummary, hasEslintConfig, hasTsConfig, isTypeScriptOrJs, runEslintDiagnostics, runTscDiagnostics } from "./diagnostics.js";
 import type { DiagnosticsConfig } from "./diagnostics.js";
+import { isReasoningEffortSupported, type CodingAgentModel } from "../models.js";
 
 export interface AgentLike {
   subscribe(fn: (event: AgentEvent) => void): () => void;
@@ -62,7 +63,7 @@ export function reduceState(prev: ConductorState, action: StateAction): Conducto
 }
 
 const DEFAULT_RETRY = { maxAttempts: 2, baseDelayMs: 250 };
-const THINKING_LADDER: ThinkingLevel[] = ["off", "low", "medium", "high"];
+const DEFAULT_THINKING_LADDER: readonly CodingAgentThinkingLevel[] = ["off", "low", "medium", "high"];
 const PERMISSION_CYCLE: PermissionMode[] = ["default", "acceptEdits", "plan", "bypass"];
 
 function newSessionId(): string { return `s_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`; }
@@ -73,6 +74,10 @@ function accumulateUsage(a: Usage, b: Usage): Usage {
 function errorText(error: unknown): string { return error instanceof Error ? error.message : String(error); }
 function isTransient(error: unknown): boolean { const text = errorText(error).toLowerCase(); return ["429", "rate limit", "overloaded", "timeout", "timed out", "econnreset", "etimedout", "503", "502", "500", "unavailable", "temporarily"].some((part) => text.includes(part)); }
 function isOverloadFault(error: unknown): boolean { const text = errorText(error).toLowerCase(); return text.includes("529") || text.includes("overload"); }
+function thinkingLadderForModel(model: Model<any> | undefined): readonly CodingAgentThinkingLevel[] {
+  const efforts = (model as CodingAgentModel | undefined)?.reasoningEfforts;
+  return efforts?.length ? efforts : DEFAULT_THINKING_LADDER;
+}
 
 export function withGatewayBaseUrl<M extends { baseUrl: string; provider: string }>(model: M, gatewayBaseUrls: Record<string, string> | undefined): M {
   const url = gatewayBaseUrls?.[model.provider];
@@ -132,7 +137,7 @@ class SessionConductorImpl implements SessionConductor {
   #draining = false;
   #queue: { mode: "steer" | "followUp"; text: string }[] = [];
   #boundModel?: Model<any>;
-  #thinking: ThinkingLevel;
+  #thinking: CodingAgentThinkingLevel;
   #prePlanMode?: PermissionMode;
   #sessionName?: string;
   #gatewayBaseUrls?: Record<string, string>;
@@ -218,8 +223,8 @@ class SessionConductorImpl implements SessionConductor {
   stats() { const messages = this.agent.state.messages; let userMessages = 0, assistantMessages = 0, toolCalls = 0, toolResults = 0; for (const message of messages) { if (message.role === "user") userMessages++; else if (message.role === "assistant") { assistantMessages++; for (const part of message.content ?? []) if (typeof part === "object" && part && part.type === "toolCall") toolCalls++; } else if (message.role === "toolResult") toolResults++; } const usage = this.#state.usage; return { sessionId: this.#state.head.sessionId, userMessages, assistantMessages, toolCalls, toolResults, totalMessages: messages.length, tokens: { input: usage.input, output: usage.output, cacheRead: usage.cacheRead, cacheWrite: usage.cacheWrite, total: usage.totalTokens }, cost: usage.cost.total }; }
   costReport() { const stats = this.stats(); return [`Total cost:            $${stats.cost.toFixed(4)}`, `Total tokens:          ${stats.tokens.total}`, `  Input:               ${stats.tokens.input}`, `  Output:              ${stats.tokens.output}`, `  Cache read:          ${stats.tokens.cacheRead}`, `  Cache write:         ${stats.tokens.cacheWrite}`].join("\n"); }
   thinkingLevel() { return this.#thinking; }
-  setThinkingLevel(level: ThinkingLevel) { this.#thinking = level; this.agent.setThinkingLevel?.(level); }
-  cycleThinkingLevel() { const next = THINKING_LADDER[(THINKING_LADDER.indexOf(this.#thinking) + 1) % THINKING_LADDER.length]; this.setThinkingLevel(next); return next; }
+  setThinkingLevel(level: CodingAgentThinkingLevel) { if (!isReasoningEffortSupported(this.#boundModel?.id, level)) return; this.#thinking = level; this.agent.setThinkingLevel?.(level as ThinkingLevel); }
+  cycleThinkingLevel() { const ladder = thinkingLadderForModel(this.#boundModel); const next = ladder[(ladder.indexOf(this.#thinking) + 1) % ladder.length]; this.setThinkingLevel(next); return next; }
   permissionMode() { return this.modeHolder.mode; }
   setPermissionMode(mode: PermissionMode) { this.modeHolder.mode = mode; }
   setApprovalResolver(resolver: ApprovalResolver | undefined) { this.approvalHolder.resolver = resolver; }

package/src/conductor/contract.ts

@@ -40,6 +40,7 @@ import type { AgentMessage, AgentTool, CanUseToolFn, ThinkingLevel } from "indus
 import type { KnownProvider, Model, Usage } from "indusagi/ai";
 import type { PermissionMode } from "../settings.js";
 import type { ApprovalResolver } from "./permissions.js";
+export type CodingAgentThinkingLevel = ThinkingLevel | "max";
 /** Re-exported framework vocabulary that conductor consumers routinely need. */
 export type { AgentMessage, AgentTool, CanUseToolFn, ThinkingLevel, Model, Usage, KnownProvider };
 /** Re-exported permission vocabulary, so conductor consumers get it in one import. */
@@ -131,6 +132,7 @@ export type SessionSignal = {
     readonly kind: "tool_start";
     readonly id: string;
     readonly name: string;
+    readonly args: unknown;
 } | {
     readonly kind: "tool_update";
     readonly id: string;
@@ -140,6 +142,8 @@ export type SessionSignal = {
     readonly kind: "tool_end";
     readonly id: string;
     readonly ok: boolean;
+    readonly result: unknown;
+    readonly isError: boolean;
 } | {
     readonly kind: "turn_end";
     readonly usage: Usage;
@@ -431,7 +435,7 @@ export interface SessionConductorOptions {
     /** Tools made available to the agent for this session. */
     readonly tools?: AgentTool[];
     /** Initial reasoning effort for models that support it. */
-    readonly thinking?: ThinkingLevel;
+    readonly thinking?: CodingAgentThinkingLevel;
     /**
      * Canonical id of a model to fall back to when the bound model is overloaded
      * (HTTP 529 / "overloaded") mid-turn (`--fallback-model`). When set, an
@@ -715,19 +719,19 @@ export interface SessionConductor {
      */
     costReport(): string;
     /** The reasoning effort currently applied to the session. */
-    thinkingLevel(): ThinkingLevel;
+    thinkingLevel(): CodingAgentThinkingLevel;
     /**
      * Set the reasoning effort for subsequent turns. Applied to the agent when it
      * exposes a setter; otherwise stored and applied on the next model bind.
      *
      * @param level the reasoning effort to apply
      */
-    setThinkingLevel(level: ThinkingLevel): void;
+    setThinkingLevel(level: CodingAgentThinkingLevel): void;
     /**
      * Advance the reasoning effort to the next level in the cycle, applying it, and
      * return the newly-selected level.
      */
-    cycleThinkingLevel(): ThinkingLevel;
+    cycleThinkingLevel(): CodingAgentThinkingLevel;
     /**
      * The permission mode currently in effect. The live `canUseTool` gate reads
      * this on every tool call, so the value reflects the most recent

package/src/conductor/index.ts

@@ -16,7 +16,7 @@
  * land; consumers import the conductor surface from `src/conductor` rather than
  * reaching into individual modules.
  */
-export type { FaultKind, ConductorFault, SessionSignal, SignalKind, SignalOf, SignalHandler, TranscriptSchema, TranscriptRole, TranscriptEntry, SessionHead, ModelCardRef, MatchQuery, ConductorPhase, ConductorState, QueueMode, QueuedInput, SessionStats, ExecuteBashOptions, BashOutcome, SessionConductor, SessionConductorOptions, CondenseOutcome, AgentMessage, AgentTool, CanUseToolFn, ThinkingLevel, Model, Usage, KnownProvider, PermissionMode, } from "./contract.js";
+export type { FaultKind, ConductorFault, SessionSignal, SignalKind, SignalOf, SignalHandler, TranscriptSchema, TranscriptRole, TranscriptEntry, SessionHead, ModelCardRef, MatchQuery, ConductorPhase, ConductorState, QueueMode, QueuedInput, SessionStats, ExecuteBashOptions, BashOutcome, SessionConductor, SessionConductorOptions, CondenseOutcome, AgentMessage, AgentTool, CanUseToolFn, ThinkingLevel, CodingAgentThinkingLevel, Model, Usage, KnownProvider, PermissionMode, } from "./contract.js";
 export { conductorFault, TRANSCRIPT_SCHEMA } from "./contract.js";
 export { createSessionConductor, reduceState, noopCondense, withGatewayBaseUrl, type AgentLike, type ConductorDeps, type CondenseFn, type RetryPolicy, } from "./conductor.js";
 export { SignalHub, translateAgentEvent, type SignalHubOptions } from "./signal-hub/index.js";

package/src/conductor/signal-hub/translate.ts

@@ -52,7 +52,7 @@ export const TRANSLATOR_TABLE: TranslatorTable = {
   },
   turn_end: (event) => [{ kind: "turn_end", usage: usageOf(event.message) }],
   message_update: (event) => translateStreamEvent(event.assistantMessageEvent),
-  tool_execution_start: (event) => [{ kind: "tool_start", id: event.toolCallId, name: event.toolName, args: event.args } as SessionSignal],
+  tool_execution_start: (event) => [{ kind: "tool_start", id: event.toolCallId, name: event.toolName, args: event.args }],
   tool_execution_update: (event) => [{
     kind: "tool_update",
     id: event.toolCallId,
@@ -65,7 +65,7 @@ export const TRANSLATOR_TABLE: TranslatorTable = {
     ok: !event.isError,
     result: event.result,
     isError: event.isError,
-  } as SessionSignal],
+  }],
 };
 
 export function translateAgentEvent(event: AgentEvent): SessionSignal[] {

package/src/console/slash/commands/workbench.ts

@@ -147,7 +147,7 @@ const HOTKEYS: Array<[string, string]> = [
   ["Tab", "Accept the highlighted completion"],
   ["Ctrl+C", "Interrupt the running turn"],
   ["Ctrl+T", "Toggle reasoning / thinking rows"],
-  ["/thinking", "Cycle thinking effort level (off → low → medium)"],
+  ["/thinking", "Cycle the selected model's supported reasoning efforts"],
   ["Ctrl+V", "Attach an image from the clipboard"],
   ["Ctrl+G", "Edit the composer in your external editor"],
   ["Ctrl+O", "Expand or collapse full tool output"],
@@ -232,7 +232,7 @@ export const workbenchCommands: SlashCommand[] = [
   },
   {
     name: "thinking",
-    summary: "Cycle thinking effort level (off → low → medium → off)",
+    summary: "Cycle reasoning effort using the selected model's supported levels",
     run: (ctx) => {
       ctx.conductor.cycleThinkingLevel();
       return HANDLED;

package/src/index.ts

@@ -15,4 +15,5 @@ export * as addons from "./addons/index.js";
 export * as channels from "./channels/index.js";
 export * as runtimeBridge from "./runtime-bridge/index.js";
 export * as insight from "./insight/index.js";
+export * as reviewAgent from "./review-agent/index.js";
 export { VERSION } from "./workspace/index.js";

package/src/launch/catalog.ts

@@ -3,6 +3,7 @@
  */
 import { ModelRegistry, type KnownProvider, type Model } from "indusagi/ai";
 import type { CatalogFilter } from "./contract.js";
+import { applyCodingAgentModelOverlay } from "../models.js";
 
 export interface CatalogIo {
   print(line: string): void;
@@ -22,10 +23,11 @@ export interface CatalogModelSource {
 }
 
 export function registrySource(registry: ModelRegistry = new ModelRegistry()): CatalogModelSource {
+  const overlaid = applyCodingAgentModelOverlay(registry);
   return {
-    providers: (): readonly (KnownProvider | string)[] => registry.getProviders(),
+    providers: (): readonly (KnownProvider | string)[] => overlaid.getProviders(),
     models: (provider: string): readonly Model<Model<string>["api"]>[] =>
-      registry.getModels(provider),
+      overlaid.getModels(provider),
   };
 }
 

package/src/launch/contract.ts

@@ -33,6 +33,7 @@ export const THINKING_EFFORTS = [
   "medium",
   "high",
   "xhigh",
+  "max",
 ] as const;
 
 export type ThinkingEffort = (typeof THINKING_EFFORTS)[number];

package/src/launch/invocation/flags.ts

@@ -20,7 +20,7 @@ export const FLAG_GROUPS: readonly { readonly id: FlagGroup; readonly title: str
   { id: "meta", title: "Meta" },
 ];
 
-const THINKING_CHOICES = ["off", "minimal", "low", "medium", "high", "xhigh"];
+const THINKING_CHOICES = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 
 export const FLAG_SPECS: readonly GroupedFlagSpec[] = [
   /* ---- Output ---------------------------------------------------------- */

package/src/launch/invocation/read.ts

@@ -9,6 +9,7 @@ import {
   isToolName,
 } from "../contract.js";
 import { FLAG_SPECS, type GroupedFlagSpec } from "./flags.js";
+import { isReasoningEffortSupported } from "../../models.js";
 
 interface ParseState {
   flags: Record<string, FlagValue>;
@@ -154,14 +155,14 @@ function readBool(flags: Record<string, FlagValue>, key: string): boolean {
 }
 
 function deriveMode(flags: Record<string, FlagValue>): Invocation["mode"] {
-  if (readBool(flags, "json")) return "rpc";
   if (readBool(flags, "print") && !readBool(flags, "interactive")) return "json";
+  if (readBool(flags, "json")) return "rpc";
   return "text";
 }
 
-function resolveThinking(flags: Record<string, FlagValue>): Invocation["thinking"] {
+function resolveThinking(flags: Record<string, FlagValue>, modelId: string | undefined): Invocation["thinking"] {
   const raw = readString(flags, "thinking");
-  return raw !== undefined && isThinkingEffort(raw) ? raw : undefined;
+  return raw !== undefined && isThinkingEffort(raw) && isReasoningEffortSupported(modelId, raw) ? raw : undefined;
 }
 
 function resolveTools(flags: Record<string, FlagValue>): Invocation["tools"] {
@@ -215,7 +216,7 @@ export function readInvocation(argv: readonly string[]): Invocation {
   const cwd = readString(flags, "cwd");
   const system = readString(flags, "system");
   const appendSystem = readString(flags, "append-system");
-  const thinking = resolveThinking(flags);
+  const thinking = resolveThinking(flags, model);
   const tools = resolveTools(flags);
   return {
     mode,

package/src/models.ts

@@ -0,0 +1,90 @@
+import { ModelRegistry, type Api, type Model } from "indusagi/ai";
+
+export type AstraReasoningLevel = "low" | "medium" | "high" | "xhigh" | "max";
+
+export interface LongContextPricing {
+  readonly threshold: number;
+  readonly multipliers: {
+    readonly input: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+    readonly output: number;
+  };
+}
+
+export interface CodingAgentModel<TApi extends Api = Api> extends Model<TApi> {
+  readonly reasoningEfforts?: readonly AstraReasoningLevel[];
+  readonly longContextPricing?: LongContextPricing;
+}
+
+const GPT_6_ASTRA_BASE = {
+  id: "gpt-6-astra",
+  name: "GPT-6 Astra",
+  api: "openai-responses",
+  reasoning: true,
+  reasoningEfforts: ["low", "medium", "high", "xhigh", "max"],
+  input: ["text", "image"] as Array<"text" | "image">,
+  cost: {
+    input: 10,
+    cacheRead: 1,
+    cacheWrite: 12.5,
+    output: 50,
+  },
+  contextWindow: 1_050_000,
+  maxTokens: 128_000,
+  longContextPricing: {
+    threshold: 272_000,
+    multipliers: {
+      input: 2,
+      cacheRead: 2,
+      cacheWrite: 2,
+      output: 1.5,
+    },
+  },
+} as const;
+
+export const CODING_AGENT_MODELS: readonly CodingAgentModel[] = [
+  {
+    ...GPT_6_ASTRA_BASE,
+    provider: "openai",
+    baseUrl: "https://api.openai.com/v1",
+  },
+  {
+    ...GPT_6_ASTRA_BASE,
+    api: "openai-codex-responses",
+    provider: "openai-codex",
+    baseUrl: "https://chatgpt.com/backend-api",
+  },
+  {
+    ...GPT_6_ASTRA_BASE,
+    provider: "codex-cli",
+    baseUrl: "bridge:codex-cli",
+  },
+  {
+    ...GPT_6_ASTRA_BASE,
+    id: "openai/gpt-6-astra",
+    provider: "indusagi-cli",
+    baseUrl: "bridge:indusagi-cli",
+  },
+  {
+    ...GPT_6_ASTRA_BASE,
+    id: "openai-codex/gpt-6-astra",
+    api: "openai-codex-responses",
+    provider: "indusagi-cli",
+    baseUrl: "bridge:indusagi-cli",
+  },
+];
+
+export function applyCodingAgentModelOverlay(registry: ModelRegistry): ModelRegistry {
+  for (const model of CODING_AGENT_MODELS) registry.registerCustomModel(model);
+  return registry;
+}
+
+export function createCodingAgentModelRegistry(): ModelRegistry {
+  return applyCodingAgentModelOverlay(new ModelRegistry());
+}
+
+export function isReasoningEffortSupported(modelId: string | undefined, effort: string): boolean {
+  if (modelId?.split("/").at(-1) !== "gpt-6-astra") return true;
+  return GPT_6_ASTRA_BASE.reasoningEfforts.includes(effort as AstraReasoningLevel);
+}

package/src/review-agent/config.ts

@@ -0,0 +1,75 @@
+const SDSDSD_SUPABASE_URL = "https://bnaadeovgcqgbrnrfcef.supabase.co";
+
+export interface ReviewAgentConfig {
+  host: string;
+  port: number;
+  supabaseUrl: string;
+  supabaseServiceKey: string;
+  githubWebhookSecret: string;
+  githubToken?: string;
+  githubApp?: { appId: string; privateKey: string };
+  modelId: string;
+  pollIntervalMs: number;
+  maxJobsPerTick: number;
+  providerKeys: Readonly<Record<string, string>>;
+}
+
+const PROVIDER_ENV: Record<string, string> = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GEMINI_API_KEY",
+  minimax: "MINIMAX_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  xai: "XAI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  groq: "GROQ_API_KEY",
+};
+
+function required(env: NodeJS.ProcessEnv, name: string): string {
+  const value = env[name]?.trim();
+  if (!value) throw new Error(`${name} is required`);
+  return value;
+}
+
+function positiveInteger(value: string | undefined, fallback: number, name: string): number {
+  if (!value) return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${name} must be a positive integer`);
+  return parsed;
+}
+
+export function loadReviewAgentConfig(env: NodeJS.ProcessEnv = process.env): ReviewAgentConfig {
+  const supabaseServiceKey = required(env, "SUPABASE_SERVICE_ROLE_KEY");
+  const githubWebhookSecret = required(env, "GITHUB_WEBHOOK_SECRET");
+  const githubToken = env.GITHUB_TOKEN?.trim();
+  const appId = env.GITHUB_APP_ID?.trim();
+  const privateKey = env.GITHUB_APP_PRIVATE_KEY?.replace(/\\n/g, "\n").trim();
+  if (!githubToken && !(appId && privateKey)) {
+    throw new Error("Configure GITHUB_APP_ID and GITHUB_APP_PRIVATE_KEY, or GITHUB_TOKEN for development");
+  }
+
+  const modelId = env.INDUSAGI_REVIEW_MODEL?.trim() || "anthropic/claude-sonnet-4-6";
+  const provider = modelId.split("/", 1)[0];
+  const providerEnv = PROVIDER_ENV[provider];
+  if (providerEnv && !env[providerEnv]?.trim()) throw new Error(`${providerEnv} is required for ${modelId}`);
+
+  const providerKeys: Record<string, string> = {};
+  for (const [id, name] of Object.entries(PROVIDER_ENV)) {
+    const value = env[name]?.trim();
+    if (value) providerKeys[id] = value;
+  }
+
+  return {
+    host: env.REVIEW_AGENT_HOST?.trim() || env.HOST?.trim() || "0.0.0.0",
+    port: positiveInteger(env.REVIEW_AGENT_PORT ?? env.PORT, 8787, "REVIEW_AGENT_PORT"),
+    supabaseUrl: env.SUPABASE_URL?.trim().replace(/\/$/, "") || SDSDSD_SUPABASE_URL,
+    supabaseServiceKey,
+    githubWebhookSecret,
+    ...(githubToken ? { githubToken } : {}),
+    ...(appId && privateKey ? { githubApp: { appId, privateKey } } : {}),
+    modelId,
+    pollIntervalMs: positiveInteger(env.REVIEW_AGENT_POLL_MS ?? env.REVIEW_POLL_INTERVAL_MS, 2_000, "REVIEW_AGENT_POLL_MS"),
+    maxJobsPerTick: positiveInteger(env.REVIEW_AGENT_JOBS_PER_TICK ?? env.REVIEW_MAX_JOBS_PER_TICK, 5, "REVIEW_AGENT_JOBS_PER_TICK"),
+    providerKeys,
+  };
+}

package/src/review-agent/contract.ts

@@ -0,0 +1,59 @@
+export const REVIEW_SEVERITIES = ["critical", "high", "medium", "low", "nit"] as const;
+export const REVIEW_RISKS = ["low", "medium", "high"] as const;
+
+export type ReviewSeverity = (typeof REVIEW_SEVERITIES)[number];
+export type ReviewRisk = (typeof REVIEW_RISKS)[number];
+export type ReviewSide = "LEFT" | "RIGHT";
+
+export interface ChangedFile {
+  filename: string;
+  status: string;
+  additions: number;
+  deletions: number;
+  patch?: string;
+}
+
+export interface PullRequestContext {
+  repository: string;
+  pullNumber: number;
+  headSha: string;
+  baseSha?: string;
+  title: string;
+  description: string;
+  author: string;
+  additions: number;
+  deletions: number;
+  changedFiles: ChangedFile[];
+  diff: string;
+}
+
+export interface ReviewFinding {
+  severity: ReviewSeverity;
+  confidence: number;
+  title: string;
+  path: string;
+  line: number;
+  side: ReviewSide;
+  body: string;
+  suggestion?: string;
+}
+
+export interface ReviewOutput {
+  summary: string;
+  risk: ReviewRisk;
+  findings: ReviewFinding[];
+  testPlan: string[];
+}
+
+export interface ReviewRequest {
+  deliveryId: string;
+  action: string;
+  installationId: number;
+  repository: string;
+  owner: string;
+  repo: string;
+  pullNumber: number;
+  headSha: string;
+  title: string;
+  draft: boolean;
+}