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

package/dist/commands/init/agents.js

@@ -1,22 +1,30 @@
+import { getAgentDefaultId, getSupportedAgentDefaults, } from "../../configs/agents/defaults.js";
 import { readAgentsConfig } from "../../configs/agents/loader.js";
-import { renderAgentPromptPreface } from "../../render/transcripts/init.js";
 import { detectBinary } from "../../utils/binaries.js";
 import { isDefaultYamlTemplate, loadYamlConfig, persistYamlConfig, } from "../../utils/yaml.js";
 import { formatWorkspacePath, resolveWorkspacePath, VORATIQ_AGENTS_FILE, } from "../../workspace/structure.js";
-import { buildDefaultAgentsTemplate, DEFAULT_AGENT_DEFAULTS, sanitizeAgentIdFromModel, serializeAgentsConfigEntries, } from "../../workspace/templates.js";
+import { buildDefaultAgentsTemplate, serializeAgentsConfigEntries, } from "../../workspace/templates.js";
 export const AGENTS_CONFIG_DISPLAY_PATH = formatWorkspacePath(VORATIQ_AGENTS_FILE);
-export async function configureAgents(root, options) {
+export async function configureAgents(root, preset, options) {
+    void preset;
+    void options;
     const filePath = resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
     const defaultTemplate = buildDefaultAgentsTemplate();
     const loadResult = await loadYamlConfig(filePath, readAgentsConfig);
     const defaultStatus = isDefaultYamlTemplate(loadResult.snapshot, defaultTemplate);
     const configCreated = !loadResult.snapshot.exists;
-    const canInteract = canConfirm(options);
-    if (!canInteract || (!defaultStatus && loadResult.snapshot.exists)) {
-        return buildAgentSummary(loadResult.config.agents, computeZeroDetections(loadResult.config.agents), configCreated, false);
+    const lifecycle = scanWorkspaceForAgentDefaults(loadResult.config, defaultStatus, getSupportedAgentDefaults());
+    const detectedProviders = collectDetectedProviders(lifecycle.templates);
+    if (!defaultStatus && loadResult.snapshot.exists) {
+        return buildAgentSummary({
+            entries: loadResult.config.agents,
+            zeroDetections: detectedProviders.length === 0,
+            detectedProviders,
+            providerEnablementPrompted: false,
+            configCreated,
+            configUpdated: false,
+        });
     }
-    const lifecycle = scanWorkspaceForAgentDefaults(loadResult.config, defaultStatus);
-    const configChanged = await applyAgentOperatorChoices(lifecycle, options);
     const snapshotResult = finalizeAgentConfigSnapshot(lifecycle);
     const updated = await persistYamlConfig({
         filePath,
@@ -25,32 +33,44 @@ export async function configureAgents(root, options) {
         defaultTemplate,
         isDefaultTemplate: defaultStatus,
     });
-    return buildAgentSummary(snapshotResult.entries, lifecycle.zeroDetections, configCreated, updated || configChanged);
+    return buildAgentSummary({
+        entries: snapshotResult.entries,
+        zeroDetections: lifecycle.zeroDetections,
+        detectedProviders,
+        providerEnablementPrompted: false,
+        configCreated,
+        configUpdated: updated,
+    });
 }
-function scanWorkspaceForAgentDefaults(config, isDefaultTemplate) {
+function scanWorkspaceForAgentDefaults(config, isDefaultTemplate, templates) {
     const templatesById = new Map();
     for (const entry of config.agents) {
         templatesById.set(entry.id, entry);
     }
     const templateStates = [];
     const templateIds = new Set();
-    const templateEntries = DEFAULT_AGENT_DEFAULTS.map((template) => ({
+    const detectedBinaryByProvider = new Map();
+    const templateEntries = templates.map((template) => ({
         template,
-        defaultId: sanitizeAgentIdFromModel(template.model),
+        templateId: getAgentDefaultId(template),
     }));
-    for (const { template, defaultId } of templateEntries) {
-        templateIds.add(defaultId);
+    for (const { template, templateId } of templateEntries) {
+        templateIds.add(templateId);
         const existing = isDefaultTemplate
             ? undefined
-            : templatesById.get(defaultId);
-        const detectedBinary = detectBinary(template.provider);
-        const baseEntry = existing ?? buildEntryFromTemplate(template, defaultId);
+            : templatesById.get(templateId);
+        let detectedBinary = detectedBinaryByProvider.get(template.provider);
+        if (!detectedBinaryByProvider.has(template.provider)) {
+            detectedBinary = detectBinary(template.provider);
+            detectedBinaryByProvider.set(template.provider, detectedBinary);
+        }
+        const baseEntry = existing ?? buildEntryFromTemplate(template, templateId);
         const entry = cloneAgentEntry(baseEntry);
-        entry.binary = detectedBinary ?? entry.binary ?? "";
+        entry.binary = detectedBinary ?? "";
         entry.enabled = entry.enabled !== false;
         templateStates.push({
+            templateId,
             template,
-            existing,
             entry,
             detectedBinary,
         });
@@ -61,20 +81,23 @@ function scanWorkspaceForAgentDefaults(config, isDefaultTemplate) {
             userDefined.push(cloneAgentEntry(entry));
         }
     }
-    const zeroDetections = templateStates.every((state) => !hasBinary(state.entry.binary));
+    const zeroDetections = templateStates.every((state) => !hasBinary(state.detectedBinary));
     return {
         templates: templateStates,
         userDefined,
         zeroDetections,
     };
 }
-function buildEntryFromTemplate(template, defaultId) {
+function buildEntryFromTemplate(template, templateId) {
     return {
-        id: defaultId,
+        id: templateId,
         provider: template.provider,
         model: template.model,
-        enabled: false,
+        enabled: true,
         binary: "",
+        extraArgs: template.extraArgs && template.extraArgs.length > 0
+            ? [...template.extraArgs]
+            : undefined,
     };
 }
 function cloneAgentEntry(entry) {
@@ -89,43 +112,25 @@ function cloneAgentEntry(entry) {
             : undefined,
     };
 }
-async function applyAgentOperatorChoices(state, options) {
-    const confirm = options.confirm;
-    if (!confirm) {
-        state.zeroDetections = state.templates.every((templateState) => !hasBinary(templateState.entry.binary));
-        return false;
-    }
-    let firstPrompt = true;
-    let changed = false;
-    for (const templateState of state.templates) {
-        const hasDetectedBinary = hasBinary(templateState.entry.binary);
-        if (!hasDetectedBinary) {
-            templateState.entry.enabled = false;
+function collectDetectedProviders(templates) {
+    const rows = [];
+    const seenProviders = new Set();
+    for (const templateState of templates) {
+        const binary = templateState.detectedBinary?.trim();
+        if (!binary) {
             continue;
         }
-        const initialEnabled = templateState.entry.enabled !== false;
-        const defaultValue = templateState.existing !== undefined
-            ? templateState.existing.enabled !== false
-            : true;
-        const prefaceLines = renderAgentPromptPreface({
-            agentId: templateState.entry.id,
-            binaryPath: templateState.entry.binary ?? "",
-            detected: hasDetectedBinary,
-            firstPrompt,
-        });
-        const shouldEnable = await confirm({
-            message: "Enable?",
-            defaultValue,
-            prefaceLines,
-        });
-        if (shouldEnable !== initialEnabled) {
-            changed = true;
+        const provider = templateState.template.provider;
+        if (seenProviders.has(provider)) {
+            continue;
         }
-        templateState.entry.enabled = shouldEnable;
-        firstPrompt = false;
+        seenProviders.add(provider);
+        rows.push({
+            provider,
+            binary,
+        });
     }
-    state.zeroDetections = state.templates.every((templateState) => !hasBinary(templateState.entry.binary));
-    return changed;
+    return rows;
 }
 function buildFinalAgentEntries(state) {
     const finalEntries = state.templates.map((templateState) => templateState.entry);
@@ -136,14 +141,18 @@ function finalizeAgentConfigSnapshot(state) {
     const serialized = serializeAgentsConfigEntries(entries);
     return { entries, serialized };
 }
-function buildAgentSummary(entries, zeroDetections, configCreated, configUpdated) {
+function buildAgentSummary(options) {
+    const { entries, zeroDetections, detectedProviders, providerEnablementPrompted, configCreated, configUpdated, } = options;
     const enabledAgents = entries
         .filter((entry) => entry.enabled !== false)
         .map((entry) => entry.id);
     return {
         configPath: AGENTS_CONFIG_DISPLAY_PATH,
         enabledAgents,
+        agentCount: entries.length,
         zeroDetections,
+        detectedProviders: [...detectedProviders],
+        providerEnablementPrompted,
         configCreated,
         configUpdated,
     };
@@ -151,9 +160,3 @@ function buildAgentSummary(entries, zeroDetections, configCreated, configUpdated
 function hasBinary(binary) {
     return Boolean(binary && binary.trim().length > 0);
 }
-function computeZeroDetections(entries) {
-    return !entries.some((entry) => hasBinary(entry.binary));
-}
-function canConfirm(options) {
-    return Boolean(options.confirm);
-}

package/dist/commands/init/command.js

@@ -1,34 +1,53 @@
-import { writeCommandPreface } from "../../cli/output.js";
-import { buildInitializationPrompt } from "../../render/transcripts/init.js";
+import { getAgentDefaultId, getAgentDefaultsForPreset, getSupportedAgentDefaults, } from "../../configs/agents/defaults.js";
+import { readAgentsConfig } from "../../configs/agents/loader.js";
+import { buildDefaultOrchestrationTemplate } from "../../configs/orchestration/bootstrap.js";
+import { renderPresetPromptPreface } from "../../render/transcripts/init.js";
+import { normalizeConfigText, readConfigSnapshot, writeConfigIfChanged, } from "../../utils/yaml.js";
 import { createWorkspace } from "../../workspace/setup.js";
-import { formatWorkspacePath, VORATIQ_SANDBOX_FILE, } from "../../workspace/structure.js";
+import { formatWorkspacePath, resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ORCHESTRATION_FILE, VORATIQ_SANDBOX_FILE, } from "../../workspace/structure.js";
+import { listAgentPresetTemplates, serializeAgentsConfigEntries, } from "../../workspace/templates.js";
 import { configureAgents } from "./agents.js";
 import { configureEnvironment } from "./environment.js";
-import { configureEvals } from "./evals.js";
 export async function executeInitCommand(input) {
-    const { root, interactive, confirm, prompt } = input;
+    const { root, preset, presetProvided, onPresetResolved, assumeYes, interactive, confirm, prompt, } = input;
+    const agentsConfigPath = resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
+    const agentsSnapshotBeforeInit = await readConfigSnapshot(agentsConfigPath);
+    const agentsConfigMissing = !agentsSnapshotBeforeInit.exists;
+    const orchestrationConfigPath = resolveWorkspacePath(root, VORATIQ_ORCHESTRATION_FILE);
+    const orchestrationSnapshotBeforeInit = await readConfigSnapshot(orchestrationConfigPath);
+    const orchestrationConfigMissing = !orchestrationSnapshotBeforeInit.exists;
+    const resolvedPreset = await resolveAgentPreset({
+        preset,
+        presetProvided,
+        interactive,
+        prompt,
+        agentsConfigMissing,
+    });
+    onPresetResolved?.(resolvedPreset);
     const workspaceResult = await createWorkspace(root);
-    const initializationPrompt = buildInitializationPrompt();
-    writeCommandPreface(initializationPrompt);
-    const agentSummary = await configureAgents(root, {
+    await applyAgentPresetTemplate(root, resolvedPreset, {
+        presetProvided: Boolean(presetProvided),
+        agentsConfigMissing,
+    });
+    const agentSummary = await configureAgents(root, resolvedPreset, {
         interactive,
+        assumeYes,
         confirm,
     });
+    const orchestrationSummary = await reconcileOrchestrationConfig(root, {
+        orchestrationConfigMissing,
+        preset: resolvedPreset,
+    });
     const environmentSummary = await configureEnvironment(root, {
-        interactive,
-        confirm,
-        prompt,
+        interactive: false,
     });
-    const evalSummary = await configureEvals(root, {
-        interactive,
-        confirm,
-    }, environmentSummary.config);
     const sandboxSummary = buildSandboxSummary(workspaceResult);
     return {
+        preset: resolvedPreset,
         workspaceResult,
         agentSummary,
+        orchestrationSummary,
         environmentSummary,
-        evalSummary,
         sandboxSummary,
     };
 }
@@ -38,3 +57,268 @@ function buildSandboxSummary(workspaceResult) {
     const configCreated = normalizedCreated.includes(configPath);
     return { configPath, configCreated };
 }
+async function reconcileOrchestrationConfig(root, options) {
+    const configPath = formatWorkspacePath(VORATIQ_ORCHESTRATION_FILE);
+    const { orchestrationConfigMissing, preset } = options;
+    if (!orchestrationConfigMissing) {
+        return { configPath, configCreated: false };
+    }
+    const agentsConfigPath = resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
+    const agentsSnapshot = await readConfigSnapshot(agentsConfigPath);
+    const agentsConfig = readAgentsConfig(agentsSnapshot.content);
+    const nextContent = buildDefaultOrchestrationTemplate(agentsConfig, preset);
+    const orchestrationConfigPath = resolveWorkspacePath(root, VORATIQ_ORCHESTRATION_FILE);
+    const orchestrationSnapshot = await readConfigSnapshot(orchestrationConfigPath);
+    const baseline = orchestrationSnapshot.exists
+        ? orchestrationSnapshot.normalized
+        : "__missing__";
+    await writeConfigIfChanged(orchestrationConfigPath, nextContent, baseline);
+    return { configPath, configCreated: true };
+}
+async function applyAgentPresetTemplate(root, preset, options) {
+    const { presetProvided, agentsConfigMissing } = options;
+    // Only switch managed presets when the operator explicitly requests it.
+    // The exception is the first run where the config is missing.
+    if (!agentsConfigMissing && !presetProvided) {
+        return;
+    }
+    const filePath = resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
+    const snapshot = await readConfigSnapshot(filePath);
+    const knownTemplates = listAgentPresetTemplates();
+    const knownNormalized = new Set(knownTemplates.map((descriptor) => normalizeConfigText(descriptor.template)));
+    const selected = knownTemplates.find((descriptor) => descriptor.preset === preset);
+    if (!selected) {
+        return;
+    }
+    const shouldConsiderApplying = !snapshot.exists || knownNormalized.has(snapshot.normalized);
+    if (shouldConsiderApplying) {
+        const baseline = snapshot.exists ? snapshot.normalized : "__missing__";
+        await writeConfigIfChanged(filePath, selected.template, baseline);
+        return;
+    }
+    if (!presetProvided) {
+        return;
+    }
+    // Fall back to semantic "managed" detection: allow switching between presets
+    // without requiring a byte-for-byte match on the template (binary / enabled
+    // often diverge after initialization).
+    const config = tryReadAgentsConfig(snapshot.content);
+    if (!config) {
+        return;
+    }
+    const managedCatalogEntries = retargetManagedCatalogEntries(config);
+    if (managedCatalogEntries) {
+        const serialized = serializeAgentsConfigEntries(managedCatalogEntries);
+        await writeConfigIfChanged(filePath, serialized, snapshot.normalized);
+        return;
+    }
+    const managedPreset = detectManagedAgentsPreset(config);
+    if (!managedPreset) {
+        return;
+    }
+    if (managedPreset === preset) {
+        return;
+    }
+    const updatedEntries = retargetManagedAgentEntries(config, managedPreset);
+    if (!updatedEntries) {
+        return;
+    }
+    const serialized = serializeAgentsConfigEntries(updatedEntries);
+    await writeConfigIfChanged(filePath, serialized, snapshot.normalized);
+}
+async function resolveAgentPreset(options) {
+    const { preset, presetProvided = false, interactive, prompt, agentsConfigMissing, } = options;
+    if (presetProvided) {
+        return preset;
+    }
+    if (!interactive || !prompt) {
+        return preset;
+    }
+    if (!agentsConfigMissing) {
+        return preset;
+    }
+    return promptForPresetSelection(prompt);
+}
+async function promptForPresetSelection(prompt) {
+    const choices = {
+        "1": "pro",
+        "2": "lite",
+        "3": "manual",
+    };
+    let firstPrompt = true;
+    for (;;) {
+        const response = await prompt({
+            message: "[1]",
+            prefaceLines: renderPresetPromptPreface(firstPrompt),
+        });
+        const trimmed = response.trim();
+        const normalized = trimmed.length === 0 ? "1" : trimmed;
+        const selected = choices[normalized];
+        if (selected) {
+            return selected;
+        }
+        process.stdout.write("Please choose 1, 2, or 3.\n");
+        firstPrompt = false;
+    }
+}
+function tryReadAgentsConfig(content) {
+    try {
+        return readAgentsConfig(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildCatalogRoster() {
+    return getSupportedAgentDefaults().map((agentDefault) => ({
+        id: getAgentDefaultId(agentDefault),
+        provider: agentDefault.provider,
+        model: agentDefault.model,
+        extraArgs: agentDefault.extraArgs && agentDefault.extraArgs.length > 0
+            ? [...agentDefault.extraArgs]
+            : undefined,
+    }));
+}
+function buildPresetRoster(preset) {
+    if (preset === "manual") {
+        return [];
+    }
+    return getAgentDefaultsForPreset(preset).map((agentDefault) => ({
+        id: getAgentDefaultId(agentDefault),
+        provider: agentDefault.provider,
+        model: agentDefault.model,
+        extraArgs: agentDefault.extraArgs && agentDefault.extraArgs.length > 0
+            ? [...agentDefault.extraArgs]
+            : undefined,
+    }));
+}
+function detectManagedAgentsPreset(config) {
+    const catalogSignatures = new Map();
+    for (const signature of buildCatalogRoster()) {
+        catalogSignatures.set(signature.id, signature);
+    }
+    const entriesById = new Map();
+    for (const entry of config.agents) {
+        if (entriesById.has(entry.id)) {
+            return undefined;
+        }
+        const catalogSignature = catalogSignatures.get(entry.id);
+        if (catalogSignature &&
+            (entry.provider !== catalogSignature.provider ||
+                entry.model !== catalogSignature.model)) {
+            return undefined;
+        }
+        entriesById.set(entry.id, entry);
+    }
+    const candidates = ["pro", "lite"];
+    for (const preset of candidates) {
+        const roster = buildPresetRoster(preset);
+        if (roster.length === 0) {
+            continue;
+        }
+        const rosterIds = new Set(roster.map((signature) => signature.id));
+        const hasCatalogEntriesOutsideRoster = config.agents.some((entry) => {
+            if (!catalogSignatures.has(entry.id)) {
+                return false;
+            }
+            return !rosterIds.has(entry.id);
+        });
+        if (hasCatalogEntriesOutsideRoster) {
+            continue;
+        }
+        let matches = true;
+        for (const signature of roster) {
+            const existing = entriesById.get(signature.id);
+            if (!existing ||
+                existing.provider !== signature.provider ||
+                existing.model !== signature.model) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) {
+            return preset;
+        }
+    }
+    return undefined;
+}
+function retargetManagedAgentEntries(config, fromPreset) {
+    const fromRoster = buildPresetRoster(fromPreset);
+    const fromIds = new Set(fromRoster.map((entry) => entry.id));
+    const priorManagedAgents = config.agents.filter((entry) => fromIds.has(entry.id));
+    const priorByProvider = new Map();
+    for (const entry of priorManagedAgents) {
+        if (!priorByProvider.has(entry.provider)) {
+            priorByProvider.set(entry.provider, entry);
+        }
+    }
+    const priorById = new Map(priorManagedAgents.map((entry) => [entry.id, entry]));
+    const userDefinedAgents = config.agents.filter((entry) => !fromIds.has(entry.id));
+    const targetRoster = buildCatalogRoster();
+    const targetIds = new Set(targetRoster.map((entry) => entry.id));
+    // Avoid overwriting agents that were user-defined under the previous preset.
+    for (const entry of userDefinedAgents) {
+        if (targetIds.has(entry.id)) {
+            return undefined;
+        }
+    }
+    const nextManagedAgents = targetRoster.map((signature) => {
+        const priorByIdentity = priorById.get(signature.id);
+        const prior = priorByProvider.get(signature.provider);
+        return {
+            id: signature.id,
+            provider: signature.provider,
+            model: signature.model,
+            enabled: priorByIdentity !== undefined
+                ? priorByIdentity.enabled !== false
+                : prior?.enabled !== false,
+            binary: prior?.binary ?? "",
+            extraArgs: prior?.id === signature.id
+                ? prior.extraArgs && prior.extraArgs.length > 0
+                    ? [...prior.extraArgs]
+                    : undefined
+                : signature.extraArgs && signature.extraArgs.length > 0
+                    ? [...signature.extraArgs]
+                    : undefined,
+        };
+    });
+    return [...nextManagedAgents, ...userDefinedAgents];
+}
+function retargetManagedCatalogEntries(config) {
+    const catalogRoster = buildCatalogRoster();
+    const catalogById = new Map(catalogRoster.map((signature) => [signature.id, signature]));
+    const catalogIds = new Set(catalogById.keys());
+    const entriesById = new Map();
+    for (const entry of config.agents) {
+        if (entriesById.has(entry.id)) {
+            return undefined;
+        }
+        entriesById.set(entry.id, entry);
+    }
+    for (const signature of catalogRoster) {
+        const existing = entriesById.get(signature.id);
+        if (!existing ||
+            existing.provider !== signature.provider ||
+            existing.model !== signature.model) {
+            return undefined;
+        }
+    }
+    const managedEntries = catalogRoster.map((signature) => {
+        const existing = entriesById.get(signature.id);
+        const binary = existing?.binary ?? "";
+        return {
+            id: signature.id,
+            provider: signature.provider,
+            model: signature.model,
+            enabled: existing?.enabled === false ? false : true,
+            binary,
+            extraArgs: existing?.extraArgs && existing.extraArgs.length > 0
+                ? [...existing.extraArgs]
+                : signature.extraArgs && signature.extraArgs.length > 0
+                    ? [...signature.extraArgs]
+                    : undefined,
+        };
+    });
+    const userDefinedEntries = config.agents.filter((entry) => !catalogIds.has(entry.id));
+    return [...managedEntries, ...userDefinedEntries];
+}

package/dist/commands/init/types.d.ts

@@ -1,32 +1,38 @@
 import type { EnvironmentConfig } from "../../configs/environment/types.js";
-import type { EvalSlug } from "../../configs/evals/types.js";
 import type { ConfirmationOptions, PromptOptions } from "../../render/interactions/confirmation.js";
+import type { AgentPreset } from "../../workspace/templates.js";
 import type { CreateWorkspaceResult } from "../../workspace/types.js";
 export interface InitCommandInput {
     root: string;
+    preset: AgentPreset;
+    presetProvided?: boolean;
+    onPresetResolved?: (preset: AgentPreset) => void;
+    assumeYes?: boolean;
     interactive: boolean;
     confirm?: InitConfirmationHandler;
     prompt?: InitPromptHandler;
 }
 export interface InitCommandResult {
+    preset: AgentPreset;
     workspaceResult: CreateWorkspaceResult;
     agentSummary: AgentInitSummary;
-    evalSummary: EvalInitSummary;
+    orchestrationSummary: OrchestrationInitSummary;
     environmentSummary: EnvironmentInitSummary;
     sandboxSummary: SandboxInitSummary;
 }
 export interface AgentInitSummary {
     configPath: string;
     enabledAgents: string[];
+    agentCount: number;
     zeroDetections: boolean;
+    detectedProviders: DetectedProviderSummary[];
+    providerEnablementPrompted: boolean;
     configCreated: boolean;
     configUpdated: boolean;
 }
-export interface EvalInitSummary {
-    configPath: string;
-    configuredEvals: EvalSlug[];
-    configCreated: boolean;
-    configUpdated: boolean;
+export interface DetectedProviderSummary {
+    provider: string;
+    binary: string;
 }
 export interface EnvironmentInitSummary {
     configPath: string;
@@ -39,10 +45,15 @@ export interface SandboxInitSummary {
     configPath: string;
     configCreated: boolean;
 }
+export interface OrchestrationInitSummary {
+    configPath: string;
+    configCreated: boolean;
+}
 export type InitConfirmationHandler = (options: ConfirmationOptions) => Promise<boolean>;
 export type InitPromptHandler = (options: PromptOptions) => Promise<string>;
 export interface InitConfigureOptions {
     interactive: boolean;
+    assumeYes?: boolean;
     confirm?: InitConfirmationHandler;
     prompt?: InitPromptHandler;
 }

package/dist/commands/interactive/lifecycle.d.ts

@@ -0,0 +1,15 @@
+import type { ChildProcess } from "node:child_process";
+import type { TeardownController } from "../../competition/shared/teardown.js";
+import type { InteractiveSessionRecord } from "../../domain/interactive/model/types.js";
+interface ActiveInteractiveContext {
+    root: string;
+    sessionId: string;
+    process?: ChildProcess;
+    completion?: Promise<InteractiveSessionRecord>;
+    teardown?: TeardownController;
+}
+export declare function registerActiveInteractive(context: ActiveInteractiveContext): void;
+export declare function clearActiveInteractive(sessionId: string): void;
+export declare function terminateActiveInteractive(status: "failed" | "aborted", reason?: string): Promise<void>;
+export declare function finalizeActiveInteractive(sessionId: string): Promise<void>;
+export {};