@evref-bl/dev-nexus 0.1.0-alpha.0

package/dist/nexusAutomationAgentProfile.d.ts

@@ -0,0 +1,39 @@
+import type { NexusAutomationAgentProfileIntendedUse, NexusAutomationAgentProfileConfig, NexusAutomationConfig, NexusAutomationSafetyConfig } from "./nexusAutomationConfig.js";
+export type NexusAutomationAgentCommandSource = "override" | "agent_command" | "coordinator_profile";
+export interface ResolvedNexusAutomationAgentCommand {
+    command: string;
+    source: NexusAutomationAgentCommandSource;
+    profile: NexusAutomationAgentProfileConfig | null;
+}
+export interface NexusAutomationAgentProfilePolicy {
+    id: string;
+    executor: string;
+    model: string | null;
+    version: string | null;
+    variant: string | null;
+    reasoning: string | null;
+    intelligence: string | null;
+    intendedUse: NexusAutomationAgentProfileIntendedUse;
+    safety: NexusAutomationSafetyConfig;
+    command: string | null;
+    args: string[];
+}
+export interface NexusAutomationAgentPolicy {
+    coordinatorProfileId: string | null;
+    maxConcurrentSubagents: number;
+    safety: NexusAutomationSafetyConfig;
+    coordinatorProfile: NexusAutomationAgentProfilePolicy | null;
+    profiles: NexusAutomationAgentProfilePolicy[];
+}
+export interface ResolveNexusAutomationAgentCommandOptions {
+    automationConfig: NexusAutomationConfig;
+    overrideCommand?: string;
+    commandName?: "run-once" | "schedule";
+}
+export declare class NexusAutomationAgentProfileError extends Error {
+    constructor(message: string);
+}
+export declare function resolveNexusAutomationAgentCommand(options: ResolveNexusAutomationAgentCommandOptions): ResolvedNexusAutomationAgentCommand;
+export declare function normalizeNexusAutomationAgentPolicy(automationConfig: NexusAutomationConfig): NexusAutomationAgentPolicy;
+export declare function shellCommandFromProfile(profile: NexusAutomationAgentProfileConfig): string;
+export declare function shellQuoteArgument(value: string): string;

package/dist/nexusAutomationAgentProfile.js

@@ -0,0 +1,103 @@
+export class NexusAutomationAgentProfileError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NexusAutomationAgentProfileError";
+    }
+}
+export function resolveNexusAutomationAgentCommand(options) {
+    const overrideCommand = optionalNonEmptyString(options.overrideCommand);
+    if (overrideCommand) {
+        return {
+            command: overrideCommand,
+            source: "override",
+            profile: null,
+        };
+    }
+    const configuredCommand = optionalNonEmptyString(options.automationConfig.agent.command);
+    if (configuredCommand) {
+        return {
+            command: configuredCommand,
+            source: "agent_command",
+            profile: null,
+        };
+    }
+    const coordinatorProfileId = options.automationConfig.agent.coordinatorProfileId;
+    if (!coordinatorProfileId) {
+        throw new NexusAutomationAgentProfileError(`automation ${options.commandName ?? "run"} requires --command, project config automation.agent.command, or automation.agent.coordinatorProfileId with a command-capable profile`);
+    }
+    const profile = options.automationConfig.agent.profiles.find((item) => item.id === coordinatorProfileId);
+    if (!profile) {
+        throw new NexusAutomationAgentProfileError(`automation.agent.coordinatorProfileId references missing profile: ${coordinatorProfileId}`);
+    }
+    if (!profile.command) {
+        throw new NexusAutomationAgentProfileError(`automation.agent.profiles.${coordinatorProfileId}.command must be configured for coordinator launch`);
+    }
+    return {
+        command: shellCommandFromProfile(profile),
+        source: "coordinator_profile",
+        profile,
+    };
+}
+export function normalizeNexusAutomationAgentPolicy(automationConfig) {
+    const profiles = automationConfig.agent.profiles.map((profile) => normalizeNexusAutomationAgentProfilePolicy(profile, automationConfig.safety));
+    const coordinatorProfile = profiles.find((profile) => profile.id === automationConfig.agent.coordinatorProfileId) ?? null;
+    return {
+        coordinatorProfileId: automationConfig.agent.coordinatorProfileId,
+        maxConcurrentSubagents: automationConfig.agent.maxConcurrentSubagents,
+        safety: automationConfig.safety,
+        coordinatorProfile,
+        profiles,
+    };
+}
+function normalizeNexusAutomationAgentProfilePolicy(profile, fallbackSafety) {
+    return {
+        id: requiredNonEmptyString(profile.id, "profile.id"),
+        executor: requiredNonEmptyString(profile.executor, "profile.executor"),
+        model: optionalNullableString(profile.model, "profile.model") ?? null,
+        version: optionalNullableString(profile.version, "profile.version") ?? null,
+        variant: optionalNullableString(profile.variant, "profile.variant") ?? null,
+        reasoning: optionalNullableString(profile.reasoning, "profile.reasoning") ??
+            null,
+        intelligence: optionalNullableString(profile.intelligence, "profile.intelligence") ??
+            null,
+        intendedUse: profile.intendedUse ?? "any",
+        safety: profile.safety ?? fallbackSafety,
+        command: optionalNullableString(profile.command, "profile.command") ?? null,
+        args: profile.args.map((arg) => requiredNonEmptyString(arg, "profile.args[]")),
+    };
+}
+export function shellCommandFromProfile(profile) {
+    const command = requiredNonEmptyString(profile.command, "profile.command");
+    return [command, ...profile.args.map(shellQuoteArgument)].join(" ");
+}
+export function shellQuoteArgument(value) {
+    const arg = requiredNonEmptyString(value, "profile.args[]");
+    if (/[\r\n]/u.test(arg)) {
+        throw new NexusAutomationAgentProfileError("profile args must not contain line breaks");
+    }
+    if (/^[A-Za-z0-9_./:@%+=,-]+$/u.test(arg)) {
+        return arg;
+    }
+    return `"${arg.replace(/(["\\])/gu, "\\$1")}"`;
+}
+function optionalNonEmptyString(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return requiredNonEmptyString(value, "value");
+}
+function optionalNullableString(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return requiredNonEmptyString(value, name);
+}
+function requiredNonEmptyString(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new NexusAutomationAgentProfileError(`${name} must be a non-empty string`);
+    }
+    return value.trim();
+}

package/dist/nexusAutomationAgentSurface.d.ts

@@ -0,0 +1,62 @@
+import type { NexusAutomationConfig } from "./nexusAutomationConfig.js";
+import { type GetNexusAutomationStatusOptions } from "./nexusAutomationStatus.js";
+import { type NexusPluginCapabilityProjection } from "./nexusPluginCapabilities.js";
+import type { WorkItem } from "./workTrackingTypes.js";
+export interface NexusAutomationProjectSummary {
+    id: string;
+    name: string;
+}
+export interface NexusAutomationEligibleWorkItemSummary {
+    componentId: string;
+    id: string;
+    title: string;
+    status: WorkItem["status"];
+    labels: string[];
+    assignees: string[];
+    milestone: string | null;
+    updatedAt: string | null;
+    webUrl: string | null;
+}
+export interface NexusAutomationEligibleWorkComponentSummary {
+    componentId: string;
+    componentName: string;
+    role: string;
+    sourceRoot: string | null;
+    workTrackingProvider: string | null;
+    workItems: NexusAutomationEligibleWorkItemSummary[];
+}
+export interface NexusAutomationEligibleWorkSummary {
+    projectRoot: string;
+    project: NexusAutomationProjectSummary;
+    status: string;
+    summary: string;
+    selector: NexusAutomationConfig["selector"] | null;
+    eligibleWorkItemCount: number;
+    components: NexusAutomationEligibleWorkComponentSummary[];
+}
+export interface NexusAutomationAgentProfilePolicySummary {
+    id: string;
+    executor: string;
+    model: string | null;
+    version: string | null;
+    variant: string | null;
+    reasoning: string | null;
+    intelligence: string | null;
+    intendedUse: string;
+    safety: NexusAutomationConfig["safety"];
+    commandConfigured: boolean;
+    argsCount: number;
+}
+export interface NexusAutomationAgentProfileSummary {
+    projectRoot: string;
+    project: NexusAutomationProjectSummary;
+    automationEnabled: boolean;
+    automationMode: NexusAutomationConfig["mode"] | null;
+    coordinatorProfileId: string | null;
+    maxConcurrentSubagents: number | null;
+    safety: NexusAutomationConfig["safety"] | null;
+    profiles: NexusAutomationAgentProfilePolicySummary[];
+    pluginCapabilities: NexusPluginCapabilityProjection[];
+}
+export declare function getNexusAutomationEligibleWorkSummary(options: GetNexusAutomationStatusOptions): Promise<NexusAutomationEligibleWorkSummary>;
+export declare function getNexusAutomationAgentProfileSummary(projectRoot: string): NexusAutomationAgentProfileSummary;

package/dist/nexusAutomationAgentSurface.js

@@ -0,0 +1,90 @@
+import path from "node:path";
+import { normalizeNexusAutomationAgentPolicy } from "./nexusAutomationAgentProfile.js";
+import { getNexusAutomationStatus, } from "./nexusAutomationStatus.js";
+import { projectPluginCapabilityProjections, } from "./nexusPluginCapabilities.js";
+import { loadProjectConfig } from "./nexusProjectConfig.js";
+export async function getNexusAutomationEligibleWorkSummary(options) {
+    const status = await getNexusAutomationStatus(options);
+    const componentById = new Map(status.components.map((component) => [component.id, component]));
+    const grouped = status.componentEligibleWorkItems ??
+        (status.selectedWorkItem
+            ? [
+                {
+                    componentId: status.components[0]?.id ?? "primary",
+                    workItems: [status.selectedWorkItem],
+                },
+            ]
+            : []);
+    const components = grouped
+        .filter((component) => component.workItems.length > 0)
+        .map((component) => {
+        const resolved = componentById.get(component.componentId);
+        return {
+            componentId: component.componentId,
+            componentName: resolved?.name ?? component.componentId,
+            role: resolved?.role ?? "primary",
+            sourceRoot: resolved?.sourceRoot ?? null,
+            workTrackingProvider: resolved?.workTracking?.provider ?? null,
+            workItems: component.workItems.map((item) => summarizeEligibleWorkItem(component.componentId, item)),
+        };
+    });
+    return {
+        projectRoot: status.projectRoot,
+        project: {
+            id: status.projectConfig.id,
+            name: status.projectConfig.name,
+        },
+        status: status.status,
+        summary: status.summary,
+        selector: status.automationConfig?.selector ?? null,
+        eligibleWorkItemCount: components.reduce((total, component) => total + component.workItems.length, 0),
+        components,
+    };
+}
+export function getNexusAutomationAgentProfileSummary(projectRoot) {
+    const resolvedProjectRoot = path.resolve(projectRoot);
+    const projectConfig = loadProjectConfig(resolvedProjectRoot);
+    const automationConfig = projectConfig.automation ?? null;
+    const agentPolicy = automationConfig
+        ? normalizeNexusAutomationAgentPolicy(automationConfig)
+        : null;
+    return {
+        projectRoot: resolvedProjectRoot,
+        project: {
+            id: projectConfig.id,
+            name: projectConfig.name,
+        },
+        automationEnabled: automationConfig?.enabled ?? false,
+        automationMode: automationConfig?.mode ?? null,
+        coordinatorProfileId: agentPolicy?.coordinatorProfileId ?? null,
+        maxConcurrentSubagents: agentPolicy?.maxConcurrentSubagents ?? null,
+        safety: automationConfig?.safety ?? null,
+        profiles: agentPolicy?.profiles.map((profile) => ({
+            id: profile.id,
+            executor: profile.executor,
+            model: profile.model,
+            version: profile.version,
+            variant: profile.variant,
+            reasoning: profile.reasoning,
+            intelligence: profile.intelligence,
+            intendedUse: profile.intendedUse,
+            safety: profile.safety,
+            commandConfigured: profile.command !== null,
+            argsCount: profile.args.length,
+        })) ?? [],
+        pluginCapabilities: projectPluginCapabilityProjections(projectConfig),
+    };
+}
+function summarizeEligibleWorkItem(componentId, item) {
+    return {
+        componentId,
+        id: item.id,
+        title: item.title,
+        status: item.status,
+        labels: item.labels ?? [],
+        assignees: item.assignees ?? [],
+        milestone: item.milestone ?? null,
+        updatedAt: item.updatedAt ?? null,
+        webUrl: item.webUrl ?? null,
+    };
+}

package/dist/nexusAutomationCommandExecutor.d.ts

@@ -0,0 +1,29 @@
+import { type GitRunner } from "./gitWorktreeService.js";
+import type { NexusAutomationExecutor } from "./nexusAutomationRunOnce.js";
+export interface NexusAutomationCommandRunOptions {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}
+export interface NexusAutomationCommandRunResult {
+    command: string;
+    cwd: string;
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    error?: string;
+}
+export type NexusAutomationCommandRunner = (command: string, options: NexusAutomationCommandRunOptions) => NexusAutomationCommandRunResult;
+export interface CreateNexusAutomationCommandExecutorOptions {
+    command: string;
+    runFullVerification?: boolean;
+    commandRunner?: NexusAutomationCommandRunner;
+    gitRunner?: GitRunner;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}
+export declare class NexusAutomationCommandExecutorError extends Error {
+    constructor(message: string);
+}
+export declare function createNexusAutomationCommandExecutor(options: CreateNexusAutomationCommandExecutorOptions): NexusAutomationExecutor;
+export declare function defaultNexusAutomationCommandRunner(command: string, options: NexusAutomationCommandRunOptions): NexusAutomationCommandRunResult;

package/dist/nexusAutomationCommandExecutor.js

@@ -0,0 +1,251 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { defaultGitRunner, } from "./gitWorktreeService.js";
+export class NexusAutomationCommandExecutorError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NexusAutomationCommandExecutorError";
+    }
+}
+export function createNexusAutomationCommandExecutor(options) {
+    const command = requiredNonEmptyString(options.command, "command");
+    const commandRunner = options.commandRunner ?? defaultNexusAutomationCommandRunner;
+    const gitRunner = options.gitRunner ?? defaultGitRunner;
+    return async (input) => {
+        const env = executorEnvironment(options.env ?? process.env, input);
+        const commandResult = commandRunner(command, {
+            cwd: input.worktree.worktreePath,
+            env,
+            timeoutMs: options.timeoutMs,
+        });
+        const verification = [
+            verificationFromCommandResult(commandResult),
+        ];
+        if (!commandSucceeded(commandResult)) {
+            return {
+                status: "failed",
+                summary: `Executor command failed: ${commandSummary(commandResult)}`,
+                verification,
+                commitIds: newCommitIds(input, gitRunner),
+                publicationDecision: publicationDecision(input, "failed"),
+                error: commandSummary(commandResult),
+            };
+        }
+        const verificationCommands = [
+            ...input.automationConfig.verification.focusedCommands,
+            ...(options.runFullVerification
+                ? input.automationConfig.verification.fullCommands
+                : []),
+        ];
+        for (const verificationCommand of verificationCommands) {
+            verification.push(verificationFromCommandResult(commandRunner(verificationCommand, {
+                cwd: input.worktree.worktreePath,
+                env,
+                timeoutMs: options.timeoutMs,
+            })));
+        }
+        const failedVerification = verification.filter((record) => record.status === "failed");
+        const status = input.automationConfig.verification.requirePassing &&
+            failedVerification.length > 0
+            ? "failed"
+            : "completed";
+        return {
+            status,
+            summary: executorSummary(status, verification),
+            verification,
+            commitIds: newCommitIds(input, gitRunner),
+            publicationDecision: publicationDecision(input, status),
+            ...(status === "failed"
+                ? { error: `${failedVerification.length} command(s) failed` }
+                : {}),
+        };
+    };
+}
+export function defaultNexusAutomationCommandRunner(command, options) {
+    const capture = createCommandCaptureFiles();
+    let result = null;
+    try {
+        result = spawnSync(command, {
+            cwd: options.cwd,
+            env: options.env,
+            shell: true,
+            stdio: ["ignore", capture.stdoutFd, capture.stderrFd],
+            timeout: options.timeoutMs,
+            windowsHide: true,
+        });
+    }
+    finally {
+        capture.close();
+    }
+    try {
+        return {
+            command,
+            cwd: options.cwd,
+            stdout: readOutputPreview(capture.stdoutPath),
+            stderr: readOutputPreview(capture.stderrPath),
+            exitCode: result?.status ?? null,
+            ...(result?.error ? { error: result.error.message } : {}),
+        };
+    }
+    finally {
+        capture.remove();
+    }
+}
+function createCommandCaptureFiles() {
+    const captureDir = fs.mkdtempSync(path.join(os.tmpdir(), "dev-nexus-command-"));
+    const stdoutPath = path.join(captureDir, "stdout.log");
+    const stderrPath = path.join(captureDir, "stderr.log");
+    const stdoutFd = fs.openSync(stdoutPath, "w");
+    const stderrFd = fs.openSync(stderrPath, "w");
+    let closed = false;
+    return {
+        stdoutPath,
+        stderrPath,
+        stdoutFd,
+        stderrFd,
+        close: () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            fs.closeSync(stdoutFd);
+            fs.closeSync(stderrFd);
+        },
+        remove: () => {
+            fs.rmSync(captureDir, { recursive: true, force: true });
+        },
+    };
+}
+function executorEnvironment(baseEnv, input) {
+    return {
+        ...baseEnv,
+        DEV_NEXUS_RUN_ID: input.runId,
+        DEV_NEXUS_STARTED_AT: input.startedAt,
+        DEV_NEXUS_PROJECT_ROOT: input.projectRoot,
+        DEV_NEXUS_SOURCE_ROOT: input.sourceRoot,
+        DEV_NEXUS_WORKTREE_PATH: input.worktree.worktreePath,
+        DEV_NEXUS_WORKTREE_BRANCH: input.worktree.branchName,
+        DEV_NEXUS_WORK_ITEM_ID: input.workItem.id,
+        DEV_NEXUS_WORK_ITEM_TITLE: input.workItem.title,
+        ...(input.setup.context
+            ? {
+                DEV_NEXUS_CONTEXT_FILE: input.setup.context.contextJsonPath,
+                DEV_NEXUS_BRIEFING_FILE: input.setup.context.briefingPath,
+            }
+            : {}),
+    };
+}
+function verificationFromCommandResult(result) {
+    return {
+        command: result.command,
+        status: commandStatus(result),
+        summary: commandSummary(result),
+    };
+}
+function commandStatus(result) {
+    return commandSucceeded(result) ? "passed" : "failed";
+}
+function commandSucceeded(result) {
+    return result.exitCode === 0 && !result.error;
+}
+function commandSummary(result) {
+    if (result.error) {
+        return result.error;
+    }
+    const exit = result.exitCode === null ? "no exit code" : `exit ${result.exitCode}`;
+    const output = firstNonEmptyLine(result.stderr) ?? firstNonEmptyLine(result.stdout);
+    return output ? `${exit}: ${truncate(output, 180)}` : exit;
+}
+function executorSummary(status, verification) {
+    const failed = verification.filter((record) => record.status === "failed").length;
+    const passed = verification.filter((record) => record.status === "passed").length;
+    if (status === "failed") {
+        return `Command executor failed: ${failed} failed, ${passed} passed`;
+    }
+    return `Command executor completed: ${passed} passed, ${failed} failed`;
+}
+function publicationDecision(input, status) {
+    const publication = input.automationConfig.publication;
+    if (status !== "completed") {
+        return {
+            type: "blocked",
+            remote: publication.remote,
+            targetBranch: publication.targetBranch,
+            reason: "Command executor did not complete cleanly",
+        };
+    }
+    return {
+        type: publication.strategy,
+        remote: publication.remote,
+        targetBranch: publication.targetBranch,
+        reason: publication.push
+            ? "Configured publication policy requests push; the CLI executor did not publish automatically"
+            : "Recorded configured publication policy; push is disabled",
+    };
+}
+function newCommitIds(input, gitRunner) {
+    if (!input.worktree.baseRef) {
+        return [];
+    }
+    try {
+        const result = gitRunner(["rev-list", "--reverse", `${input.worktree.baseRef}..HEAD`], input.worktree.worktreePath);
+        if (result.exitCode !== 0) {
+            return [];
+        }
+        return result.stdout
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function outputText(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return value?.toString("utf8") ?? "";
+}
+function readOutputPreview(filePath) {
+    const maxOutputBytes = 256 * 1024;
+    const stats = fs.statSync(filePath);
+    if (stats.size <= maxOutputBytes) {
+        return outputText(fs.readFileSync(filePath));
+    }
+    const chunkBytes = maxOutputBytes / 2;
+    const fd = fs.openSync(filePath, "r");
+    try {
+        const head = Buffer.alloc(chunkBytes);
+        const tail = Buffer.alloc(chunkBytes);
+        const headBytes = fs.readSync(fd, head, 0, chunkBytes, 0);
+        const tailBytes = fs.readSync(fd, tail, 0, chunkBytes, stats.size - chunkBytes);
+        const omittedBytes = stats.size - headBytes - tailBytes;
+        return [
+            head.subarray(0, headBytes).toString("utf8"),
+            `\n[dev-nexus output truncated: ${omittedBytes} bytes omitted]\n`,
+            tail.subarray(0, tailBytes).toString("utf8"),
+        ].join("");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function firstNonEmptyLine(value) {
+    return value
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find(Boolean);
+}
+function truncate(value, length) {
+    return value.length <= length ? value : `${value.slice(0, length - 3)}...`;
+}
+function requiredNonEmptyString(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new NexusAutomationCommandExecutorError(`${name} must be a non-empty string`);
+    }
+    return value.trim();
+}

package/dist/nexusAutomationConfig.d.ts

@@ -0,0 +1,114 @@
+import type { WorkStatus } from "./workTrackingTypes.js";
+export type NexusAutomationMode = "run_once" | "agent_launch";
+export type NexusAutomationSafetyProfile = "local" | "isolated" | "host-authorized";
+export type NexusAutomationPublicationStrategy = "local_only" | "direct_integration" | "review_handoff";
+export type NexusAutomationAgentProfileIntendedUse = "any" | "coordinator" | "subagent";
+export interface NexusAutomationSelectorConfig {
+    statuses: WorkStatus[];
+    labels: string[];
+    excludeLabels: string[];
+    assignees: string[];
+    search: string | null;
+    limit: number;
+}
+export interface NexusAutomationVerificationConfig {
+    focusedCommands: string[];
+    fullCommands: string[];
+    requirePassing: boolean;
+}
+export interface NexusAutomationLedgerConfig {
+    path: string;
+    retention: number;
+}
+export interface NexusAutomationLockConfig {
+    path: string;
+    staleAfterMs: number;
+}
+export interface NexusAutomationBackoffConfig {
+    failureLimit: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+}
+export interface NexusAutomationScheduleConfig {
+    enabled: boolean;
+    intervalMs: number;
+}
+export interface NexusAutomationDependencyLinkConfig {
+    source: string;
+    target: string;
+    required: boolean;
+}
+export interface NexusAutomationSetupConfig {
+    dependencyLinks: NexusAutomationDependencyLinkConfig[];
+}
+export interface NexusAutomationExecutorConfig {
+    command: string | null;
+    timeoutMs: number | null;
+    runFullVerification: boolean;
+}
+export interface NexusAutomationAgentRelaunchConfig {
+    whileEligible: boolean;
+}
+export interface NexusAutomationAgentProfileConfig {
+    id: string;
+    executor: string;
+    model: string | null;
+    version?: string | null;
+    variant?: string | null;
+    reasoning: string | null;
+    intelligence?: string | null;
+    intendedUse?: NexusAutomationAgentProfileIntendedUse;
+    safety?: NexusAutomationSafetyConfig | null;
+    command: string | null;
+    args: string[];
+}
+export interface NexusAutomationAgentConfig {
+    command: string | null;
+    timeoutMs: number | null;
+    coordinatorProfileId: string | null;
+    maxConcurrentSubagents: number;
+    profiles: NexusAutomationAgentProfileConfig[];
+    relaunch: NexusAutomationAgentRelaunchConfig;
+}
+export interface NexusAutomationTargetConfig {
+    id: string | null;
+    objective: string | null;
+    statePath: string;
+    cycleLedgerPath: string;
+    stopWhenNoEligibleWork: boolean;
+    maxCycles: number | null;
+    maxWorkItems: number | null;
+}
+export interface NexusAutomationSafetyConfig {
+    profile: NexusAutomationSafetyProfile;
+    allowHostMutation: boolean;
+    allowDependencyInstall: boolean;
+    allowLiveServices: boolean;
+}
+export interface NexusAutomationPublicationConfig {
+    strategy: NexusAutomationPublicationStrategy;
+    remote: string | null;
+    targetBranch: string | null;
+    push: boolean;
+}
+export interface NexusAutomationConfig {
+    enabled: boolean;
+    mode: NexusAutomationMode;
+    selector: NexusAutomationSelectorConfig;
+    verification: NexusAutomationVerificationConfig;
+    ledger: NexusAutomationLedgerConfig;
+    lock: NexusAutomationLockConfig;
+    backoff: NexusAutomationBackoffConfig;
+    schedule: NexusAutomationScheduleConfig;
+    setup: NexusAutomationSetupConfig;
+    executor: NexusAutomationExecutorConfig;
+    agent: NexusAutomationAgentConfig;
+    target: NexusAutomationTargetConfig;
+    safety: NexusAutomationSafetyConfig;
+    publication: NexusAutomationPublicationConfig;
+}
+export declare const defaultNexusAutomationConfig: NexusAutomationConfig;
+export declare class NexusAutomationConfigError extends Error {
+    constructor(message: string);
+}
+export declare function validateNexusAutomationConfig(value: unknown): NexusAutomationConfig | undefined;