voratiq 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/workspace/managed-state.d.ts

@@ -0,0 +1,32 @@
+import type { AgentPreset } from "../configs/agents/defaults.js";
+export declare const MANAGED_STATE_VERSION = 1;
+export interface ManagedConfigFingerprint {
+    fingerprint: string;
+}
+export interface ManagedAgentsFingerprint extends ManagedConfigFingerprint {
+    managedEntriesFingerprint: string;
+}
+export interface ManagedOrchestrationFingerprint extends ManagedConfigFingerprint {
+    preset: AgentPreset;
+}
+export interface ManagedStateSnapshot {
+    version: number;
+    configs: {
+        agents?: ManagedAgentsFingerprint;
+        orchestration?: ManagedOrchestrationFingerprint;
+    };
+}
+export interface UpdateManagedStateOptions {
+    agentsContent?: string;
+    orchestrationContent?: string;
+    orchestrationPreset?: AgentPreset;
+}
+export declare function readManagedState(root: string): Promise<ManagedStateSnapshot | undefined>;
+export declare function updateManagedState(root: string, options: UpdateManagedStateOptions): Promise<{
+    path: string;
+    created: boolean;
+    updated: boolean;
+}>;
+export declare function computeManagedFingerprint(content: string): string;
+export declare function isManagedFingerprintMatch(fingerprint: ManagedConfigFingerprint | undefined, content: string): boolean;
+export declare function isManagedAgentsFingerprintMatch(fingerprint: ManagedAgentsFingerprint | undefined, content: string): boolean;

package/dist/workspace/managed-state.js

@@ -0,0 +1,104 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import { getAgentDefaultId, getSupportedAgentDefaults, } from "../configs/agents/defaults.js";
+import { readAgentsConfig } from "../configs/agents/loader.js";
+import { isFileSystemError } from "../utils/fs.js";
+import { normalizeConfigText } from "../utils/yaml.js";
+import { VORATIQ_MANAGED_STATE_FILE } from "./constants.js";
+import { resolveWorkspacePath } from "./path-resolvers.js";
+import { serializeAgentsConfigEntries } from "./templates.js";
+export const MANAGED_STATE_VERSION = 1;
+export async function readManagedState(root) {
+    const path = resolveWorkspacePath(root, VORATIQ_MANAGED_STATE_FILE);
+    try {
+        const content = await readFile(path, "utf8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (isFileSystemError(error) && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export async function updateManagedState(root, options) {
+    const path = resolveWorkspacePath(root, VORATIQ_MANAGED_STATE_FILE);
+    const existing = await readManagedState(root);
+    const next = existing
+        ? {
+            ...existing,
+            version: MANAGED_STATE_VERSION,
+            configs: { ...existing.configs },
+        }
+        : { version: MANAGED_STATE_VERSION, configs: {} };
+    if (options.agentsContent !== undefined) {
+        next.configs.agents = {
+            fingerprint: computeManagedFingerprint(options.agentsContent),
+            managedEntriesFingerprint: computeManagedAgentsEntriesFingerprint(options.agentsContent),
+        };
+    }
+    if (options.orchestrationContent !== undefined) {
+        next.configs.orchestration = {
+            fingerprint: computeManagedFingerprint(options.orchestrationContent),
+            preset: options.orchestrationPreset ?? "pro",
+        };
+    }
+    const serialized = serializeManagedState(next);
+    const previousSerialized = existing ? serializeManagedState(existing) : "";
+    if (serialized === previousSerialized) {
+        return { path, created: false, updated: false };
+    }
+    await writeFile(path, serialized, "utf8");
+    return {
+        path,
+        created: existing === undefined,
+        updated: true,
+    };
+}
+export function computeManagedFingerprint(content) {
+    return createHash("sha256")
+        .update(normalizeConfigText(content), "utf8")
+        .digest("hex");
+}
+export function isManagedFingerprintMatch(fingerprint, content) {
+    if (!fingerprint) {
+        return false;
+    }
+    return fingerprint.fingerprint === computeManagedFingerprint(content);
+}
+export function isManagedAgentsFingerprintMatch(fingerprint, content) {
+    if (!fingerprint) {
+        return false;
+    }
+    return (fingerprint.fingerprint === computeManagedFingerprint(content) ||
+        fingerprint.managedEntriesFingerprint ===
+            computeManagedAgentsEntriesFingerprint(content));
+}
+function serializeManagedState(state) {
+    return `${JSON.stringify(state, null, 2)}\n`;
+}
+function computeManagedAgentsEntriesFingerprint(content) {
+    const config = readAgentsConfig(content);
+    const entriesById = new Map();
+    for (const entry of config.agents) {
+        entriesById.set(entry.id, normalizeAgentEntry(entry));
+    }
+    const managedEntries = getSupportedAgentDefaults()
+        .map((template) => entriesById.get(getAgentDefaultId(template)))
+        .filter((entry) => entry !== undefined);
+    return createHash("sha256")
+        .update(normalizeConfigText(`agents:\n${serializeAgentsConfigEntries(managedEntries)}`), "utf8")
+        .digest("hex");
+}
+function normalizeAgentEntry(entry) {
+    return {
+        id: entry.id,
+        provider: entry.provider,
+        model: entry.model,
+        enabled: entry.enabled !== false,
+        binary: entry.binary ?? "",
+        extraArgs: entry.extraArgs && entry.extraArgs.length > 0
+            ? [...entry.extraArgs]
+            : undefined,
+    };
+}

package/dist/workspace/path-formatters.d.ts

@@ -0,0 +1,9 @@
+export declare function formatWorkspacePath(...segments: string[]): string;
+export declare function assertPathSegment(label: "runId" | "agentId" | "segment" | "domain" | "sessionId", value: string): string;
+export declare function assertDomainSegment(domain: string): string;
+export declare function assertSessionId(sessionId: string): string;
+export declare function formatDomainScopedPath(domain: string, ...segments: string[]): string;
+export declare function formatSessionScopedPath(domain: string, sessionId: string, ...segments: string[]): string;
+export declare function formatAgentSessionScopedPath(domain: string, sessionId: string, agentId: string, ...segments: string[]): string;
+export declare function formatRunScopedPath(runId: string, ...segments: string[]): string;
+export declare function formatAgentScopedPath(runId: string, agentId: string, ...segments: string[]): string;

package/dist/workspace/path-formatters.js

@@ -0,0 +1,46 @@
+import { agentIdSchema } from "../configs/agents/types.js";
+import { assertRepoRelativePath } from "../utils/path.js";
+import { VORATIQ_DIR, VORATIQ_RUN_DIR, VORATIQ_SESSIONS_DIRNAME, } from "./constants.js";
+export function formatWorkspacePath(...segments) {
+    return [VORATIQ_DIR, ...segments].join("/");
+}
+export function assertPathSegment(label, value) {
+    if (typeof value !== "string") {
+        throw new Error(`${label} must be a string`);
+    }
+    if (value.length === 0) {
+        throw new Error(`${label} must be non-empty`);
+    }
+    if (value.includes("/") || value.includes("\\") || value.includes("..")) {
+        throw new Error(`${label} \`${value}\` must not contain path separators`);
+    }
+    return value;
+}
+export function assertDomainSegment(domain) {
+    return assertPathSegment("domain", domain);
+}
+export function assertSessionId(sessionId) {
+    return assertPathSegment("sessionId", sessionId);
+}
+export function formatDomainScopedPath(domain, ...segments) {
+    const safeDomain = assertDomainSegment(domain);
+    const scoped = formatWorkspacePath(safeDomain, ...segments);
+    return assertRepoRelativePath(scoped);
+}
+export function formatSessionScopedPath(domain, sessionId, ...segments) {
+    const safeSessionId = assertSessionId(sessionId);
+    return formatDomainScopedPath(domain, VORATIQ_SESSIONS_DIRNAME, safeSessionId, ...segments);
+}
+export function formatAgentSessionScopedPath(domain, sessionId, agentId, ...segments) {
+    const safeAgentId = agentIdSchema.parse(agentId);
+    return formatSessionScopedPath(domain, sessionId, safeAgentId, ...segments);
+}
+export function formatRunScopedPath(runId, ...segments) {
+    const safeRunId = assertPathSegment("runId", runId);
+    const scoped = formatDomainScopedPath(VORATIQ_RUN_DIR, VORATIQ_SESSIONS_DIRNAME, safeRunId, ...segments);
+    return assertRepoRelativePath(scoped);
+}
+export function formatAgentScopedPath(runId, agentId, ...segments) {
+    const safeAgentId = agentIdSchema.parse(agentId);
+    return formatRunScopedPath(runId, safeAgentId, ...segments);
+}

package/dist/workspace/path-resolvers.d.ts

@@ -0,0 +1 @@
+export declare function resolveWorkspacePath(root: string, ...segments: string[]): string;

package/dist/workspace/path-resolvers.js

@@ -0,0 +1,5 @@
+import { resolvePathWithinRoot } from "../utils/path.js";
+import { VORATIQ_DIR } from "./constants.js";
+export function resolveWorkspacePath(root, ...segments) {
+    return resolvePathWithinRoot(root, [VORATIQ_DIR, ...segments]);
+}

package/dist/workspace/session-paths.d.ts

@@ -0,0 +1,16 @@
+export declare function getInteractiveIndexPath(): string;
+export declare function getInteractiveHistoryLockPath(): string;
+export declare function getInteractiveSessionsDirectoryPath(): string;
+export declare function getInteractiveSessionDirectoryPath(sessionId: string): string;
+export declare function getInteractiveSessionRecordPath(sessionId: string): string;
+export declare function getInteractiveSessionArtifactsDirectoryPath(sessionId: string): string;
+export declare function getSpecSessionDirectoryPath(sessionId: string): string;
+export declare function getReductionSessionDirectoryPath(sessionId: string): string;
+export declare function getMessageSessionDirectoryPath(sessionId: string): string;
+export declare function getVerificationSessionDirectoryPath(sessionId: string): string;
+export declare function getAgentSessionDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionWorkspaceDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionContextDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionArtifactsDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getRunDirectoryPath(runId: string): string;
+export declare function getAgentDirectoryPath(runId: string, agentId: string): string;

package/dist/workspace/session-paths.js

@@ -0,0 +1,59 @@
+import { ARTIFACTS_DIRNAME, CONTEXT_DIRNAME, VORATIQ_HISTORY_LOCK_FILENAME, VORATIQ_INDEX_FILENAME, VORATIQ_INTERACTIVE_DIR, VORATIQ_MESSAGE_DIR, VORATIQ_REDUCTION_DIR, VORATIQ_SESSIONS_DIRNAME, VORATIQ_SPEC_DIR, VORATIQ_VERIFICATION_DIR, WORKSPACE_DIRNAME, } from "./constants.js";
+import { formatAgentScopedPath, formatAgentSessionScopedPath, formatDomainScopedPath, formatRunScopedPath, formatSessionScopedPath, } from "./path-formatters.js";
+function getDomainIndexPath(domain) {
+    return formatDomainScopedPath(domain, VORATIQ_INDEX_FILENAME);
+}
+export function getInteractiveIndexPath() {
+    return getDomainIndexPath(VORATIQ_INTERACTIVE_DIR);
+}
+export function getInteractiveHistoryLockPath() {
+    return formatDomainScopedPath(VORATIQ_INTERACTIVE_DIR, VORATIQ_HISTORY_LOCK_FILENAME);
+}
+export function getInteractiveSessionsDirectoryPath() {
+    return getDomainSessionsDirectoryPath(VORATIQ_INTERACTIVE_DIR);
+}
+export function getInteractiveSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_INTERACTIVE_DIR, sessionId);
+}
+export function getInteractiveSessionRecordPath(sessionId) {
+    return formatSessionScopedPath(VORATIQ_INTERACTIVE_DIR, sessionId, "record.json");
+}
+export function getInteractiveSessionArtifactsDirectoryPath(sessionId) {
+    return formatSessionScopedPath(VORATIQ_INTERACTIVE_DIR, sessionId, ARTIFACTS_DIRNAME);
+}
+function getDomainSessionsDirectoryPath(domain) {
+    return formatDomainScopedPath(domain, VORATIQ_SESSIONS_DIRNAME);
+}
+function getSessionDirectoryPath(domain, sessionId) {
+    return formatSessionScopedPath(domain, sessionId);
+}
+export function getSpecSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_SPEC_DIR, sessionId);
+}
+export function getReductionSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_REDUCTION_DIR, sessionId);
+}
+export function getMessageSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_MESSAGE_DIR, sessionId);
+}
+export function getVerificationSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_VERIFICATION_DIR, sessionId);
+}
+export function getAgentSessionDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId);
+}
+export function getAgentSessionWorkspaceDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, WORKSPACE_DIRNAME);
+}
+export function getAgentSessionContextDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, CONTEXT_DIRNAME);
+}
+export function getAgentSessionArtifactsDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, ARTIFACTS_DIRNAME);
+}
+export function getRunDirectoryPath(runId) {
+    return formatRunScopedPath(runId);
+}
+export function getAgentDirectoryPath(runId, agentId) {
+    return formatAgentScopedPath(runId, agentId);
+}

package/dist/workspace/setup.js

@@ -1,13 +1,15 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve as resolveAbsolute } from "node:path";
 import { readAgentsConfig } from "../configs/agents/loader.js";
 import { loadEnvironmentConfig, } from "../configs/environment/loader.js";
 import { buildDefaultOrchestrationTemplate } from "../configs/orchestration/bootstrap.js";
 import { toErrorMessage } from "../utils/errors.js";
 import { isDirectory, isFile, pathExists } from "../utils/fs.js";
 import { relativeToRoot } from "../utils/path.js";
+import { VORATIQ_AGENTS_FILE, VORATIQ_ENVIRONMENT_FILE, VORATIQ_INTERACTIVE_DIR, VORATIQ_INTERACTIVE_FILE, VORATIQ_INTERACTIVE_SESSIONS_DIR, VORATIQ_MANAGED_STATE_FILE, VORATIQ_MESSAGE_DIR, VORATIQ_MESSAGE_FILE, VORATIQ_MESSAGE_SESSIONS_DIR, VORATIQ_ORCHESTRATION_FILE, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_REDUCTION_SESSIONS_DIR, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_RUN_SESSIONS_DIR, VORATIQ_SANDBOX_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_SPEC_SESSIONS_DIR, VORATIQ_VERIFICATION_CONFIG_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, VORATIQ_VERIFICATION_SESSIONS_DIR, VORATIQ_VERIFICATION_TEMPLATES_DIR, } from "./constants.js";
 import { WorkspaceMissingEntryError, WorkspaceNotInitializedError, WorkspaceSetupError, WorkspaceWrongTypeEntryError, } from "./errors.js";
-import { resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ENVIRONMENT_FILE, VORATIQ_INTERACTIVE_DIR, VORATIQ_INTERACTIVE_FILE, VORATIQ_INTERACTIVE_SESSIONS_DIR, VORATIQ_MESSAGE_DIR, VORATIQ_MESSAGE_FILE, VORATIQ_MESSAGE_SESSIONS_DIR, VORATIQ_ORCHESTRATION_FILE, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_REDUCTION_SESSIONS_DIR, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_RUN_SESSIONS_DIR, VORATIQ_SANDBOX_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_SPEC_SESSIONS_DIR, VORATIQ_VERIFICATION_CONFIG_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, VORATIQ_VERIFICATION_SESSIONS_DIR, VORATIQ_VERIFICATION_TEMPLATES_DIR, } from "./structure.js";
+import { updateManagedState } from "./managed-state.js";
+import { resolveWorkspacePath } from "./path-resolvers.js";
 import { buildDefaultAgentsTemplate, buildDefaultEnvironmentTemplate, buildDefaultSandboxTemplate, } from "./templates.js";
 import { buildDefaultVerificationConfigYaml, SHIPPED_VERIFICATION_TEMPLATES, } from "./verification-defaults.js";
 async function seedVerificationSurface(root, options = {}) {
@@ -99,6 +101,12 @@ const WORKSPACE_CONFIG_SEGMENTS = [
     VORATIQ_SANDBOX_FILE,
     VORATIQ_ORCHESTRATION_FILE,
 ];
+const VOLATILE_WORKSPACE_EXCLUDE_PATTERNS = [
+    "/.voratiq/*/index.json",
+    "/.voratiq/*/sessions/",
+    "/.voratiq/*/history.lock",
+];
+const VOLATILE_WORKSPACE_EXCLUDE_HEADER = "# voratiq runtime state (auto-managed)";
 export async function createWorkspace(root) {
     const createdDirectories = [];
     const createdFiles = [];
@@ -109,6 +117,7 @@ export async function createWorkspace(root) {
     const sandboxConfigPath = resolveWorkspacePath(root, VORATIQ_SANDBOX_FILE);
     const orchestrationConfigPath = resolveWorkspacePath(root, VORATIQ_ORCHESTRATION_FILE);
     const verificationConfigPath = resolveWorkspacePath(root, VORATIQ_VERIFICATION_CONFIG_FILE);
+    const managedStatePath = resolveWorkspacePath(root, VORATIQ_MANAGED_STATE_FILE);
     const workspaceExists = await pathExists(workspaceDir);
     const [agentsConfigExists, environmentConfigExists] = await Promise.all([
         pathExists(agentsConfigPath),
@@ -123,6 +132,7 @@ export async function createWorkspace(root) {
         await mkdir(workspaceDir, { recursive: true });
         createdDirectories.push(relativeToRoot(root, workspaceDir));
     }
+    await ensureWorkspaceGitExclude(root);
     for (const domain of domainStructures) {
         if (!(await pathExists(domain.directoryPath))) {
             await mkdir(domain.directoryPath, { recursive: true });
@@ -165,6 +175,20 @@ export async function createWorkspace(root) {
         });
         createdFiles.push(relativeToRoot(root, orchestrationConfigPath));
     }
+    if (!agentsConfigExists || !orchestrationConfigExists) {
+        const [agentsContent, orchestrationContent] = await Promise.all([
+            readFile(agentsConfigPath, "utf8"),
+            readFile(orchestrationConfigPath, "utf8"),
+        ]);
+        const managedStateResult = await updateManagedState(root, {
+            agentsContent,
+            orchestrationContent,
+            orchestrationPreset: "pro",
+        });
+        if (managedStateResult.created) {
+            createdFiles.push(relativeToRoot(root, managedStatePath));
+        }
+    }
     const seededVerification = await seedVerificationSurface(root, {
         verificationConfigPath,
         configExists: verificationExists,
@@ -178,6 +202,7 @@ export async function repairWorkspaceStructure(root, options = {}) {
     const createdFiles = [];
     const workspaceDir = resolveWorkspacePath(root);
     await ensureWorkspaceDirectoryEntry(root, workspaceDir);
+    await ensureWorkspaceGitExclude(root);
     // Additive repair must not mutate config semantics.
     for (const configPath of resolveWorkspaceConfigPaths(root)) {
         const kind = await detectPathKind(configPath);
@@ -359,6 +384,46 @@ async function detectPathKind(path) {
     }
     return "other";
 }
+async function ensureWorkspaceGitExclude(root) {
+    const excludePath = await resolveGitExcludePath(root);
+    if (!excludePath) {
+        return;
+    }
+    const existing = (await pathExists(excludePath))
+        ? await readFile(excludePath, "utf8")
+        : "";
+    const lines = existing.split(/\r?\n/u);
+    const missingPatterns = VOLATILE_WORKSPACE_EXCLUDE_PATTERNS.filter((pattern) => !lines.includes(pattern));
+    if (missingPatterns.length === 0) {
+        return;
+    }
+    const nextLines = existing.length > 0 && !existing.endsWith("\n")
+        ? [...lines, VOLATILE_WORKSPACE_EXCLUDE_HEADER, ...missingPatterns]
+        : [
+            ...lines.filter((line, index, all) => !(index === all.length - 1 && line === "")),
+            VOLATILE_WORKSPACE_EXCLUDE_HEADER,
+            ...missingPatterns,
+        ];
+    await mkdir(dirname(excludePath), { recursive: true });
+    await writeFile(excludePath, `${nextLines.join("\n")}\n`, "utf8");
+}
+async function resolveGitExcludePath(root) {
+    const gitEntryPath = join(root, ".git");
+    const kind = await detectPathKind(gitEntryPath);
+    if (kind === "directory") {
+        return join(gitEntryPath, "info", "exclude");
+    }
+    if (kind !== "file") {
+        return undefined;
+    }
+    const raw = await readFile(gitEntryPath, "utf8");
+    const match = raw.match(/^gitdir:\s*(.+)\s*$/mu);
+    if (!match) {
+        return undefined;
+    }
+    const gitDir = resolveAbsolute(root, match[1]);
+    return join(gitDir, "info", "exclude");
+}
 async function validateWorkspaceIndexFile(root, domain) {
     const displayPath = relativeToRoot(root, domain.indexPath);
     let raw;

package/dist/workspace/shim.d.ts

@@ -1,3 +1,4 @@
+export declare const WORKSPACE_SHIM_RELATIVE_PATH: readonly ["dist", "commands", "run", "shim", "run-agent-shim.mjs"];
 export declare function ensureWorkspaceShim(options: {
     workspacePath: string;
     cliInstallRoot?: string;

package/dist/workspace/shim.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 import { isFileSystemError } from "../utils/fs.js";
 import { resolvePath } from "../utils/path.js";
 import { WorkspaceSetupError } from "./errors.js";
-const SHIM_RELATIVE_PATH = [
+export const WORKSPACE_SHIM_RELATIVE_PATH = [
     "dist",
     "commands",
     "run",
@@ -16,8 +16,8 @@ function resolveCliInstallRoot() {
 }
 export async function ensureWorkspaceShim(options) {
     const { workspacePath, cliInstallRoot = resolveCliInstallRoot() } = options;
-    const sourcePath = resolvePath(cliInstallRoot, ...SHIM_RELATIVE_PATH);
-    const targetPath = resolvePath(workspacePath, ...SHIM_RELATIVE_PATH);
+    const sourcePath = resolvePath(cliInstallRoot, ...WORKSPACE_SHIM_RELATIVE_PATH);
+    const targetPath = resolvePath(workspacePath, ...WORKSPACE_SHIM_RELATIVE_PATH);
     try {
         await access(sourcePath);
         await mkdir(dirname(targetPath), { recursive: true });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "voratiq",
-  "version": "0.1.0-beta.21",
-  "description": "Agent ensembles to design, generate, and select the best code for every task.",
+  "version": "0.1.0-beta.23",
+  "description": "Run workflows, delegate to swarms, and verify outputs before you apply them.",
   "keywords": [
     "agent-ensembles",
     "agent-orchestration",

package/dist/cli/init.d.ts

@@ -1,15 +0,0 @@
-import { Command } from "commander";
-import type { InitCommandResult } from "../commands/init/types.js";
-import type { AgentPreset } from "../workspace/templates.js";
-import { type CommandOutputWriter } from "./output.js";
-export interface RunInitCommandResult extends InitCommandResult {
-    body: string;
-}
-export interface InitCommandOptions {
-    yes?: boolean;
-    preset?: AgentPreset;
-    presetProvided?: boolean;
-    writeOutput?: CommandOutputWriter;
-}
-export declare function runInitCommand(options?: InitCommandOptions): Promise<RunInitCommandResult>;
-export declare function createInitCommand(): Command;

package/dist/cli/init.js

@@ -1,70 +0,0 @@
-import { Command, Option } from "commander";
-import { executeInitCommand } from "../commands/init/command.js";
-import { resolveCliContext } from "../preflight/index.js";
-import { renderInitTranscript } from "../render/transcripts/init.js";
-import { AGENT_PRESET_CHOICES } from "../workspace/templates.js";
-import { createConfirmationWorkflow } from "./confirmation.js";
-import { NonInteractiveShellError } from "./errors.js";
-import { writeCommandOutput } from "./output.js";
-export async function runInitCommand(options = {}) {
-    const { writeOutput = writeCommandOutput } = options;
-    writeOutput({
-        alerts: [{ severity: "info", message: "Initializing Voratiq…" }],
-    });
-    const { root } = await resolveCliContext({ requireWorkspace: false });
-    const assumeYes = Boolean(options.yes);
-    const preset = options.preset ?? "pro";
-    const presetProvided = Boolean(options.presetProvided);
-    const confirmation = createConfirmationWorkflow({
-        assumeYes,
-        onUnavailable: () => {
-            throw new NonInteractiveShellError();
-        },
-    });
-    let wroteConfiguringPreface = false;
-    try {
-        const initResult = await executeInitCommand({
-            root,
-            preset,
-            presetProvided,
-            onPresetResolved: () => {
-                writeOutput({
-                    alerts: [{ severity: "info", message: "Configuring workspace…" }],
-                });
-                wroteConfiguringPreface = true;
-            },
-            assumeYes,
-            interactive: confirmation.interactive,
-            confirm: confirmation.confirm,
-            prompt: confirmation.prompt,
-        });
-        const body = renderInitTranscript(initResult, {
-            includeConfigurationHeading: !wroteConfiguringPreface,
-        });
-        return { ...initResult, body };
-    }
-    finally {
-        confirmation.close();
-    }
-}
-export function createInitCommand() {
-    const presetOption = new Option("--preset <preset>", "Select a preset")
-        .choices(AGENT_PRESET_CHOICES)
-        .default("pro");
-    return new Command("init")
-        .description("Initialize the Voratiq workspace")
-        .addOption(presetOption)
-        .option("-y, --yes", "Assume yes and accept defaults")
-        .allowExcessArguments(false)
-        .action(async (commandOptions, command) => {
-        const presetSource = command.getOptionValueSource("preset");
-        const presetProvided = typeof presetSource === "string" && presetSource !== "default";
-        const result = await runInitCommand({
-            ...commandOptions,
-            presetProvided,
-        });
-        writeCommandOutput({
-            body: result.body,
-        });
-    });
-}

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

@@ -1,4 +0,0 @@
-import { type AgentPreset } from "../../workspace/templates.js";
-import type { AgentInitSummary, InitConfigureOptions } from "./types.js";
-export declare const AGENTS_CONFIG_DISPLAY_PATH: string;
-export declare function configureAgents(root: string, preset: AgentPreset, options: InitConfigureOptions): Promise<AgentInitSummary>;

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

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

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

@@ -1,2 +0,0 @@
-import type { EnvironmentInitSummary, InitConfigureOptions } from "./types.js";
-export declare function configureEnvironment(root: string, options: InitConfigureOptions): Promise<EnvironmentInitSummary>;

package/dist/render/transcripts/init.d.ts

@@ -1,7 +0,0 @@
-import type { InitCommandResult } from "../../commands/init/types.js";
-export declare function renderPresetPromptPreface(firstPrompt: boolean): string[];
-interface RenderInitTranscriptOptions {
-    includeConfigurationHeading?: boolean;
-}
-export declare function renderInitTranscript({ preset, agentSummary, orchestrationSummary, environmentSummary, sandboxSummary, }: InitCommandResult, options?: RenderInitTranscriptOptions): string;
-export {};

package/dist/render/transcripts/init.js

@@ -1,83 +0,0 @@
-import { getAgentDefaultsForPreset } from "../../configs/agents/defaults.js";
-import { colorize } from "../../utils/colors.js";
-import { formatWorkspacePath, VORATIQ_VERIFICATION_CONFIG_FILE, } from "../../workspace/structure.js";
-import { renderTable } from "../utils/table.js";
-import { renderBlocks, renderTranscript } from "../utils/transcript.js";
-import { wrapWords } from "../utils/wrap.js";
-const INIT_NOTE_MAX_WIDTH = 79;
-export function renderPresetPromptPreface(firstPrompt) {
-    const sections = [
-        [
-            "Which workspace preset would you like?",
-            "  [1] Pro (flagship)",
-            "  [2] Lite (faster/cheaper)",
-            "  [3] Manual (configure yourself)",
-        ],
-    ];
-    return renderBlocks({
-        sections,
-        leadingBlankLine: firstPrompt,
-    });
-}
-export function renderInitTranscript({ preset, agentSummary, orchestrationSummary, environmentSummary, sandboxSummary, }, options = {}) {
-    const { includeConfigurationHeading = true } = options;
-    const sections = [];
-    if (includeConfigurationHeading) {
-        sections.push(["Configuring workspace…"]);
-    }
-    sections.push(buildConfigurationSummaryTable({
-        orchestrationPath: orchestrationSummary.configPath,
-        agentsPath: agentSummary.configPath,
-        verificationPath: formatWorkspacePath(VORATIQ_VERIFICATION_CONFIG_FILE),
-        environmentPath: environmentSummary.configPath,
-        sandboxPath: sandboxSummary.configPath,
-    }));
-    const conditionalNote = resolveConditionalInitNote({
-        preset,
-        agentSummary,
-    });
-    if (conditionalNote) {
-        sections.push(wrapWords(conditionalNote, INIT_NOTE_MAX_WIDTH).map((line) => colorize(line, "yellow")));
-    }
-    sections.push([
-        "Configuration docs:",
-        "  https://github.com/voratiq/voratiq/tree/main/docs/configs",
-    ]);
-    sections.push([buildWorkspaceInitializedSection()]);
-    sections.push(["Run end-to-end:", '  voratiq auto --description "<task>"']);
-    return renderTranscript({ sections });
-}
-function buildConfigurationSummaryTable(paths) {
-    return renderTable({
-        columns: [
-            { header: "CONFIGURATION", accessor: (row) => row.configuration },
-            { header: "FILE", accessor: (row) => row.path },
-        ],
-        rows: [
-            { configuration: "agents", path: paths.agentsPath },
-            { configuration: "orchestration", path: paths.orchestrationPath },
-            { configuration: "verification", path: paths.verificationPath },
-            { configuration: "environment", path: paths.environmentPath },
-            { configuration: "sandbox", path: paths.sandboxPath },
-        ],
-    });
-}
-function buildWorkspaceInitializedSection() {
-    return colorize("Voratiq initialized.", "green");
-}
-function resolveConditionalInitNote({ preset, agentSummary, }) {
-    if (agentSummary.zeroDetections) {
-        return "No agent CLIs detected on PATH. Install providers, then update `agents.yaml`.";
-    }
-    if (preset === "manual") {
-        return "Manual preset leaves stages empty. Add agents to `orchestration.yaml`.";
-    }
-    const presetProviders = new Set(getAgentDefaultsForPreset(preset).map((agentDefault) => agentDefault.provider));
-    const detectedProviders = new Set(agentSummary.detectedProviders.map((summary) => summary.provider));
-    for (const presetProvider of presetProviders) {
-        if (!detectedProviders.has(presetProvider)) {
-            return "Some providers not found on PATH. Only detected providers were configured. Install missing ones, then update `agents.yaml`.";
-        }
-    }
-    return undefined;
-}