@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/dashboard/apps/frontend/src/agent-catalog-settings.test.ts

@@ -0,0 +1,249 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it, vi } from "vitest";
+import {
+  applyAgentEditorDraft,
+  automaticPolicyLabel,
+  cloneAgent,
+  createCustomAgent,
+  effectiveConfiguredValue,
+  effectiveEffortValue,
+  effectiveModelValue,
+  humanizeAgentLabel,
+  restoreAgentCatalogFocus,
+  safePhotoUrl,
+  withCustomName,
+} from "./AgentCatalogSettingsPage.js";
+
+const componentSource = readFileSync(
+  new URL("./AgentCatalogSettingsPage.tsx", import.meta.url),
+  "utf8",
+);
+const stylesheetSource = readFileSync(
+  new URL("./agent-catalog-settings-page.css", import.meta.url),
+  "utf8",
+);
+
+describe("agent catalog settings helpers", () => {
+  it("creates unique custom agents with valid catalog identities", () => {
+    const first = createCustomAgent([]);
+    const second = createCustomAgent([first]);
+
+    expect(first).toMatchObject({
+      id: "agent-custom",
+      codex_name: "zaip-agent-custom",
+      codex_task_name: "zaip_agent_custom",
+      capabilities: ["custom-task-delivery"],
+      execution_eligibility: ["delivery"],
+    });
+    expect(second.id).toBe("agent-custom-2");
+  });
+
+  it("keeps technical identity stable when a custom persona changes", () => {
+    const renamed = withCustomName(createCustomAgent([]), "Zaip Agent Audio Notes");
+
+    expect(renamed).toMatchObject({
+      id: "agent-custom",
+      codex_name: "zaip-agent-custom",
+      codex_task_name: "zaip_agent_custom",
+      persona: { nome: "zaip_agent_audio_notes", cargo: "agent" },
+      nickname_candidates: ["zaip_agent_audio_notes_agent_zaip_agent"],
+    });
+  });
+
+  it("preserves inherited model and effort semantics instead of replacing them with defaults", () => {
+    expect(effectiveModelValue("policy-selected")).toBe("policy-selected");
+    expect(effectiveModelValue(undefined)).toBe("policy-selected");
+    expect(effectiveModelValue("gpt-5.6-sol")).toBe("gpt-5.6-sol");
+    expect(effectiveEffortValue(undefined)).toBe("policy-selected");
+    expect(effectiveEffortValue("high")).toBe("high");
+    expect(effectiveConfiguredValue("gpt-5.6-terra")).toBe("gpt-5.6-terra");
+    expect(effectiveConfiguredValue("medium")).toBe("medium");
+    expect(effectiveConfiguredValue(null)).toBe("—");
+    expect(componentSource).not.toContain('defaultLabel: "Padrão"');
+    expect(componentSource).not.toContain("configuredDefaultLabel");
+  });
+
+  it("labels policy-selected separately from the explicit Terra option", () => {
+    const inheritedModel = automaticPolicyLabel(
+      "Política automática (padrão: {value})",
+      "gpt-5.6-terra",
+    );
+    const inheritedEffort = automaticPolicyLabel("Política automática (padrão: {value})", "medium");
+    expect(inheritedModel).toBe("Política automática (padrão: gpt-5.6-terra)");
+    expect(inheritedModel).not.toBe("gpt-5.6-terra");
+    expect(inheritedEffort).toBe("Política automática (padrão: medium)");
+    expect(componentSource).toContain('automaticPolicy: "Política automática (padrão: {value})"');
+    expect(componentSource).toContain('automaticPolicy: "Automatic policy (default: {value})"');
+    expect(componentSource).toContain('modelSummary === "policy-selected"');
+    expect(componentSource).toContain('effortSummary === "policy-selected"');
+  });
+
+  it("creates an isolated editor draft for mutable catalog fields", () => {
+    const original = createCustomAgent([]);
+    const draft = cloneAgent(original);
+
+    draft.capabilities.push("another-capability");
+    draft.model.preferred[0] = "gpt-5.6-sol";
+
+    expect(original.capabilities).toEqual(["custom-task-delivery"]);
+    expect(original.model.preferred).toEqual(["policy-selected"]);
+  });
+
+  it("renders a square contained portrait and removes its region when no asset is available", () => {
+    expect(humanizeAgentLabel("product_owner")).toBe("Product Owner");
+    expect(humanizeAgentLabel("quality_assurance_lead")).toBe("Quality Assurance Lead");
+    expect(componentSource).toContain("api.agentPortraitUrl(agent.id)");
+    expect(componentSource).toContain("safePhotoUrl(agent.persona.foto_url)");
+    expect(componentSource).toContain("localPortraitFallbacks");
+    expect(safePhotoUrl("https://example.test/portrait.png")).toBe(
+      "https://example.test/portrait.png",
+    );
+    expect(safePhotoUrl("file:///private/portrait.png")).toBeNull();
+    expect(componentSource).toContain("agent-catalog-card-portrait");
+    expect(componentSource).toContain("setUnavailablePortraits");
+    expect(componentSource).toContain("{hasPortrait ? (");
+    expect(componentSource).not.toContain("event.currentTarget.hidden = true");
+    expect(componentSource).not.toContain('aria-hidden="true"');
+    expect(componentSource).toContain("{agent.codex_name}");
+    expect(stylesheetSource).toContain(".agent-catalog-card-portrait img");
+    expect(stylesheetSource).toContain("aspect-ratio: 1");
+    expect(stylesheetSource).toContain("object-fit: contain");
+  });
+
+  it("keeps only persona name and role controls in the edit modal", () => {
+    const modalControls = componentSource.slice(
+      componentSource.indexOf('<div className="agent-catalog-modal-body">'),
+      componentSource.indexOf('<footer className="agent-catalog-modal-actions">'),
+    );
+
+    expect(componentSource).not.toContain("AgentTechnicalDetails");
+    expect(componentSource).not.toContain("Configuração efetiva");
+    expect(modalControls).toContain("text.personaName");
+    expect(modalControls).toContain("text.personaRole");
+    expect(modalControls.match(/<input/g)).toHaveLength(2);
+    expect(modalControls).not.toContain("text.prompt");
+    expect(modalControls).not.toContain("text.photoUrl");
+    expect(modalControls).not.toContain("text.capabilities");
+    expect(modalControls).not.toContain("text.runtimeTitle");
+    expect(modalControls).not.toContain("<textarea");
+    expect(modalControls).not.toContain("<select");
+  });
+
+  it("keeps add and remove isolated while existing edits preserve every technical field", () => {
+    const original = createCustomAgent([]);
+    const edited = withCustomName(cloneAgent(original), "zaip-agent-research");
+    edited.purpose = "attempted replacement";
+    edited.capabilities = ["attempted-capability"];
+    edited.model.preferred = ["gpt-5.6-sol"];
+    edited.model.reasoning_effort = "high";
+    edited.persona.foto_url = "https://example.test/replaced.png";
+
+    const savedEdit = applyAgentEditorDraft([original], {
+      sourceId: original.id,
+      agent: edited,
+      removeOnSave: false,
+    });
+
+    expect(original.id).toBe("agent-custom");
+    expect(savedEdit[0]).toEqual({
+      ...original,
+      persona: { ...original.persona, nome: "zaip_agent_research", cargo: "agent" },
+    });
+    expect(
+      applyAgentEditorDraft([original], {
+        sourceId: original.id,
+        agent: edited,
+        removeOnSave: true,
+      }),
+    ).toEqual([]);
+
+    const added = createCustomAgent([original]);
+    expect(
+      applyAgentEditorDraft([original], {
+        sourceId: null,
+        agent: added,
+        removeOnSave: false,
+      }),
+    ).toEqual([original, added]);
+    expect(original.id).toBe("agent-custom");
+  });
+
+  it("keeps the compact card and modal accessibility contracts explicit", () => {
+    expect(componentSource).toContain('add: "Adicionar agente"');
+    expect(componentSource.indexOf('className="agent-catalog-back"')).toBeLessThan(
+      componentSource.indexOf('className="agent-catalog-add"'),
+    );
+    expect(componentSource).not.toContain('className="agent-catalog-actions"');
+    expect(componentSource).toContain('role="dialog"');
+    expect(componentSource).toContain('aria-modal="true"');
+    expect(componentSource).toContain('aria-labelledby="agent-catalog-editor-title"');
+    expect(componentSource).toContain('event.key === "Escape"');
+    expect(componentSource).toContain('document.body.style.overflow = "hidden"');
+    expect(componentSource).toContain(
+      "restoreAgentCatalogFocus(openerRef.current, addButtonRef.current)",
+    );
+    expect(stylesheetSource).toContain("-webkit-line-clamp: 3");
+    expect(stylesheetSource).toContain("min-height: calc(1.5em * 3)");
+    expect(stylesheetSource).toContain("minmax(min(100%, 260px), 1fr)");
+    expect(stylesheetSource).toContain("@media (prefers-color-scheme: dark)");
+  });
+
+  it("removes the global protection notice while preserving framework safeguards", () => {
+    expect(componentSource).not.toContain("agent-catalog-protection");
+    expect(stylesheetSource).not.toContain(".agent-catalog-protection");
+    expect(componentSource).not.toContain("protectedTitle");
+    expect(componentSource).not.toContain("protectedBody");
+    expect(componentSource).not.toContain("Agentes fundamentais protegidos");
+    expect(componentSource).not.toContain("Protected foundational agents");
+    expect(componentSource).toContain("lockedHint:");
+    expect(componentSource).toContain("agent-catalog-card-lock");
+    expect(componentSource).toContain("frameworkIds.has(editor.sourceId");
+    expect(componentSource).toContain("!frameworkIds.has(editor.sourceId)");
+  });
+
+  it("uses the approved subtitle copy at full width while preserving narrow responsiveness", () => {
+    expect(componentSource).toContain(
+      "Os agentes do framework possuem edições limitadas para garantir o funcionamento.",
+    );
+    expect(componentSource).toContain(
+      "Framework agents have limited editing to ensure proper operation.",
+    );
+    const subtitleStyles = stylesheetSource.match(
+      /\.agent-catalog-header-copy > span\s*\{([^}]+)\}/,
+    )?.[1];
+    expect(subtitleStyles).toBeDefined();
+    expect(subtitleStyles).not.toContain("max-width: 760px");
+    expect(stylesheetSource).toContain("@media (max-width: 720px)");
+  });
+
+  it("keeps the modal actions clear of the bottom edge", () => {
+    expect(stylesheetSource).toContain(".agent-catalog-modal-actions {\n  align-items: center;");
+    expect(stylesheetSource).toContain("padding-bottom: 32px;");
+  });
+
+  it("keeps modal header and actions visible while only the body scrolls", () => {
+    expect(stylesheetSource).toMatch(
+      /\.agent-catalog-modal\s*\{[^}]*display: flex;[^}]*flex-direction: column;/,
+    );
+    expect(stylesheetSource).toMatch(
+      /\.agent-catalog-modal-body\s*\{[^}]*flex: 1 1 auto;[^}]*min-height: 0;[^}]*overflow-y: auto;/,
+    );
+    expect(stylesheetSource).not.toContain("max-height: calc(min(90vh, 880px) - 176px)");
+    expect(stylesheetSource).not.toContain("max-height: calc(94vh - 188px)");
+  });
+
+  it("uses the opener while connected and a stable fallback after rename or removal", () => {
+    const opener = { isConnected: true, focus: vi.fn() };
+    const fallback = { isConnected: true, focus: vi.fn() };
+
+    restoreAgentCatalogFocus(opener, fallback);
+    expect(opener.focus).toHaveBeenCalledOnce();
+    expect(fallback.focus).not.toHaveBeenCalled();
+
+    opener.isConnected = false;
+    restoreAgentCatalogFocus(opener, fallback);
+    restoreAgentCatalogFocus(null, fallback);
+    expect(opener.focus).toHaveBeenCalledOnce();
+    expect(fallback.focus).toHaveBeenCalledTimes(2);
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/dashboard-api.test.ts

@@ -0,0 +1,31 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { DashboardApiClient, reconciliationRequestTimeoutMs } from "./dashboard-api.js";
+
+describe("DashboardApiClient reconciliation", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it("keeps the manual reconciliation request alive past the normal dashboard timeout", async () => {
+    vi.useFakeTimers();
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn(
+      (_path: string, init: RequestInit) =>
+        new Promise<Response>((_resolve, reject) => {
+          init.signal?.addEventListener("abort", () =>
+            reject(new DOMException("aborted", "AbortError")),
+          );
+        }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    const pending = new DashboardApiClient("session").reconcileOpenWork();
+    const rejection = expect(pending).rejects.toThrow("125 segundos");
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(fetchMock.mock.calls[0]?.[1].signal?.aborted).toBe(false);
+
+    await vi.advanceTimersByTimeAsync(reconciliationRequestTimeoutMs - 30_000);
+    await rejection;
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/dashboard-api.ts

@@ -0,0 +1,374 @@
+import { type ApiErrorPayload, dashboardApiPaths } from "@zaip-ai/dashboard-contracts";
+import type { CostMonitorProjection } from "@zaip-ai/dashboard-cost-monitor/contracts";
+import type {
+  OperationsProjection,
+  PrdDetailProjection,
+  SpecDetailProjection,
+  TaskDetailProjection,
+} from "@zaip-ai/dashboard-operations/contracts";
+import type { TaskTrace } from "@zaip-ai/dashboard-traceability/contracts";
+
+export interface ReconciliationBlockedItem {
+  id: string;
+  reason: string | null;
+}
+
+export interface ReconciliationResult {
+  reconciled_ids: string[];
+  blocked: ReconciliationBlockedItem[];
+  not_reconciled: ReconciliationBlockedItem[];
+}
+
+export class DashboardApiClient {
+  constructor(private readonly token: string) {}
+
+  operations(
+    period?: { from: string | null; to: string | null },
+    overviewOnly = false,
+  ): Promise<OperationsProjection> {
+    const path = overviewOnly
+      ? `${dashboardApiPaths.operations}?scope=overview`
+      : dashboardApiPaths.operations;
+    return this.get(withPeriod(path, period));
+  }
+
+  costMonitor(
+    currency: "BRL" | "USD" = "BRL",
+    period?: { from: string | null; to: string | null },
+  ): Promise<CostMonitorProjection> {
+    return this.get(withPeriod(`${dashboardApiPaths.costMonitor}?currency=${currency}`, period));
+  }
+
+  snapshot(
+    currency: "BRL" | "USD" = "BRL",
+    period?: { from: string | null; to: string | null },
+  ): Promise<{
+    operations: OperationsProjection;
+    costs: CostMonitorProjection;
+    dashboard?: { title: string; repository_name: string };
+    projection: { source_latest_at: string | null; served_at: string };
+  }> {
+    return this.get(withPeriod(`${dashboardApiPaths.snapshot}?currency=${currency}`, period));
+  }
+
+  reconcileOpenWork(
+    currency: "BRL" | "USD" = "BRL",
+    period?: { from: string | null; to: string | null },
+  ): Promise<{
+    operations: OperationsProjection;
+    costs: CostMonitorProjection;
+    dashboard?: { title: string; repository_name: string };
+    projection: { source_latest_at: string | null; served_at: string };
+    reconciliation: ReconciliationResult;
+  }> {
+    return this.post(
+      withPeriod(`${dashboardApiPaths.reconcileOpenWork}?currency=${currency}`, period),
+      reconciliationRequestTimeoutMs,
+    );
+  }
+
+  task(taskId: string): Promise<TaskDetailProjection> {
+    return this.get(dashboardApiPaths.task(taskId));
+  }
+
+  prd(prdId: string): Promise<PrdDetailProjection> {
+    return this.get(dashboardApiPaths.prd(prdId));
+  }
+
+  spec(specId: string): Promise<SpecDetailProjection> {
+    return this.get(dashboardApiPaths.spec(specId));
+  }
+
+  taskTrace(taskId: string): Promise<TaskTrace> {
+    return this.get(dashboardApiPaths.taskTrace(taskId));
+  }
+
+  pricing(): Promise<PricingCatalog> {
+    return this.get("/api/v2/pricing");
+  }
+
+  async savePricing(catalog: PricingCatalog): Promise<PricingCatalog> {
+    const response = await fetch("/api/v2/pricing", {
+      method: "PUT",
+      headers: { "content-type": "application/json", "x-zaip-session": this.token },
+      body: JSON.stringify(catalog),
+    });
+    if (!response.ok) throw new Error(`Pricing update failed with HTTP ${response.status}`);
+    return (await response.json()) as PricingCatalog;
+  }
+
+  fxRate(): Promise<FxRate | null> {
+    return this.get("/api/v2/fx-rate");
+  }
+
+  agentCatalog(): Promise<AgentCatalogSettings> {
+    return this.get(dashboardApiPaths.agentCatalog);
+  }
+
+  agentPortraitUrl(agentId: string): string {
+    return `/api/v2/agent-catalog-assets/${encodeURIComponent(agentId)}?token=${encodeURIComponent(this.token)}`;
+  }
+
+  projectSettings(): Promise<ProjectConfigSettings> {
+    return this.get(dashboardApiPaths.projectSettings);
+  }
+
+  async saveProjectSettings(config: ProjectConfigSettings): Promise<ProjectConfigSettings> {
+    const response = await fetch(dashboardApiPaths.projectSettings, {
+      method: "PUT",
+      headers: { "content-type": "application/json", "x-zaip-session": this.token },
+      body: JSON.stringify(config),
+    });
+    if (!response.ok) {
+      const payload = (await response.json().catch(() => null)) as ApiErrorPayload | null;
+      throw new Error(
+        payload?.error ?? `Project settings update failed with HTTP ${response.status}`,
+      );
+    }
+    return (await response.json()) as ProjectConfigSettings;
+  }
+
+  async saveAgentCatalog(agents: AgentCatalogAgent[]): Promise<AgentCatalogSettings> {
+    const personaOnlyAgents = agents.map(({ nickname_candidates: _derived, ...agent }) => agent);
+    const response = await fetch(dashboardApiPaths.agentCatalog, {
+      method: "PUT",
+      headers: { "content-type": "application/json", "x-zaip-session": this.token },
+      body: JSON.stringify({ agents: personaOnlyAgents }),
+    });
+    if (!response.ok) {
+      const payload = (await response.json().catch(() => null)) as ApiErrorPayload | null;
+      throw new Error(payload?.error ?? `Agent catalog update failed with HTTP ${response.status}`);
+    }
+    return (await response.json()) as AgentCatalogSettings;
+  }
+
+  async saveFxRate(rate: number): Promise<FxRate> {
+    const response = await fetch("/api/v2/fx-rate", {
+      method: "PUT",
+      headers: { "content-type": "application/json", "x-zaip-session": this.token },
+      body: JSON.stringify({ rate }),
+    });
+    if (!response.ok) throw new Error(`FX update failed with HTTP ${response.status}`);
+    return (await response.json()) as FxRate;
+  }
+
+  private async get<Response>(path: string): Promise<Response> {
+    const response = await fetchWithTimeout(path, {
+      cache: "no-store",
+      headers: { "x-zaip-session": this.token },
+    });
+    if (!response.ok) {
+      const payload = (await response.json().catch(() => null)) as ApiErrorPayload | null;
+      throw new Error(payload?.error ?? `Dashboard API failed with HTTP ${response.status}`);
+    }
+    return (await response.json()) as Response;
+  }
+
+  private async post<Response>(
+    path: string,
+    timeoutMs = dashboardRequestTimeoutMs,
+  ): Promise<Response> {
+    const response = await fetchWithTimeout(
+      path,
+      {
+        method: "POST",
+        headers: { "x-zaip-session": this.token },
+      },
+      timeoutMs,
+    );
+    if (!response.ok) {
+      const payload = (await response.json().catch(() => null)) as ApiErrorPayload | null;
+      throw new Error(payload?.error ?? `Dashboard API failed with HTTP ${response.status}`);
+    }
+    return (await response.json()) as Response;
+  }
+}
+
+export const dashboardRequestTimeoutMs = 30_000;
+// The local runtime permits reconciliation for up to two minutes. Keep a small
+// transport margin so the browser never cancels a valid server-side operation.
+export const reconciliationRequestTimeoutMs = 125_000;
+
+export async function fetchWithTimeout(
+  path: string,
+  init: RequestInit,
+  timeoutMs = dashboardRequestTimeoutMs,
+): Promise<Response> {
+  const controller = new AbortController();
+  const timeout = window.setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(path, { ...init, signal: controller.signal });
+  } catch (cause) {
+    if (cause instanceof DOMException && cause.name === "AbortError") {
+      throw new Error(
+        `A leitura demorou mais de ${Math.ceil(timeoutMs / 1_000)} segundos. Tente novamente.`,
+      );
+    }
+    throw cause;
+  } finally {
+    window.clearTimeout(timeout);
+  }
+}
+
+function withPeriod(
+  path: string,
+  period: { from: string | null; to: string | null } | undefined,
+): string {
+  if (period === undefined) return path;
+  const url = new URL(path, "http://dashboard.local");
+  if (period.from !== null) url.searchParams.set("from", period.from);
+  if (period.to !== null) url.searchParams.set("to", period.to);
+  return `${url.pathname}${url.search}`;
+}
+
+export interface PricingModel {
+  id: string;
+  provider: "openai" | "anthropic";
+  aliases: string[];
+  input_per_million_usd: number;
+  cached_input_per_million_usd: number | null;
+  output_per_million_usd: number;
+  reasoning_per_million_usd: number | null;
+  priority_input_per_million_usd?: number | null;
+  priority_cached_input_per_million_usd?: number | null;
+  priority_output_per_million_usd?: number | null;
+  priority_reasoning_per_million_usd?: number | null;
+  reasoning_billed_separately: boolean;
+  long_context_threshold_tokens: number | null;
+  long_context_input_multiplier: number;
+  long_context_output_multiplier: number;
+  source_label: string;
+  source_url: string;
+  notes: string[];
+}
+
+export interface PricingCatalog {
+  schema_version: 1;
+  updated_at: string;
+  source: string;
+  disclaimer: string;
+  models: PricingModel[];
+}
+
+export interface FxRate {
+  schema_version: 1;
+  base: "USD";
+  quote: "BRL";
+  rate: number;
+  as_of: string;
+  source_label: string;
+  source_url: string;
+}
+
+export type AgentReasoningEffort = "low" | "medium" | "high" | "xhigh" | "ultra";
+
+export interface AgentCatalogAgent {
+  id: string;
+  version: number;
+  purpose: string;
+  codex_name: string;
+  codex_task_name: string;
+  persona: { nome: string; cargo: string; foto_url?: string };
+  role: string;
+  capabilities: string[];
+  execution_eligibility: Array<"interaction" | "delivery">;
+  model: {
+    required_capabilities: string[];
+    preferred: string[];
+    reasoning_effort?: AgentReasoningEffort;
+  };
+  [key: string]: unknown;
+}
+
+export interface AgentCatalogSettings {
+  catalog: {
+    schema_version: 1;
+    agents: AgentCatalogAgent[];
+    squads: unknown[];
+  };
+  framework_agent_ids: string[];
+  default_model: string | null;
+  default_reasoning_effort: string | null;
+  allowed_models: string[];
+  allowed_reasoning_efforts: AgentReasoningEffort[];
+  sync: {
+    required: true;
+    valid: boolean | null;
+    drifted: string[];
+  };
+}
+
+export interface ProjectConfigSettings {
+  schema_version: 1;
+  zaip?: { enabled: boolean };
+  project: {
+    id: string;
+    name: string;
+    timezone: string;
+  };
+  stack: {
+    profile: string;
+    overrides: Record<string, unknown>;
+  };
+  clients: {
+    codex: boolean;
+    claude: boolean;
+  };
+  tracking: {
+    enabled: boolean;
+    currency: string;
+    storage_mode: "tracked_sanitized" | "local_only";
+  };
+  model_orchestration?:
+    | {
+        mode: "manual";
+        default_model: "manual";
+        default_effort: "manual";
+        default_velocity: "manual";
+        notice: "always" | "mismatch";
+      }
+    | {
+        mode: "off";
+        default_model: string;
+        default_effort: string;
+        default_velocity: string;
+        notice: "always" | "mismatch";
+      }
+    | {
+        mode: "auto";
+        default_model: "gpt-5.6-terra";
+        default_effort: "medium";
+        default_velocity: "standard";
+        allowed_models: ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"];
+        allowed_efforts: ["low", "medium", "high", "xhigh"];
+        max_auto_effort: "xhigh";
+        automatic_sources: ["spec", "prd"];
+        notice: "always" | "mismatch";
+      }
+    | undefined;
+  execution?:
+    | { runtime: "manual" }
+    | {
+        runtime: "autonomous";
+        autonomous: {
+          provider: "codex" | "claude";
+          model: string;
+          max_parallelism: number;
+          lease_ms: number;
+        };
+      }
+    | undefined;
+  assurance?:
+    | {
+        version: 1;
+        standard_depth: "auto" | "base" | "elevated";
+        require_final_commit: boolean;
+      }
+    | undefined;
+  context?:
+    | {
+        canonical_roots: string[];
+        projection_roots: string[];
+      }
+    | undefined;
+}