voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/configs/environment/detect.js

@@ -1,4 +1,5 @@
 import { stat } from "node:fs/promises";
+import { renderBlocks } from "../../render/utils/transcript.js";
 import { pathExists } from "../../utils/fs.js";
 import { resolvePath } from "../../utils/path.js";
 import { normalizeEnvironmentConfig } from "./types.js";
@@ -31,10 +32,14 @@ export async function detectEnvironmentConfig(options) {
         const selection = (await promptPath({
             message: "Enter the path to an existing Python virtual environment (press Enter to skip)",
             defaultValue: ".venv",
-            prefaceLines: [
-                "",
-                "Detected Python project markers but no virtual environment directory.",
-            ],
+            prefaceLines: renderBlocks({
+                sections: [
+                    [
+                        "Detected Python project markers but no virtual environment directory.",
+                    ],
+                ],
+                leadingBlankLine: true,
+            }),
         })).trim();
         if (selection.length > 0) {
             config.python = { path: selection };

package/dist/configs/environment/errors.js

@@ -1,5 +1,5 @@
 import { WorkspaceError } from "../../workspace/errors.js";
-const DEFAULT_ENVIRONMENT_ERROR_CONTEXT = "Invalid workspace environment configuration";
+const DEFAULT_ENVIRONMENT_ERROR_CONTEXT = "Invalid `environment.yaml`";
 export class EnvironmentConfigError extends WorkspaceError {
     constructor(message) {
         super(message);
@@ -9,7 +9,7 @@ export class EnvironmentConfigError extends WorkspaceError {
 export class MissingEnvironmentConfigError extends EnvironmentConfigError {
     filePath;
     constructor(filePath) {
-        super(`Missing workspace environment configuration at ${filePath}`);
+        super("Missing `environment.yaml`.");
         this.filePath = filePath;
         this.name = "MissingEnvironmentConfigError";
     }
@@ -18,8 +18,8 @@ export class EnvironmentConfigParseError extends EnvironmentConfigError {
     filePath;
     constructor(filePath, detail) {
         super(detail
-            ? `${DEFAULT_ENVIRONMENT_ERROR_CONTEXT} (${filePath}): ${detail}`
-            : `${DEFAULT_ENVIRONMENT_ERROR_CONTEXT} at ${filePath}`);
+            ? `${DEFAULT_ENVIRONMENT_ERROR_CONTEXT}: ${detail}`
+            : DEFAULT_ENVIRONMENT_ERROR_CONTEXT);
         this.filePath = filePath;
         this.name = "EnvironmentConfigParseError";
     }

package/dist/configs/environment/loader.d.ts

@@ -1,5 +1,5 @@
 import { type EnvironmentConfig } from "./types.js";
-export declare const DEFAULT_ENVIRONMENT_FILE_DISPLAY: string;
+export declare const DEFAULT_ENVIRONMENT_FILE_DISPLAY = "environment.yaml";
 export interface LoadEnvironmentConfigOptions {
     root?: string;
     filePath?: string;

package/dist/configs/environment/loader.js

@@ -1,11 +1,11 @@
 import { parseYamlDocument, } from "../../utils/yaml-reader.js";
-import { formatWorkspacePath, resolveWorkspacePath, VORATIQ_ENVIRONMENT_FILE, } from "../../workspace/structure.js";
+import { resolveWorkspacePath, VORATIQ_ENVIRONMENT_FILE, } from "../../workspace/structure.js";
 import { createConfigLoader } from "../shared/loader-factory.js";
 import { formatYamlErrorDetail } from "../shared/yaml-error-formatter.js";
 import { EnvironmentConfigParseError, MissingEnvironmentConfigError, } from "./errors.js";
 import { environmentConfigSchema, getNodeDependencyRoots, getPythonEnvironmentPath, isNodeEnvironmentDisabled, isPythonEnvironmentDisabled, normalizeEnvironmentConfig, } from "./types.js";
-export const DEFAULT_ENVIRONMENT_FILE_DISPLAY = formatWorkspacePath(VORATIQ_ENVIRONMENT_FILE);
-const DEFAULT_ENVIRONMENT_ERROR_CONTEXT = "Failed to parse workspace environment configuration";
+export const DEFAULT_ENVIRONMENT_FILE_DISPLAY = VORATIQ_ENVIRONMENT_FILE;
+const DEFAULT_ENVIRONMENT_ERROR_CONTEXT = "Invalid `environment.yaml`";
 const loadEnvironmentConfigInternal = createConfigLoader({
     resolveFilePath: (root, options) => options.filePath ?? resolveWorkspacePath(root, VORATIQ_ENVIRONMENT_FILE),
     handleMissing: ({ filePath, options }) => {

package/dist/configs/orchestration/bootstrap.d.ts

@@ -0,0 +1,16 @@
+import { type AgentPreset } from "../agents/defaults.js";
+import type { AgentConfigEntry, AgentsConfig } from "../agents/types.js";
+export interface ResolvedPresetAgent {
+    readonly id: string;
+    readonly runOnly?: true;
+}
+export interface BootstrapOrchestrationProfiles {
+    readonly default: readonly ResolvedPresetAgent[];
+    readonly pro: readonly ResolvedPresetAgent[];
+    readonly lite: readonly ResolvedPresetAgent[];
+}
+export declare function collectEnabledAgentIdsForBootstrap(agents: readonly Pick<AgentConfigEntry, "id" | "enabled">[]): string[];
+export declare function serializeDefaultOrchestrationYaml(profiles: BootstrapOrchestrationProfiles): string;
+export declare function listEnabledAgentIdsForOrchestrationBootstrap(config: AgentsConfig): string[];
+export declare function listPresetStageAgentsForOrchestrationBootstrap(config: AgentsConfig, preset: AgentPreset): ResolvedPresetAgent[];
+export declare function buildDefaultOrchestrationTemplate(config: AgentsConfig, preset?: AgentPreset): string;

package/dist/configs/orchestration/bootstrap.js

@@ -0,0 +1,122 @@
+import { getAgentDefaultId, getAgentDefaultsForPreset, } from "../agents/defaults.js";
+const ORCHESTRATION_BOOTSTRAP_STAGE_IDS = [
+    "spec",
+    "run",
+    "reduce",
+    "verify",
+    "message",
+];
+const ORCHESTRATION_BOOTSTRAP_PRESET_PROFILES = ["pro", "lite"];
+export function collectEnabledAgentIdsForBootstrap(agents) {
+    const seen = new Set();
+    const enabledAgentIds = [];
+    for (const entry of agents) {
+        if (entry.enabled === false) {
+            continue;
+        }
+        if (seen.has(entry.id)) {
+            continue;
+        }
+        seen.add(entry.id);
+        enabledAgentIds.push(entry.id);
+    }
+    return enabledAgentIds;
+}
+export function serializeDefaultOrchestrationYaml(profiles) {
+    const lines = ["profiles:"];
+    const profileNames = [
+        "default",
+        ...ORCHESTRATION_BOOTSTRAP_PRESET_PROFILES,
+    ];
+    for (const [index, profileName] of profileNames.entries()) {
+        if (index > 0) {
+            lines.push("");
+        }
+        appendProfileYaml(lines, profileName, profiles[profileName]);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function appendProfileYaml(lines, profileName, presetAgents) {
+    lines.push(`  ${profileName}:`);
+    for (const stageId of ORCHESTRATION_BOOTSTRAP_STAGE_IDS) {
+        lines.push(`    ${stageId}:`);
+        const agents = stageId === "run" ? presetAgents : presetAgents.filter((a) => !a.runOnly);
+        if (agents.length === 0) {
+            lines.push("      agents: []");
+        }
+        else {
+            lines.push("      agents:");
+            for (const agent of agents) {
+                lines.push(`        - id: ${formatYamlScalar(agent.id)}`);
+            }
+        }
+    }
+}
+function formatYamlScalar(value) {
+    if (/^[a-z0-9_-]{1,64}$/u.test(value)) {
+        return value;
+    }
+    const escaped = value.replaceAll('"', '\\"');
+    return `"${escaped}"`;
+}
+export function listEnabledAgentIdsForOrchestrationBootstrap(config) {
+    return collectEnabledAgentIdsForBootstrap(config.agents);
+}
+export function listPresetStageAgentsForOrchestrationBootstrap(config, preset) {
+    if (preset === "manual") {
+        return [];
+    }
+    const enabledByProvider = groupEnabledAgentsByProvider(config.agents);
+    const seenAgentIds = new Set();
+    const stageAgents = [];
+    for (const agentDefault of getAgentDefaultsForPreset(preset)) {
+        const candidates = enabledByProvider.get(agentDefault.provider);
+        if (!candidates || candidates.length === 0) {
+            continue;
+        }
+        const defaultId = getAgentDefaultId(agentDefault);
+        const preferred = candidates.find((entry) => entry.id === defaultId);
+        const selectedId = preferred?.id ?? candidates[0]?.id;
+        if (!selectedId || seenAgentIds.has(selectedId)) {
+            continue;
+        }
+        seenAgentIds.add(selectedId);
+        stageAgents.push({
+            id: selectedId,
+            ...(agentDefault.runOnly ? { runOnly: true } : {}),
+        });
+    }
+    return stageAgents;
+}
+function groupEnabledAgentsByProvider(agents) {
+    const grouped = new Map();
+    for (const entry of agents) {
+        if (entry.enabled === false) {
+            continue;
+        }
+        if (!hasBinary(entry.binary)) {
+            continue;
+        }
+        const existing = grouped.get(entry.provider);
+        if (existing) {
+            existing.push(entry);
+            continue;
+        }
+        grouped.set(entry.provider, [entry]);
+    }
+    return grouped;
+}
+function hasBinary(binary) {
+    return typeof binary === "string" && binary.trim().length > 0;
+}
+export function buildDefaultOrchestrationTemplate(config, preset = "pro") {
+    const proAgents = listPresetStageAgentsForOrchestrationBootstrap(config, "pro");
+    const liteAgents = listPresetStageAgentsForOrchestrationBootstrap(config, "lite");
+    const defaultAgents = preset === "lite" ? liteAgents : preset === "manual" ? [] : proAgents;
+    return serializeDefaultOrchestrationYaml({
+        default: defaultAgents,
+        pro: proAgents,
+        lite: liteAgents,
+    });
+}

package/dist/configs/orchestration/errors.d.ts

@@ -0,0 +1,15 @@
+import { WorkspaceSetupError } from "../../workspace/errors.js";
+export declare const DEFAULT_ORCHESTRATION_ERROR_CONTEXT: "Invalid `orchestration.yaml`";
+export declare class OrchestrationConfigError extends WorkspaceSetupError {
+    constructor(message: string);
+}
+export declare class MissingOrchestrationConfigError extends OrchestrationConfigError {
+    readonly filePath: string;
+    constructor(filePath: string);
+}
+export declare class OrchestrationYamlParseError extends OrchestrationConfigError {
+    constructor(message: string);
+}
+export declare class OrchestrationSchemaValidationError extends OrchestrationConfigError {
+    constructor(message: string);
+}

package/dist/configs/orchestration/errors.js

@@ -0,0 +1,28 @@
+import { WorkspaceSetupError } from "../../workspace/errors.js";
+export const DEFAULT_ORCHESTRATION_ERROR_CONTEXT = "Invalid `orchestration.yaml`";
+export class OrchestrationConfigError extends WorkspaceSetupError {
+    constructor(message) {
+        super(message);
+        this.name = "OrchestrationConfigError";
+    }
+}
+export class MissingOrchestrationConfigError extends OrchestrationConfigError {
+    filePath;
+    constructor(filePath) {
+        super("Missing `orchestration.yaml`.");
+        this.filePath = filePath;
+        this.name = "MissingOrchestrationConfigError";
+    }
+}
+export class OrchestrationYamlParseError extends OrchestrationConfigError {
+    constructor(message) {
+        super(message);
+        this.name = "OrchestrationYamlParseError";
+    }
+}
+export class OrchestrationSchemaValidationError extends OrchestrationConfigError {
+    constructor(message) {
+        super(message);
+        this.name = "OrchestrationSchemaValidationError";
+    }
+}

package/dist/configs/orchestration/loader.d.ts

@@ -0,0 +1,9 @@
+import { type OrchestrationConfig } from "./types.js";
+export interface LoadOrchestrationConfigOptions {
+    root?: string;
+    filePath?: string;
+    agentsFilePath?: string;
+    readFile?: (path: string) => string;
+}
+export declare function loadOrchestrationConfig(options?: LoadOrchestrationConfigOptions): OrchestrationConfig;
+export declare function readOrchestrationConfig(content: string): OrchestrationConfig;

package/dist/configs/orchestration/loader.js

@@ -0,0 +1,148 @@
+import { readAgentsConfig } from "../../configs/agents/loader.js";
+import { isMissing, readUtf8File } from "../../utils/fs.js";
+import { parseYamlDocument, } from "../../utils/yaml-reader.js";
+import { resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ORCHESTRATION_FILE, } from "../../workspace/structure.js";
+import { createConfigLoader } from "../shared/loader-factory.js";
+import { DEFAULT_ORCHESTRATION_ERROR_CONTEXT, MissingOrchestrationConfigError, OrchestrationSchemaValidationError, OrchestrationYamlParseError, } from "./errors.js";
+import { ORCHESTRATION_STAGE_IDS, orchestrationConfigSchema, } from "./types.js";
+const loadOrchestrationConfigInternal = createConfigLoader({
+    resolveFilePath: (root, options) => options.filePath ?? resolveWorkspacePath(root, VORATIQ_ORCHESTRATION_FILE),
+    selectReadFile: (options) => options.readFile,
+    handleMissing: ({ filePath }) => {
+        throw new MissingOrchestrationConfigError(filePath);
+    },
+    parse: (content, context) => {
+        const config = readOrchestrationConfig(content);
+        validateStageAgentReferences(config, {
+            root: context.root,
+            agentsFilePath: context.options.agentsFilePath,
+            readFile: context.options.readFile,
+        });
+        return config;
+    },
+});
+export function loadOrchestrationConfig(options = {}) {
+    return loadOrchestrationConfigInternal(options);
+}
+export function readOrchestrationConfig(content) {
+    const parsed = parseYamlDocument(content, {
+        formatError: (detail) => formatOrchestrationYamlError(detail),
+    });
+    const result = orchestrationConfigSchema.safeParse(parsed);
+    if (!result.success) {
+        const message = formatSchemaValidationErrorMessage(result.error.issues);
+        throw new OrchestrationSchemaValidationError(message);
+    }
+    return result.data;
+}
+function validateStageAgentReferences(config, context) {
+    const agentsById = loadAgentsById(context);
+    for (const profile of Object.values(config.profiles)) {
+        for (const stageId of ORCHESTRATION_STAGE_IDS) {
+            const stage = profile[stageId];
+            for (const stageAgent of stage.agents) {
+                assertAgentEnabled(stageAgent.id, agentsById);
+            }
+        }
+    }
+}
+function assertAgentEnabled(agentId, agentsById) {
+    const matchingAgent = agentsById.get(agentId);
+    if (!matchingAgent) {
+        throw new OrchestrationSchemaValidationError(`${DEFAULT_ORCHESTRATION_ERROR_CONTEXT}: Agent ${formatAgentId(agentId)} is not defined in \`agents.yaml\`.`);
+    }
+    if (matchingAgent.enabled === false) {
+        throw new OrchestrationSchemaValidationError(`${DEFAULT_ORCHESTRATION_ERROR_CONTEXT}: Agent ${formatAgentId(agentId)} is disabled in \`agents.yaml\`.`);
+    }
+}
+function loadAgentsById(context) {
+    const { root, readFile } = context;
+    const agentsFilePath = context.agentsFilePath ?? resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
+    const read = readFile ?? defaultReadFile;
+    const agentsDisplayPath = VORATIQ_AGENTS_FILE;
+    let content;
+    try {
+        content = read(agentsFilePath);
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            throw new OrchestrationSchemaValidationError(`${DEFAULT_ORCHESTRATION_ERROR_CONTEXT}: Cannot validate stage agents because \`${agentsDisplayPath}\` is missing.`);
+        }
+        throw error;
+    }
+    let agentsConfig;
+    try {
+        agentsConfig = readAgentsConfig(content);
+    }
+    catch (error) {
+        const message = error instanceof Error && error.message
+            ? normalizeMessage(error.message)
+            : "unknown error";
+        throw new OrchestrationSchemaValidationError(`${DEFAULT_ORCHESTRATION_ERROR_CONTEXT}: Cannot validate stage agents because \`${agentsDisplayPath}\` is invalid (${message}).`);
+    }
+    const agentsById = new Map();
+    for (const [index, agent] of agentsConfig.agents.entries()) {
+        if (agentsById.has(agent.id)) {
+            throw new OrchestrationSchemaValidationError(`${DEFAULT_ORCHESTRATION_ERROR_CONTEXT}: Cannot validate stage agents because \`${agentsDisplayPath}\` has duplicate id ${formatAgentId(agent.id)} at \`agents[${index}]\`.`);
+        }
+        agentsById.set(agent.id, { enabled: agent.enabled !== false });
+    }
+    return agentsById;
+}
+function defaultReadFile(path) {
+    return readUtf8File(path, "utf8");
+}
+function formatOrchestrationYamlError(detail) {
+    const parseReason = normalizeMessage(detail.reason ??
+        detail.message ??
+        `${VORATIQ_ORCHESTRATION_FILE} contains invalid YAML`);
+    return new OrchestrationYamlParseError(`${DEFAULT_ORCHESTRATION_ERROR_CONTEXT}: ${parseReason}.`);
+}
+function formatSchemaValidationErrorMessage(issues) {
+    const issue = selectMostActionableIssue(issues);
+    if (!issue) {
+        return `${DEFAULT_ORCHESTRATION_ERROR_CONTEXT}: invalid value.`;
+    }
+    const path = formatIssuePath(issue.path);
+    if (issue.code === "unrecognized_keys") {
+        const keys = issue.keys
+            .slice()
+            .sort()
+            .map((key) => `\`${key}\``)
+            .join(", ");
+        const noun = issue.keys.length > 1 ? "keys" : "key";
+        return `${DEFAULT_ORCHESTRATION_ERROR_CONTEXT}: ${path}: unknown ${noun} ${keys}.`;
+    }
+    return `${DEFAULT_ORCHESTRATION_ERROR_CONTEXT}: ${path}: ${normalizeMessage(issue.message)}.`;
+}
+function selectMostActionableIssue(issues) {
+    const unrecognizedKeyIssue = issues.find((issue) => issue.code === "unrecognized_keys");
+    return unrecognizedKeyIssue ?? issues[0];
+}
+function formatIssuePath(path) {
+    if (path.length === 0) {
+        return "<root>";
+    }
+    let formatted = "";
+    for (const segment of path) {
+        if (typeof segment === "number") {
+            formatted += `[${segment}]`;
+            continue;
+        }
+        if (typeof segment === "symbol") {
+            const symbolLabel = segment.description ?? segment.toString();
+            formatted =
+                formatted.length === 0 ? symbolLabel : `${formatted}.${symbolLabel}`;
+            continue;
+        }
+        formatted = formatted.length === 0 ? segment : `${formatted}.${segment}`;
+    }
+    return formatted;
+}
+function normalizeMessage(message) {
+    const compact = message.replace(/\s+/gu, " ").trim();
+    return compact.replace(/[.]$/u, "");
+}
+function formatAgentId(agentId) {
+    return `\`${agentId}\``;
+}

package/dist/configs/orchestration/types.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+export declare const ORCHESTRATION_STAGE_IDS: readonly ["spec", "run", "reduce", "verify", "message"];
+export type OrchestrationStageId = (typeof ORCHESTRATION_STAGE_IDS)[number];
+export declare const orchestrationStageAgentSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strict>;
+export type OrchestrationStageAgent = z.infer<typeof orchestrationStageAgentSchema>;
+export declare const orchestrationStageSchema: z.ZodObject<{
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type OrchestrationStageConfig = z.infer<typeof orchestrationStageSchema>;
+export declare const orchestrationProfileSchema: z.ZodObject<{
+    spec: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    run: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    reduce: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    verify: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    message: z.ZodDefault<z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type OrchestrationProfile = z.infer<typeof orchestrationProfileSchema>;
+export declare const ORCHESTRATION_PROFILE_NAME_PATTERN: RegExp;
+export declare const ORCHESTRATION_PROFILE_NAME_MAX_LENGTH = 64;
+export declare const orchestrationProfileNameSchema: z.ZodString;
+export declare const orchestrationProfilesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    spec: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    run: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    reduce: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    verify: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    message: z.ZodDefault<z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export type OrchestrationProfiles = z.infer<typeof orchestrationProfilesSchema>;
+export declare const orchestrationConfigSchema: z.ZodObject<{
+    profiles: z.ZodRecord<z.ZodString, z.ZodObject<{
+        spec: z.ZodObject<{
+            agents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        run: z.ZodObject<{
+            agents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        reduce: z.ZodObject<{
+            agents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        verify: z.ZodObject<{
+            agents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        message: z.ZodDefault<z.ZodObject<{
+            agents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type OrchestrationConfig = z.infer<typeof orchestrationConfigSchema>;

package/dist/configs/orchestration/types.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { agentIdSchema } from "../agents/types.js";
+export const ORCHESTRATION_STAGE_IDS = [
+    "spec",
+    "run",
+    "reduce",
+    "verify",
+    "message",
+];
+export const orchestrationStageAgentSchema = z
+    .object({
+    id: agentIdSchema,
+})
+    .strict();
+export const orchestrationStageSchema = z
+    .object({
+    agents: z.array(orchestrationStageAgentSchema),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const seen = new Set();
+    value.agents.forEach((agent, index) => {
+        if (seen.has(agent.id)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["agents", index, "id"],
+                message: `duplicate stage agent id \`${agent.id}\``,
+            });
+            return;
+        }
+        seen.add(agent.id);
+    });
+});
+const orchestrationProfileShape = {
+    spec: orchestrationStageSchema,
+    run: orchestrationStageSchema,
+    reduce: orchestrationStageSchema,
+    verify: orchestrationStageSchema,
+    message: orchestrationStageSchema.default({ agents: [] }),
+};
+export const orchestrationProfileSchema = z
+    .object(orchestrationProfileShape)
+    .strict();
+export const ORCHESTRATION_PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/u;
+export const ORCHESTRATION_PROFILE_NAME_MAX_LENGTH = 64;
+export const orchestrationProfileNameSchema = z
+    .string()
+    .max(ORCHESTRATION_PROFILE_NAME_MAX_LENGTH, `profile name must be ${ORCHESTRATION_PROFILE_NAME_MAX_LENGTH} characters or fewer`)
+    .regex(ORCHESTRATION_PROFILE_NAME_PATTERN, "profile name must match /^[a-z0-9][a-z0-9-]*$/");
+export const orchestrationProfilesSchema = z
+    .record(orchestrationProfileNameSchema, orchestrationProfileSchema)
+    .superRefine((profiles, ctx) => {
+    if (!Object.hasOwn(profiles, "default")) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["default"],
+            message: "required",
+        });
+    }
+});
+export const orchestrationConfigSchema = z
+    .object({
+    profiles: orchestrationProfilesSchema,
+})
+    .strict();

package/dist/configs/sandbox/defaults.js

@@ -2,7 +2,12 @@ export const DEFAULT_SANDBOX_PROVIDERS = [
     {
         id: "claude",
         network: {
-            allowedDomains: ["api.anthropic.com", "console.anthropic.com"],
+            allowedDomains: [
+                "api.anthropic.com",
+                "console.anthropic.com",
+                "mcp-proxy.anthropic.com",
+                "platform.claude.com",
+            ],
             deniedDomains: [],
             allowLocalBinding: false,
         },
@@ -10,7 +15,12 @@ export const DEFAULT_SANDBOX_PROVIDERS = [
     {
         id: "codex",
         network: {
-            allowedDomains: ["api.openai.com", "chatgpt.com", "auth.openai.com"],
+            allowedDomains: [
+                "ab.chatgpt.com",
+                "api.openai.com",
+                "auth.openai.com",
+                "chatgpt.com",
+            ],
             deniedDomains: [],
             allowLocalBinding: false,
         },
@@ -19,10 +29,10 @@ export const DEFAULT_SANDBOX_PROVIDERS = [
         id: "gemini",
         network: {
             allowedDomains: [
-                "oauth2.googleapis.com",
                 "cloudcode-pa.googleapis.com",
-                "play.googleapis.com",
                 "generativelanguage.googleapis.com",
+                "oauth2.googleapis.com",
+                "play.googleapis.com",
             ],
             deniedDomains: [],
             allowLocalBinding: false,

package/dist/configs/sandbox/errors.d.ts

@@ -1,5 +1,5 @@
 import { WorkspaceSetupError } from "../../workspace/errors.js";
-export declare const DEFAULT_SANDBOX_ERROR_CONTEXT: "Invalid `.voratiq/sandbox.yaml`";
+export declare const DEFAULT_SANDBOX_ERROR_CONTEXT: "Invalid `sandbox.yaml`";
 export declare class SandboxConfigurationError extends WorkspaceSetupError {
     constructor(detail: string);
 }

package/dist/configs/sandbox/errors.js

@@ -1,5 +1,5 @@
 import { WorkspaceSetupError } from "../../workspace/errors.js";
-export const DEFAULT_SANDBOX_ERROR_CONTEXT = "Invalid `.voratiq/sandbox.yaml`";
+export const DEFAULT_SANDBOX_ERROR_CONTEXT = "Invalid `sandbox.yaml`";
 export class SandboxConfigurationError extends WorkspaceSetupError {
     constructor(detail) {
         super(detail);