voratiq 0.1.0-beta.21 → 0.1.0-beta.22

package/dist/commands/{init/types.d.ts → doctor/fix-types.d.ts}

@@ -2,17 +2,18 @@ import type { EnvironmentConfig } from "../../configs/environment/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 {
+export interface DoctorBootstrapInput {
     root: string;
     preset: AgentPreset;
     presetProvided?: boolean;
     onPresetResolved?: (preset: AgentPreset) => void;
     assumeYes?: boolean;
     interactive: boolean;
-    confirm?: InitConfirmationHandler;
-    prompt?: InitPromptHandler;
+    confirm?: DoctorConfirmationHandler;
+    prompt?: DoctorPromptHandler;
 }
-export interface InitCommandResult {
+export interface DoctorBootstrapResult {
+    mode: "bootstrap" | "repair";
     preset: AgentPreset;
     workspaceResult: CreateWorkspaceResult;
     agentSummary: AgentInitSummary;
@@ -29,6 +30,7 @@ export interface AgentInitSummary {
     providerEnablementPrompted: boolean;
     configCreated: boolean;
     configUpdated: boolean;
+    managed: boolean;
 }
 export interface DetectedProviderSummary {
     provider: string;
@@ -48,12 +50,31 @@ export interface SandboxInitSummary {
 export interface OrchestrationInitSummary {
     configPath: string;
     configCreated: boolean;
+    configUpdated?: boolean;
 }
-export type InitConfirmationHandler = (options: ConfirmationOptions) => Promise<boolean>;
-export type InitPromptHandler = (options: PromptOptions) => Promise<string>;
-export interface InitConfigureOptions {
+export type DoctorConfirmationHandler = (options: ConfirmationOptions) => Promise<boolean>;
+export type DoctorPromptHandler = (options: PromptOptions) => Promise<string>;
+export interface DoctorBootstrapConfigureOptions {
     interactive: boolean;
     assumeYes?: boolean;
-    confirm?: InitConfirmationHandler;
-    prompt?: InitPromptHandler;
+    confirm?: DoctorConfirmationHandler;
+    prompt?: DoctorPromptHandler;
+}
+export interface DoctorReconcileInput {
+    root: string;
+}
+export interface DoctorReconcileOrchestrationSummary {
+    configPath: string;
+    configCreated: boolean;
+    configUpdated: boolean;
+    skippedCustomized: boolean;
+    managed: boolean;
+    preset: AgentPreset;
+}
+export interface DoctorReconcileResult {
+    workspaceBootstrapped: boolean;
+    workspaceResult?: CreateWorkspaceResult;
+    agentSummary: AgentInitSummary;
+    environmentSummary: EnvironmentInitSummary;
+    orchestrationSummary: DoctorReconcileOrchestrationSummary;
 }

package/dist/commands/doctor/fix.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorBootstrapInput, DoctorBootstrapResult } from "./fix-types.js";
+export declare function executeDoctorBootstrap(input: DoctorBootstrapInput): Promise<DoctorBootstrapResult>;

package/dist/commands/{init/command.js → doctor/fix.js}

@@ -1,21 +1,40 @@
+import { readFile } from "node:fs/promises";
 import { getAgentDefaultId, getAgentDefaultsForPreset, getSupportedAgentDefaults, } from "../../configs/agents/defaults.js";
 import { readAgentsConfig } from "../../configs/agents/loader.js";
+import { loadEnvironmentConfig } from "../../configs/environment/loader.js";
 import { buildDefaultOrchestrationTemplate } from "../../configs/orchestration/bootstrap.js";
-import { renderPresetPromptPreface } from "../../render/transcripts/init.js";
+import { pathExists } from "../../utils/fs.js";
 import { normalizeConfigText, readConfigSnapshot, writeConfigIfChanged, } from "../../utils/yaml.js";
+import { updateManagedState } from "../../workspace/managed-state.js";
 import { createWorkspace } from "../../workspace/setup.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";
-export async function executeInitCommand(input) {
+import { bootstrapDoctorAgents } from "./agents.js";
+import { reconcileDoctorEnvironment } from "./environment.js";
+export async function executeDoctorBootstrap(input) {
     const { root, preset, presetProvided, onPresetResolved, assumeYes, interactive, confirm, prompt, } = input;
+    const workspaceExistsBeforeInit = await pathExists(resolveWorkspacePath(root));
     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 workspaceResult = await createWorkspace(root);
+    if (workspaceExistsBeforeInit) {
+        const repairedOrchestrationSummary = await repairExistingWorkspaceOrchestration(root, {
+            orchestrationConfigMissing,
+            preset,
+        });
+        const repairOnly = await buildRepairOnlySummaries(root, workspaceResult);
+        return {
+            mode: "repair",
+            preset,
+            workspaceResult,
+            ...repairOnly,
+            orchestrationSummary: repairedOrchestrationSummary ?? repairOnly.orchestrationSummary,
+        };
+    }
     const resolvedPreset = await resolveAgentPreset({
         preset,
         presetProvided,
@@ -24,12 +43,11 @@ export async function executeInitCommand(input) {
         agentsConfigMissing,
     });
     onPresetResolved?.(resolvedPreset);
-    const workspaceResult = await createWorkspace(root);
     await applyAgentPresetTemplate(root, resolvedPreset, {
         presetProvided: Boolean(presetProvided),
         agentsConfigMissing,
     });
-    const agentSummary = await configureAgents(root, resolvedPreset, {
+    const agentSummary = await bootstrapDoctorAgents(root, resolvedPreset, {
         interactive,
         assumeYes,
         confirm,
@@ -38,11 +56,13 @@ export async function executeInitCommand(input) {
         orchestrationConfigMissing,
         preset: resolvedPreset,
     });
-    const environmentSummary = await configureEnvironment(root, {
+    const environmentSummary = await reconcileDoctorEnvironment(root, {
         interactive: false,
     });
     const sandboxSummary = buildSandboxSummary(workspaceResult);
+    await refreshManagedState(root, resolvedPreset);
     return {
+        mode: "bootstrap",
         preset: resolvedPreset,
         workspaceResult,
         agentSummary,
@@ -51,6 +71,56 @@ export async function executeInitCommand(input) {
         sandboxSummary,
     };
 }
+async function buildRepairOnlySummaries(root, workspaceResult) {
+    const createdFiles = new Set(workspaceResult.createdFiles.map((value) => value.replace(/\\/g, "/")));
+    const agentsConfig = readAgentsConfig(await readFile(resolveWorkspacePath(root, VORATIQ_AGENTS_FILE), "utf8"));
+    const environmentConfig = loadEnvironmentConfig({ root, optional: true });
+    return {
+        agentSummary: {
+            configPath: formatWorkspacePath(VORATIQ_AGENTS_FILE),
+            enabledAgents: agentsConfig.agents
+                .filter((entry) => entry.enabled !== false)
+                .map((entry) => entry.id),
+            agentCount: agentsConfig.agents.length,
+            zeroDetections: agentsConfig.agents.every((entry) => (entry.binary ?? "").trim().length === 0),
+            detectedProviders: collectDetectedProvidersFromConfig(agentsConfig),
+            providerEnablementPrompted: false,
+            configCreated: createdFiles.has(formatWorkspacePath(VORATIQ_AGENTS_FILE)),
+            configUpdated: false,
+            managed: false,
+        },
+        orchestrationSummary: {
+            configPath: formatWorkspacePath(VORATIQ_ORCHESTRATION_FILE),
+            configCreated: createdFiles.has(formatWorkspacePath(VORATIQ_ORCHESTRATION_FILE)),
+            configUpdated: false,
+        },
+        environmentSummary: {
+            configPath: formatWorkspacePath("environment.yaml"),
+            detectedEntries: Object.keys(environmentConfig),
+            configCreated: createdFiles.has(formatWorkspacePath("environment.yaml")),
+            configUpdated: false,
+            config: environmentConfig,
+        },
+        sandboxSummary: buildSandboxSummary(workspaceResult),
+    };
+}
+async function repairExistingWorkspaceOrchestration(root, options) {
+    if (!options.orchestrationConfigMissing) {
+        return undefined;
+    }
+    return reconcileOrchestrationConfig(root, options);
+}
+async function refreshManagedState(root, preset) {
+    const [agentsContent, orchestrationContent] = await Promise.all([
+        readFile(resolveWorkspacePath(root, VORATIQ_AGENTS_FILE), "utf8"),
+        readFile(resolveWorkspacePath(root, VORATIQ_ORCHESTRATION_FILE), "utf8"),
+    ]);
+    await updateManagedState(root, {
+        agentsContent,
+        orchestrationContent,
+        orchestrationPreset: preset,
+    });
+}
 function buildSandboxSummary(workspaceResult) {
     const configPath = formatWorkspacePath(VORATIQ_SANDBOX_FILE);
     const normalizedCreated = workspaceResult.createdFiles.map((file) => file.replace(/\\/g, "/"));
@@ -72,8 +142,12 @@ async function reconcileOrchestrationConfig(root, options) {
     const baseline = orchestrationSnapshot.exists
         ? orchestrationSnapshot.normalized
         : "__missing__";
-    await writeConfigIfChanged(orchestrationConfigPath, nextContent, baseline);
-    return { configPath, configCreated: true };
+    const updated = await writeConfigIfChanged(orchestrationConfigPath, nextContent, baseline);
+    await updateManagedState(root, {
+        orchestrationContent: nextContent,
+        orchestrationPreset: preset,
+    });
+    return { configPath, configCreated: true, configUpdated: updated };
 }
 async function applyAgentPresetTemplate(root, preset, options) {
     const { presetProvided, agentsConfigMissing } = options;
@@ -149,7 +223,7 @@ async function promptForPresetSelection(prompt) {
     for (;;) {
         const response = await prompt({
             message: "[1]",
-            prefaceLines: renderPresetPromptPreface(firstPrompt),
+            prefaceLines: buildPresetPromptPreface(firstPrompt),
         });
         const trimmed = response.trim();
         const normalized = trimmed.length === 0 ? "1" : trimmed;
@@ -161,6 +235,19 @@ async function promptForPresetSelection(prompt) {
         firstPrompt = false;
     }
 }
+function collectDetectedProvidersFromConfig(config) {
+    const detected = [];
+    const seenProviders = new Set();
+    for (const entry of config.agents) {
+        const binary = entry.binary?.trim();
+        if (!binary || seenProviders.has(entry.provider)) {
+            continue;
+        }
+        seenProviders.add(entry.provider);
+        detected.push({ provider: entry.provider, binary });
+    }
+    return detected;
+}
 function tryReadAgentsConfig(content) {
     try {
         return readAgentsConfig(content);
@@ -242,6 +329,15 @@ function detectManagedAgentsPreset(config) {
     }
     return undefined;
 }
+function buildPresetPromptPreface(firstPrompt) {
+    const lines = [
+        "Which workspace preset would you like?",
+        "  [1] Pro (flagship)",
+        "  [2] Lite (faster/cheaper)",
+        "  [3] Manual (configure yourself)",
+    ];
+    return firstPrompt ? ["", ...lines] : lines;
+}
 function retargetManagedAgentEntries(config, fromPreset) {
     const fromRoster = buildPresetRoster(fromPreset);
     const fromIds = new Set(fromRoster.map((entry) => entry.id));

package/dist/commands/doctor/reconcile.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorReconcileInput, DoctorReconcileResult } from "./fix-types.js";
+export declare function executeDoctorReconcile(input: DoctorReconcileInput): Promise<DoctorReconcileResult>;

package/dist/commands/doctor/reconcile.js

@@ -0,0 +1,101 @@
+import { readFile } from "node:fs/promises";
+import { readAgentsConfig } from "../../configs/agents/loader.js";
+import { buildDefaultOrchestrationTemplate } from "../../configs/orchestration/bootstrap.js";
+import { pathExists } from "../../utils/fs.js";
+import { readConfigSnapshot, writeConfigIfChanged } from "../../utils/yaml.js";
+import { computeManagedFingerprint, isManagedFingerprintMatch, readManagedState, updateManagedState, } from "../../workspace/managed-state.js";
+import { createWorkspace } from "../../workspace/setup.js";
+import { formatWorkspacePath, resolveWorkspacePath, VORATIQ_ORCHESTRATION_FILE, } from "../../workspace/structure.js";
+import { reconcileManagedDoctorAgents } from "./agents.js";
+import { reconcileDoctorEnvironment } from "./environment.js";
+export async function executeDoctorReconcile(input) {
+    const { root } = input;
+    const workspaceDirExists = await pathExists(resolveWorkspacePath(root));
+    const workspaceResult = workspaceDirExists
+        ? undefined
+        : await createWorkspace(root);
+    const agentSummary = await reconcileManagedDoctorAgents(root);
+    const environmentSummary = await reconcileDoctorEnvironment(root, {
+        interactive: false,
+    });
+    const orchestrationSummary = await reconcileManagedOrchestration(root);
+    const [agentsContent, orchestrationContent] = await Promise.all([
+        readFile(resolveWorkspacePath(root, "agents.yaml"), "utf8"),
+        readFile(resolveWorkspacePath(root, "orchestration.yaml"), "utf8"),
+    ]);
+    await updateManagedState(root, {
+        ...(agentSummary.managed ? { agentsContent } : {}),
+        ...(orchestrationSummary.managed
+            ? {
+                orchestrationContent,
+                orchestrationPreset: orchestrationSummary.preset,
+            }
+            : {}),
+    });
+    return {
+        workspaceBootstrapped: !workspaceDirExists,
+        workspaceResult,
+        agentSummary,
+        environmentSummary,
+        orchestrationSummary,
+    };
+}
+async function reconcileManagedOrchestration(root) {
+    const configPath = formatWorkspacePath(VORATIQ_ORCHESTRATION_FILE);
+    const filePath = resolveWorkspacePath(root, VORATIQ_ORCHESTRATION_FILE);
+    const agentsPath = resolveWorkspacePath(root, "agents.yaml");
+    const [snapshot, agentsContent, managedState] = await Promise.all([
+        readConfigSnapshot(filePath),
+        readFile(agentsPath, "utf8"),
+        readManagedState(root),
+    ]);
+    const agentsConfig = readAgentsConfig(agentsContent);
+    const preset = managedState?.configs.orchestration?.preset ??
+        inferManagedPreset(snapshot.content, agentsConfig) ??
+        "pro";
+    const desired = buildDefaultOrchestrationTemplate(agentsConfig, preset);
+    const managed = !snapshot.exists ||
+        isManagedFingerprintMatch(managedState?.configs.orchestration, snapshot.content) ||
+        computeManagedFingerprint(snapshot.content) ===
+            computeManagedFingerprint(desired);
+    if (!snapshot.exists) {
+        await writeConfigIfChanged(filePath, desired, "__missing__");
+        return {
+            configPath,
+            configCreated: true,
+            configUpdated: true,
+            skippedCustomized: false,
+            managed: true,
+            preset,
+        };
+    }
+    if (!managed) {
+        return {
+            configPath,
+            configCreated: false,
+            configUpdated: false,
+            skippedCustomized: true,
+            managed: false,
+            preset,
+        };
+    }
+    const updated = await writeConfigIfChanged(filePath, desired, snapshot.normalized);
+    return {
+        configPath,
+        configCreated: false,
+        configUpdated: updated,
+        skippedCustomized: false,
+        managed: true,
+        preset,
+    };
+}
+function inferManagedPreset(content, agentsConfig) {
+    const normalized = computeManagedFingerprint(content);
+    for (const preset of ["pro", "lite", "manual"]) {
+        const candidate = buildDefaultOrchestrationTemplate(agentsConfig, preset);
+        if (computeManagedFingerprint(candidate) === normalized) {
+            return preset;
+        }
+    }
+    return undefined;
+}

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

@@ -7,9 +7,11 @@ interface ActiveInteractiveContext {
     process?: ChildProcess;
     completion?: Promise<InteractiveSessionRecord>;
     teardown?: TeardownController;
+    terminationStatus?: "failed" | "aborted";
 }
 export declare function registerActiveInteractive(context: ActiveInteractiveContext): void;
 export declare function clearActiveInteractive(sessionId: string): void;
+export declare function getActiveInteractiveTerminationStatus(sessionId: string): "failed" | "aborted" | undefined;
 export declare function terminateActiveInteractive(status: "failed" | "aborted", reason?: string): Promise<void>;
 export declare function finalizeActiveInteractive(sessionId: string): Promise<void>;
 export {};

package/dist/commands/interactive/lifecycle.js

@@ -15,12 +15,19 @@ export function clearActiveInteractive(sessionId) {
         activeInteractive = undefined;
     }
 }
+export function getActiveInteractiveTerminationStatus(sessionId) {
+    if (activeInteractive?.sessionId !== sessionId) {
+        return undefined;
+    }
+    return activeInteractive.terminationStatus;
+}
 export async function terminateActiveInteractive(status, reason) {
     if (!activeInteractive || terminationInFlight) {
         return;
     }
     terminationInFlight = true;
     const context = activeInteractive;
+    context.terminationStatus = status;
     let persistenceError;
     try {
         terminateInteractiveProcess(context.process);
@@ -57,6 +64,7 @@ export async function terminateActiveInteractive(status, reason) {
             await runTeardown(context.teardown);
         }
         finally {
+            context.terminationStatus = undefined;
             terminationInFlight = false;
             activeInteractive = undefined;
         }

package/dist/commands/list/command.d.ts

@@ -6,6 +6,7 @@ export interface ListCommandInput {
     reductionsFilePath: string;
     messagesFilePath: string;
     verificationsFilePath: string;
+    interactiveFilePath: string;
     operator: ListOperator;
     sessionId?: string;
     limit?: number;