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

package/dist/domain/verify/persistence/adapter.d.ts

@@ -0,0 +1,43 @@
+import type { VerificationRecord } from "../model/types.js";
+export type VerificationRecordPredicate = (record: VerificationRecord) => boolean;
+export interface VerificationRecordWarningMissing {
+    kind: "missing-record";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+}
+export interface VerificationRecordWarningParse {
+    kind: "parse-error";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+    details: string;
+}
+export type VerificationRecordWarning = VerificationRecordWarningMissing | VerificationRecordWarningParse;
+export interface ReadVerificationRecordsOptions {
+    root: string;
+    verificationsFilePath: string;
+    limit?: number;
+    predicate?: VerificationRecordPredicate;
+    onWarning?: (warning: VerificationRecordWarning) => void;
+}
+export interface RewriteVerificationRecordOptions {
+    root: string;
+    verificationsFilePath: string;
+    sessionId: string;
+    mutate: (record: VerificationRecord) => VerificationRecord;
+    forceFlush?: boolean;
+}
+export interface AppendVerificationRecordOptions {
+    root: string;
+    verificationsFilePath: string;
+    record: VerificationRecord;
+}
+export declare function readVerificationRecords(options: ReadVerificationRecordsOptions): Promise<VerificationRecord[]>;
+export declare function appendVerificationRecord(options: AppendVerificationRecordOptions): Promise<void>;
+export declare function rewriteVerificationRecord(options: RewriteVerificationRecordOptions): Promise<VerificationRecord>;
+export declare function flushVerificationRecordBuffer(options: {
+    verificationsFilePath: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function flushAllVerificationRecordBuffers(): Promise<void>;

package/dist/domain/verify/persistence/adapter.js

@@ -0,0 +1,126 @@
+import { dirname, join } from "node:path";
+import { mapSessionStoreError, sessionStoreErrorMapper, } from "../../../persistence/error-mapping.js";
+import { SessionRecordParseError } from "../../../persistence/errors.js";
+import { acquireHistoryLock } from "../../../persistence/history-lock.js";
+import { createSessionStore, } from "../../../persistence/session-store.js";
+import { TERMINAL_VERIFICATION_STATUSES, verificationRecordSchema, } from "../model/types.js";
+const VERIFICATION_INDEX_VERSION = 1;
+const VERIFICATION_RECORD_FILENAME = "record.json";
+const VERIFICATION_HISTORY_LOCK_FILENAME = "history.lock";
+const verificationPersistence = createSessionStore({
+    recordFilename: VERIFICATION_RECORD_FILENAME,
+    indexVersion: VERIFICATION_INDEX_VERSION,
+    acquireLock: acquireHistoryLock,
+    parseRecord: ({ path, raw }) => {
+        const parsed = JSON.parse(raw);
+        const result = verificationRecordSchema.safeParse(parsed);
+        if (!result.success) {
+            const issues = result.error.issues
+                .map((issue) => issue.message)
+                .join(", ");
+            throw new SessionRecordParseError(path, issues);
+        }
+        return result.data;
+    },
+    buildIndexEntry: (record) => ({
+        sessionId: record.sessionId,
+        createdAt: record.createdAt,
+        status: record.status,
+        targetKind: record.target.kind,
+        targetSessionId: record.target.sessionId,
+    }),
+    getIndexEntryId: (entry) => entry.sessionId,
+    shouldForceFlush: (record) => TERMINAL_VERIFICATION_STATUSES.includes(record.status),
+    getRecordId: (record) => record.sessionId,
+    getRecordStatus: (record) => record.status,
+    readIndexEntries: (parsed) => {
+        const payload = parsed;
+        return Array.isArray(payload.sessions) ? payload.sessions : [];
+    },
+});
+export async function readVerificationRecords(options) {
+    const { root, verificationsFilePath, limit, predicate, onWarning } = options;
+    const paths = buildVerificationPaths(root, verificationsFilePath);
+    try {
+        return await verificationPersistence.readRecords({
+            paths,
+            limit,
+            predicate,
+            onWarning: onWarning
+                ? (warning) => onWarning(mapWarning(warning))
+                : undefined,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function appendVerificationRecord(options) {
+    const { root, verificationsFilePath, record } = options;
+    const paths = buildVerificationPaths(root, verificationsFilePath);
+    try {
+        await verificationPersistence.appendRecord({ paths, record });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function rewriteVerificationRecord(options) {
+    const { root, verificationsFilePath, sessionId, mutate, forceFlush = false, } = options;
+    const paths = buildVerificationPaths(root, verificationsFilePath);
+    try {
+        return await verificationPersistence.rewriteRecord({
+            paths,
+            sessionId,
+            mutate,
+            forceFlush,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushVerificationRecordBuffer(options) {
+    const { verificationsFilePath, sessionId } = options;
+    const paths = buildVerificationPaths("", verificationsFilePath);
+    try {
+        await verificationPersistence.flushRecordBuffer({ paths, sessionId });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushAllVerificationRecordBuffers() {
+    try {
+        await verificationPersistence.flushAllRecordBuffers();
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+function buildVerificationPaths(root, verificationsFilePath) {
+    const verificationsRoot = dirname(verificationsFilePath);
+    return {
+        root,
+        indexPath: verificationsFilePath,
+        sessionsDir: join(verificationsRoot, "sessions"),
+        lockPath: join(verificationsRoot, VERIFICATION_HISTORY_LOCK_FILENAME),
+    };
+}
+function mapWarning(warning) {
+    if (warning.kind === "missing-record") {
+        return {
+            kind: "missing-record",
+            sessionId: warning.sessionId,
+            recordPath: warning.recordPath,
+            displayPath: warning.displayPath,
+        };
+    }
+    return {
+        kind: "parse-error",
+        sessionId: warning.sessionId,
+        recordPath: warning.recordPath,
+        displayPath: warning.displayPath,
+        details: warning.details,
+    };
+}

package/dist/domain/verify/programmatic/runner.d.ts

@@ -0,0 +1,22 @@
+import { type EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { ProgrammaticCheckResult, ProgrammaticCommandEntry } from "../../../configs/verification/methods.js";
+interface ExecuteProgrammaticChecksOptions {
+    checks: readonly ProgrammaticCommandEntry[];
+    cwd: string;
+    root: string;
+    logsDirectory: string;
+    env?: NodeJS.ProcessEnv;
+    environment: EnvironmentConfig;
+    envDirectoryGuard?: ProgrammaticEnvDirectoryGuardOptions;
+}
+export interface ProgrammaticEnvDirectoryGuardOptions {
+    trustedAbsoluteRoots: readonly string[];
+    includeHomeForPythonStack?: boolean;
+    failOnDirectoryPreparationError?: boolean;
+}
+export interface ExecuteProgrammaticChecksResult {
+    results: ProgrammaticCheckResult[];
+    warnings: string[];
+}
+export declare function executeProgrammaticChecks(options: ExecuteProgrammaticChecksOptions): Promise<ExecuteProgrammaticChecksResult>;
+export {};

package/dist/domain/verify/programmatic/runner.js

@@ -0,0 +1,209 @@
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { isAbsolute, resolve as resolveAbsolute } from "node:path";
+import { getNodeDependencyRoots, getPythonEnvironmentPath, } from "../../../configs/environment/types.js";
+import { sanitizeSlugForFilename } from "../../../configs/verification/methods.js";
+import { toErrorMessage } from "../../../utils/errors.js";
+import { normalizePathForDisplay, relativeToRoot, resolvePath, } from "../../../utils/path.js";
+import { spawnStreamingProcess } from "../../../utils/process.js";
+export async function executeProgrammaticChecks(options) {
+    const { checks, cwd, root, logsDirectory, env, environment, envDirectoryGuard, } = options;
+    const results = [];
+    const warnings = [];
+    await mkdir(logsDirectory, { recursive: true });
+    const checkEnvironment = composeCheckEnvironment(env);
+    for (const check of checks) {
+        const { slug, command } = check;
+        if (!command) {
+            results.push({
+                slug,
+                status: "skipped",
+            });
+            continue;
+        }
+        try {
+            const prepWarnings = await ensureEnvDirectories({
+                command,
+                cwd,
+                env: checkEnvironment,
+                guard: envDirectoryGuard,
+            });
+            warnings.push(...prepWarnings);
+        }
+        catch (error) {
+            throw new Error(`Programmatic environment preparation failed for "${slug}": ${toErrorMessage(error)}`);
+        }
+        const logFileName = `${sanitizeSlugForFilename(slug)}.log`;
+        const logPath = resolvePath(logsDirectory, logFileName);
+        const logStream = createWriteStream(logPath, { flags: "w" });
+        let exitCode = null;
+        let status = "succeeded";
+        let errorMessage;
+        const missingStacks = detectMissingStacks(command, environment);
+        if (missingStacks.length > 0) {
+            const warningMessage = buildMissingStackWarning(slug, command, missingStacks);
+            logStream.write(`${warningMessage}\n`);
+            warnings.push(warningMessage);
+        }
+        try {
+            const { exitCode: code, signal } = await spawnStreamingProcess({
+                command,
+                cwd,
+                env: checkEnvironment,
+                shell: true,
+                stdout: { writable: logStream, endOnClose: false },
+                stderr: { writable: logStream, endOnClose: false },
+            });
+            if (signal) {
+                status = "errored";
+                exitCode = null;
+                errorMessage = `Process terminated by signal ${signal}`;
+            }
+            else {
+                exitCode = code;
+                status = code === 0 ? "succeeded" : "failed";
+            }
+        }
+        catch (error) {
+            status = "errored";
+            exitCode = null;
+            errorMessage = toErrorMessage(error);
+        }
+        finally {
+            logStream.end();
+        }
+        results.push({
+            slug,
+            status,
+            command,
+            exitCode,
+            logPath: normalizePathForDisplay(relativeToRoot(root, logPath)),
+            error: errorMessage,
+        });
+    }
+    return { results, warnings };
+}
+function composeCheckEnvironment(overrides) {
+    return {
+        ...overrides,
+    };
+}
+async function ensureEnvDirectories(options) {
+    const { command, cwd, env, guard } = options;
+    if (!guard) {
+        return [];
+    }
+    const warnings = [];
+    const candidates = collectEnvDirCandidates({
+        command,
+        cwd,
+        env,
+        includeHomeForPythonStack: guard.includeHomeForPythonStack ?? false,
+    });
+    if (candidates.length === 0) {
+        return warnings;
+    }
+    const trustedRoots = normalizeTrustedRoots(guard.trustedAbsoluteRoots);
+    trustedRoots.push(resolveAbsolute(tmpdir()));
+    for (const candidate of candidates) {
+        if (candidate.absolute &&
+            !isWithinAnyRoot(candidate.resolvedPath, trustedRoots)) {
+            warnings.push(`[voratiq] Warning: skipping programmatic env mkdir for ${candidate.variables.join(", ")} at ${candidate.resolvedPath} (outside trusted roots).`);
+            continue;
+        }
+        try {
+            await mkdir(candidate.resolvedPath, { recursive: true });
+        }
+        catch (error) {
+            const failureMessage = `[voratiq] Warning: failed to create programmatic env directory for ${candidate.variables.join(", ")} at ${candidate.resolvedPath}: ${toErrorMessage(error)}`;
+            warnings.push(failureMessage);
+            if (guard.failOnDirectoryPreparationError) {
+                throw new Error(`required programmatic env directory prep failed for ${candidate.variables.join(", ")} at ${candidate.resolvedPath}: ${toErrorMessage(error)}`);
+            }
+        }
+    }
+    return warnings;
+}
+function collectEnvDirCandidates(options) {
+    const { command, cwd, env, includeHomeForPythonStack } = options;
+    const lowerCommand = command.toLowerCase();
+    const variableNames = ["TMPDIR", "TMP", "TEMP"];
+    if (includeHomeForPythonStack && requiresPythonStack(lowerCommand)) {
+        variableNames.push("HOME");
+    }
+    const deduplicated = new Map();
+    for (const variable of variableNames) {
+        const raw = env[variable];
+        if (typeof raw !== "string") {
+            continue;
+        }
+        const trimmed = raw.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        const absolute = isAbsolute(trimmed);
+        const resolvedPath = absolute
+            ? resolveAbsolute(trimmed)
+            : resolveAbsolute(cwd, trimmed);
+        const existing = deduplicated.get(resolvedPath);
+        if (existing) {
+            existing.variables.push(variable);
+            continue;
+        }
+        deduplicated.set(resolvedPath, {
+            resolvedPath,
+            variables: [variable],
+            absolute,
+        });
+    }
+    return Array.from(deduplicated.values());
+}
+function normalizeTrustedRoots(roots) {
+    const unique = new Set();
+    for (const root of roots) {
+        if (typeof root !== "string") {
+            continue;
+        }
+        const trimmed = root.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        unique.add(resolveAbsolute(trimmed));
+    }
+    return Array.from(unique);
+}
+function isWithinAnyRoot(path, roots) {
+    for (const root of roots) {
+        if (path === root) {
+            return true;
+        }
+        if (path.startsWith(`${root}/`)) {
+            return true;
+        }
+    }
+    return false;
+}
+function detectMissingStacks(command, environment) {
+    const missing = [];
+    const lowerCommand = command.toLowerCase();
+    if (requiresNodeStack(lowerCommand) &&
+        getNodeDependencyRoots(environment).length === 0) {
+        missing.push("node");
+    }
+    if (requiresPythonStack(lowerCommand) &&
+        !getPythonEnvironmentPath(environment)) {
+        missing.push("python");
+    }
+    return missing;
+}
+function requiresNodeStack(command) {
+    return /(^|\\s)(npm|pnpm|yarn|node|tsc|jest|vitest)(\\s|$)/u.test(command);
+}
+function requiresPythonStack(command) {
+    return /(^|\\s)(python|python3|pip|pip3|pytest)(\\s|$)/u.test(command);
+}
+function buildMissingStackWarning(slug, command, missingStacks) {
+    const stackList = missingStacks.join(", ");
+    return `[voratiq] Warning: programmatic check "${slug}" may fail because ${stackList} support is not enabled (command: ${JSON.stringify(command)}).`;
+}

package/dist/domain/verify/rubric-result.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export declare const rubricResultPayloadSchema: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+export type RubricResultPayload = z.infer<typeof rubricResultPayloadSchema>;
+export declare const rubricRecommendationSchema: z.ZodObject<{
+    preferred: z.ZodOptional<z.ZodString>;
+    ranking: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    rationale: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RubricRecommendation = z.infer<typeof rubricRecommendationSchema>;
+export declare function parseRubricResultPayload(raw: string): RubricResultPayload;
+export declare function safeParseRubricRecommendationFromResult(result: RubricResultPayload): {
+    success: true;
+    data: RubricRecommendation | undefined;
+} | {
+    success: false;
+    error: z.ZodError<RubricRecommendation>;
+};
+export declare function parseRubricRecommendationFromResult(result: RubricResultPayload): RubricRecommendation | undefined;
+export declare function readRubricResultPreferred(result: RubricResultPayload): string | undefined;
+export declare function readRubricResultRanking(result: RubricResultPayload): string[] | undefined;
+export declare function readRubricResultComparison(result: RubricResultPayload): string | undefined;
+export declare function readRubricResultRationale(result: RubricResultPayload): string | undefined;
+export declare function readRubricResultNextActions(result: RubricResultPayload): string[] | undefined;
+export declare function readRubricResultNarrative(result: RubricResultPayload): string | undefined;
+export declare function formatRubricResultIssues(issues: ReadonlyArray<{
+    path: readonly PropertyKey[];
+    message: string;
+}>): string;

package/dist/domain/verify/rubric-result.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+export const rubricResultPayloadSchema = z.object({}).catchall(z.unknown());
+const verificationSelectorSchema = z.string().trim().min(1);
+export const rubricRecommendationSchema = z
+    .object({
+    preferred: verificationSelectorSchema.optional(),
+    ranking: z.array(verificationSelectorSchema).min(1).optional(),
+    rationale: z.string().min(1).optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.preferred !== undefined &&
+        value.ranking !== undefined &&
+        value.ranking[0] !== value.preferred) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["preferred"],
+            message: "`preferred` must match `ranking[0]` when both are present",
+        });
+    }
+});
+export function parseRubricResultPayload(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "invalid JSON";
+        throw new Error(`Invalid verifier result.json: ${reason}`);
+    }
+    const validation = rubricResultPayloadSchema.safeParse(parsed);
+    if (!validation.success) {
+        throw new Error("Invalid verifier result.json: expected a top-level JSON object");
+    }
+    return validation.data;
+}
+export function safeParseRubricRecommendationFromResult(result) {
+    const candidate = extractRubricRecommendationCandidate(result);
+    if (!candidate) {
+        return {
+            success: true,
+            data: undefined,
+        };
+    }
+    const validation = rubricRecommendationSchema.safeParse(candidate);
+    if (!validation.success) {
+        return validation;
+    }
+    return {
+        success: true,
+        data: validation.data,
+    };
+}
+export function parseRubricRecommendationFromResult(result) {
+    const validation = safeParseRubricRecommendationFromResult(result);
+    if (!validation.success) {
+        throw new Error(formatRubricResultIssues(validation.error.issues));
+    }
+    return validation.data;
+}
+export function readRubricResultPreferred(result) {
+    return normalizeNonEmptyString(result["preferred"]);
+}
+export function readRubricResultRanking(result) {
+    const value = result["ranking"];
+    if (!Array.isArray(value) ||
+        !value.every((entry) => typeof entry === "string")) {
+        return undefined;
+    }
+    const ranking = value.map((entry) => entry.trim());
+    return ranking.every((entry) => entry.length > 0) ? ranking : undefined;
+}
+export function readRubricResultComparison(result) {
+    return normalizeNonEmptyString(result["comparison"]);
+}
+export function readRubricResultRationale(result) {
+    return normalizeNonEmptyString(result["rationale"]);
+}
+export function readRubricResultNextActions(result) {
+    const value = result["next_actions"];
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const actions = value
+        .map((entry) => normalizeNonEmptyString(entry))
+        .filter((entry) => entry !== undefined);
+    return actions.length > 0 ? actions : undefined;
+}
+export function readRubricResultNarrative(result) {
+    return (readRubricResultRationale(result) ?? readRubricResultComparison(result));
+}
+export function formatRubricResultIssues(issues) {
+    return issues
+        .map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+        return `${path}: ${issue.message}`;
+    })
+        .join("; ");
+}
+function extractRubricRecommendationCandidate(result) {
+    const preferred = readRubricResultPreferred(result);
+    const ranking = readRubricResultRanking(result);
+    const rationale = readRubricResultNarrative(result);
+    if (preferred === undefined &&
+        ranking === undefined &&
+        rationale === undefined) {
+        return undefined;
+    }
+    return {
+        ...(preferred !== undefined ? { preferred } : {}),
+        ...(ranking !== undefined ? { ranking } : {}),
+        ...(rationale !== undefined ? { rationale } : {}),
+    };
+}
+function normalizeNonEmptyString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}

package/dist/extra-context/contract.d.ts

@@ -0,0 +1,17 @@
+export declare const EXTRA_CONTEXT_STAGED_PREFIX: string;
+export interface PersistableExtraContextFile {
+    readonly displayPath: string;
+    readonly stagedRelativePath: string;
+}
+export interface PersistedExtraContextMetadataEntry {
+    readonly stagedPath: string;
+    readonly sourcePath: string;
+}
+export interface PersistedExtraContextFields {
+    readonly extraContext?: string[];
+    readonly extraContextMetadata?: PersistedExtraContextMetadataEntry[];
+}
+export declare function buildPersistedExtraContextFields(files: readonly PersistableExtraContextFile[]): PersistedExtraContextFields;
+export declare function assertExtraContextStagedPath(value: string, message?: string): string;
+export declare function assertExtraContextSourcePath(value: string, message?: string): string;
+export declare function toExtraContextContextSubpath(stagedPath: string): string;

package/dist/extra-context/contract.js

@@ -0,0 +1,60 @@
+const EXTRA_CONTEXT_STAGED_PREFIX_SEGMENTS = ["..", "context"];
+export const EXTRA_CONTEXT_STAGED_PREFIX = `${EXTRA_CONTEXT_STAGED_PREFIX_SEGMENTS.join("/")}/`;
+export function buildPersistedExtraContextFields(files) {
+    if (files.length === 0) {
+        return {};
+    }
+    return {
+        extraContext: files.map((file) => assertExtraContextStagedPath(file.stagedRelativePath)),
+        extraContextMetadata: files.map((file) => ({
+            stagedPath: assertExtraContextStagedPath(file.stagedRelativePath),
+            sourcePath: assertExtraContextSourcePath(file.displayPath),
+        })),
+    };
+}
+export function assertExtraContextStagedPath(value, message = `Path "${value}" must be session-relative under "../context/" with forward slashes.`) {
+    if (typeof value !== "string") {
+        throw new Error(message);
+    }
+    if (value.trim() !== value || value.length === 0) {
+        throw new Error(message);
+    }
+    if (value.startsWith("/")) {
+        throw new Error(message);
+    }
+    if (isWindowsAbsolutePath(value)) {
+        throw new Error(message);
+    }
+    if (value.includes("\\")) {
+        throw new Error(message);
+    }
+    const segments = value.split("/");
+    if (segments.length < 3) {
+        throw new Error(message);
+    }
+    const [parentSegment, contextSegment, ...rest] = segments;
+    if (parentSegment !== EXTRA_CONTEXT_STAGED_PREFIX_SEGMENTS[0] ||
+        contextSegment !== EXTRA_CONTEXT_STAGED_PREFIX_SEGMENTS[1]) {
+        throw new Error(message);
+    }
+    if (rest.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+        throw new Error(message);
+    }
+    return value;
+}
+export function assertExtraContextSourcePath(value, message = `Path "${value}" must be a non-empty normalized source path.`) {
+    if (typeof value !== "string") {
+        throw new Error(message);
+    }
+    if (value.trim() !== value || value.length === 0) {
+        throw new Error(message);
+    }
+    return value;
+}
+export function toExtraContextContextSubpath(stagedPath) {
+    assertExtraContextStagedPath(stagedPath);
+    return stagedPath.slice(EXTRA_CONTEXT_STAGED_PREFIX.length);
+}
+function isWindowsAbsolutePath(value) {
+    return /^[A-Za-z]:/.test(value);
+}

package/dist/interactive/index.d.ts

@@ -0,0 +1,2 @@
+export { prepareAndSpawnNativeInteractiveSession, prepareNativeInteractiveSession, resolveInteractiveAgentProvider, spawnPreparedInteractiveSession, } from "./substrate.js";
+export type { InteractiveLaunchFailure, InteractiveLaunchFailureCode, InteractiveLaunchFailureKind, InteractiveSessionChatRecord, InteractiveSessionErrorRecord, InteractiveSessionIndexEntry, InteractiveSessionIndexRecord, InteractiveSessionRecord, InteractiveSessionStatus, NativeLaunchInvocation, NativeSessionLaunchMode, NativeToolDeclaration, PrepareAndSpawnNativeSessionResult, PreparedInteractiveSession, PrepareNativeSessionFailure, PrepareNativeSessionOptions, PrepareNativeSessionResult, PrepareNativeSessionSuccess, SpawnPreparedSessionFailure, SpawnPreparedSessionOptions, SpawnPreparedSessionResult, SpawnPreparedSessionSuccess, ToolAttachmentStatus, } from "./types.js";

package/dist/interactive/index.js

@@ -0,0 +1 @@
+export { prepareAndSpawnNativeInteractiveSession, prepareNativeInteractiveSession, resolveInteractiveAgentProvider, spawnPreparedInteractiveSession, } from "./substrate.js";

package/dist/interactive/providers/launch.d.ts

@@ -0,0 +1,23 @@
+import type { AgentDefinition } from "../../configs/agents/types.js";
+import type { NativeToolDeclaration, ToolAttachmentStatus } from "../types.js";
+import type { FirstPartyMcpStatusAndArgs } from "./mcp.js";
+export interface ProviderLaunchPreparationInput {
+    providerId: string;
+    agent: AgentDefinition;
+    root: string;
+    toolDeclarations: readonly NativeToolDeclaration[];
+    prompt?: string;
+    launchMode?: "default" | "first-party";
+    firstPartyMcpResolution?: FirstPartyMcpStatusAndArgs;
+}
+export interface ProviderLaunchPreparationResult {
+    args: string[];
+    env: Record<string, string>;
+    toolAttachmentStatus: ToolAttachmentStatus;
+    artifactCaptureSupported: boolean;
+}
+export declare function createBundledVoratiqToolDeclaration(options: {
+    command: string;
+    argsPrefix: readonly string[];
+}): NativeToolDeclaration;
+export declare function prepareProviderNativeLaunch(options: ProviderLaunchPreparationInput): Promise<ProviderLaunchPreparationResult>;