voratiq 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/cli/errors.d.ts

@@ -2,4 +2,7 @@ import { HintedError } from "../utils/errors.js";
 export declare class CliError extends HintedError {
     constructor(headline: string, detailLines?: readonly string[], hintLines?: readonly string[]);
 }
+export declare class NonInteractiveShellError extends CliError {
+    constructor();
+}
 export declare function toCliError(error: unknown): CliError;

package/dist/cli/errors.js

@@ -5,6 +5,12 @@ export class CliError extends HintedError {
         this.name = "CliError";
     }
 }
+export class NonInteractiveShellError extends CliError {
+    constructor() {
+        super("Non-interactive shell detected; re-run with --yes to accept defaults.");
+        this.name = "NonInteractiveShellError";
+    }
+}
 export function toCliError(error) {
     if (error instanceof CliError) {
         return error;

package/dist/cli/init.js

@@ -3,6 +3,7 @@ import { executeInitCommand } from "../commands/init/command.js";
 import { resolveCliContext } from "../preflight/index.js";
 import { renderInitTranscript } from "../render/transcripts/init.js";
 import { createConfirmationWorkflow } from "./confirmation.js";
+import { NonInteractiveShellError } from "./errors.js";
 import { writeCommandOutput } from "./output.js";
 export async function runInitCommand(options = {}) {
     const { root } = await resolveCliContext({ requireWorkspace: false });
@@ -10,7 +11,7 @@ export async function runInitCommand(options = {}) {
     const confirmation = createConfirmationWorkflow({
         assumeYes,
         onUnavailable: () => {
-            throw new Error("Non-interactive shell detected; re-run with --yes to accept defaults.");
+            throw new NonInteractiveShellError();
         },
     });
     try {

package/dist/cli/prune.js

@@ -1,9 +1,9 @@
 import { Command } from "commander";
 import { executePruneCommand } from "../commands/prune/command.js";
-import { InteractiveConfirmationRequiredError } from "../commands/prune/errors.js";
 import { resolveCliContext } from "../preflight/index.js";
 import { renderPruneTranscript } from "../render/transcripts/prune.js";
 import { createConfirmationWorkflow } from "./confirmation.js";
+import { NonInteractiveShellError } from "./errors.js";
 import { writeCommandOutput } from "./output.js";
 export async function runPruneCommand(options) {
     const { runId } = options;
@@ -13,7 +13,7 @@ export async function runPruneCommand(options) {
     const confirmation = createConfirmationWorkflow({
         assumeYes,
         onUnavailable: () => {
-            throw new InteractiveConfirmationRequiredError();
+            throw new NonInteractiveShellError();
         },
     });
     try {

package/dist/commands/apply/errors.js

@@ -16,7 +16,7 @@ export class ApplyRunDeletedError extends ApplyError {
 export class ApplyRunMetadataCorruptedError extends ApplyError {
     constructor(detail) {
         super("Run history is corrupted; cannot apply.", [detail], [
-            "Inspect `.voratiq/runs/index.json` and the affected run directory under `.voratiq/runs/<id>` or regenerate the run with `voratiq run`.",
+            "Inspect `.voratiq/runs/index.json` and the affected run directory under `.voratiq/runs/sessions/<id>` or regenerate the run with `voratiq run`.",
         ]);
         this.name = "ApplyRunMetadataCorruptedError";
     }

package/dist/commands/prune/command.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs/promises";
+import { NonInteractiveShellError } from "../../cli/errors.js";
 import { RunRecordNotFoundError, RunRecordParseError, } from "../../records/errors.js";
 import { rewriteRunRecord, RUN_RECORD_FILENAME, } from "../../records/persistence.js";
 import { buildPruneConfirmationPreface } from "../../render/transcripts/prune.js";
@@ -7,14 +8,14 @@ import { pathExists } from "../../utils/fs.js";
 import { getGitStderr, runGitCommand } from "../../utils/git.js";
 import { normalizePathForDisplay, resolveDisplayPath, resolvePath, } from "../../utils/path.js";
 import { deriveAgentBranches, removeRunDirectory, removeWorkspaceEntry, } from "../../workspace/prune.js";
-import { buildAgentArtifactPaths, formatWorkspacePath, getAgentDirectoryPath, getAgentEvalsDirectoryPath, getAgentWorkspaceDirectoryPath, resolveWorkspacePath, VORATIQ_RUNS_DIR, } from "../../workspace/structure.js";
+import { buildAgentArtifactPaths, getAgentDirectoryPath, getAgentEvalsDirectoryPath, getAgentWorkspaceDirectoryPath, getRunDirectoryPath, resolveWorkspacePath, VORATIQ_RUNS_SESSIONS_DIR, } from "../../workspace/structure.js";
 import { fetchRunSafely } from "../fetch.js";
-import { InteractiveConfirmationRequiredError, PruneBranchDeletionError, PruneRunDeletedError, RunMetadataMissingError, } from "./errors.js";
+import { PruneBranchDeletionError, PruneRunDeletedError, RunMetadataMissingError, } from "./errors.js";
 export async function executePruneCommand(input) {
     const { root, runsFilePath, runId, confirm, clock, purge: purgeInput, } = input;
     const purge = purgeInput ?? false;
     if (!confirm) {
-        throw new InteractiveConfirmationRequiredError();
+        throw new NonInteractiveShellError();
     }
     const runRecord = await fetchRunSafely({
         root,
@@ -22,7 +23,7 @@ export async function executePruneCommand(input) {
         runId,
         onDeleted: (record) => new PruneRunDeletedError(record.runId),
     });
-    const runPathDisplay = formatWorkspacePath(VORATIQ_RUNS_DIR, runRecord.runId);
+    const runPathDisplay = getRunDirectoryPath(runRecord.runId);
     const branches = deriveAgentBranches(runRecord);
     const workspaceTargets = buildWorkspaceTargets({
         root,
@@ -263,7 +264,7 @@ async function pruneArtifacts(options) {
 }
 async function purgeRunDirectoryExceptRecord(options) {
     const { root, runRecord } = options;
-    const runDir = resolveWorkspacePath(root, VORATIQ_RUNS_DIR, runRecord.runId);
+    const runDir = resolveWorkspacePath(root, VORATIQ_RUNS_SESSIONS_DIR, runRecord.runId);
     if (!(await pathExists(runDir))) {
         return;
     }

package/dist/commands/prune/errors.d.ts

@@ -6,9 +6,6 @@ export declare class RunMetadataMissingError extends PruneError {
     readonly runId: string;
     constructor(runId: string);
 }
-export declare class InteractiveConfirmationRequiredError extends PruneError {
-    constructor();
-}
 export declare class PruneBranchDeletionError extends PruneError {
     readonly branch: string;
     readonly detail: string;

package/dist/commands/prune/errors.js

@@ -8,17 +8,11 @@ export class PruneError extends CliError {
 export class RunMetadataMissingError extends PruneError {
     runId;
     constructor(runId) {
-        super(`Run metadata for ${runId} is missing from .voratiq/runs/${runId}/record.json; prune cannot proceed.`);
+        super(`Run metadata for ${runId} is missing from .voratiq/runs/sessions/${runId}/record.json; prune cannot proceed.`);
         this.runId = runId;
         this.name = "RunMetadataMissingError";
     }
 }
-export class InteractiveConfirmationRequiredError extends PruneError {
-    constructor() {
-        super("Interactive confirmation required; re-run with --yes or from a tty.");
-        this.name = "InteractiveConfirmationRequiredError";
-    }
-}
 export class PruneBranchDeletionError extends PruneError {
     branch;
     detail;

package/dist/configs/agents/defaults.d.ts

@@ -6,4 +6,5 @@ export interface AgentDefault {
 }
 export declare function sanitizeAgentIdFromModel(model: string): string;
 export declare const DEFAULT_AGENT_DEFAULTS: readonly AgentDefault[];
+export declare function getDefaultAgentIdByProvider(provider: string): string | undefined;
 export declare function getAgentDefault(provider: string): AgentDefault | undefined;

package/dist/configs/agents/defaults.js

@@ -24,7 +24,7 @@ export const DEFAULT_AGENT_DEFAULTS = [
     },
     {
         provider: "codex",
-        model: "gpt-5.1-codex-max",
+        model: "gpt-5.2-codex",
         argv: [
             "exec",
             "--model",
@@ -42,6 +42,10 @@ export const DEFAULT_AGENT_DEFAULTS = [
     },
 ];
 const AGENT_DEFAULTS_BY_PROVIDER = new Map(DEFAULT_AGENT_DEFAULTS.map((agentDefault) => [agentDefault.provider, agentDefault]));
+export function getDefaultAgentIdByProvider(provider) {
+    const entry = AGENT_DEFAULTS_BY_PROVIDER.get(provider);
+    return entry ? sanitizeAgentIdFromModel(entry.model) : undefined;
+}
 export function getAgentDefault(provider) {
     const agentDefault = AGENT_DEFAULTS_BY_PROVIDER.get(provider);
     return agentDefault ? cloneAgentDefault(agentDefault) : undefined;

package/dist/configs/agents/errors.d.ts

@@ -18,6 +18,15 @@ export declare class DuplicateAgentIdError extends AgentsConfigError {
     readonly displayPath: string;
     constructor(agentId: string, displayPath: string);
 }
+export declare class AgentNotFoundError extends AgentsConfigError {
+    readonly agentId: string;
+    readonly enabledAgentIds: readonly string[];
+    constructor(agentId: string, enabledAgentIds: readonly string[]);
+}
+export declare class AgentDisabledError extends AgentsConfigError {
+    readonly agentId: string;
+    constructor(agentId: string);
+}
 export declare class ModelPlaceholderMissingError extends AgentsError {
     readonly agentId: string;
     readonly placeholder: string;

package/dist/configs/agents/errors.js

@@ -36,6 +36,27 @@ export class DuplicateAgentIdError extends AgentsConfigError {
         this.name = "DuplicateAgentIdError";
     }
 }
+export class AgentNotFoundError extends AgentsConfigError {
+    agentId;
+    enabledAgentIds;
+    constructor(agentId, enabledAgentIds) {
+        const enabledList = enabledAgentIds.length > 0
+            ? enabledAgentIds.slice().sort().join(", ")
+            : "none";
+        super(`${DEFAULT_ERROR_CONTEXT}: Agent "${agentId}" is not defined in agents.yaml. Enabled agents: ${enabledList}.`);
+        this.agentId = agentId;
+        this.enabledAgentIds = enabledAgentIds;
+        this.name = "AgentNotFoundError";
+    }
+}
+export class AgentDisabledError extends AgentsConfigError {
+    agentId;
+    constructor(agentId) {
+        super(`${DEFAULT_ERROR_CONTEXT}: Agent "${agentId}" is disabled in agents.yaml.`);
+        this.agentId = agentId;
+        this.name = "AgentDisabledError";
+    }
+}
 export class ModelPlaceholderMissingError extends AgentsError {
     agentId;
     placeholder;

package/dist/configs/agents/loader.d.ts

@@ -1,4 +1,4 @@
-import { type AgentCatalog, type AgentsConfig } from "./types.js";
+import { type AgentCatalog, type AgentDefinition, type AgentsConfig } from "./types.js";
 export declare function readAgentsConfig(content: string): AgentsConfig;
 export interface LoadAgentCatalogOptions {
     root?: string;
@@ -6,3 +6,4 @@ export interface LoadAgentCatalogOptions {
     readFile?: (path: string) => string;
 }
 export declare function loadAgentCatalog(options?: LoadAgentCatalogOptions): AgentCatalog;
+export declare function loadAgentById(id: string, options?: LoadAgentCatalogOptions): AgentDefinition;

package/dist/configs/agents/loader.js

@@ -6,7 +6,7 @@ import { resolveWorkspacePath } from "../../workspace/structure.js";
 import { createConfigLoader } from "../shared/loader-factory.js";
 import { formatYamlErrorMessage } from "../shared/yaml-error-formatter.js";
 import { getAgentDefault, MODEL_PLACEHOLDER, } from "./defaults.js";
-import { AgentBinaryAccessError, AgentBinaryMissingError, AgentsYamlParseError, DEFAULT_ERROR_CONTEXT, DuplicateAgentIdError, MissingAgentsConfigError, ModelPlaceholderMissingError, UnknownAgentProviderTemplateError, } from "./errors.js";
+import { AgentBinaryAccessError, AgentBinaryMissingError, AgentDisabledError, AgentNotFoundError, AgentsYamlParseError, DEFAULT_ERROR_CONTEXT, DuplicateAgentIdError, MissingAgentsConfigError, ModelPlaceholderMissingError, UnknownAgentProviderTemplateError, } from "./errors.js";
 import { agentsConfigSchema, } from "./types.js";
 const AGENTS_CONFIG_FILENAME = "agents.yaml";
 export function readAgentsConfig(content) {
@@ -21,7 +21,7 @@ function formatAgentsYamlError(detail) {
     });
     return new AgentsYamlParseError(message);
 }
-const loadAgentCatalogInternal = createConfigLoader({
+const loadAgentsConfigInternal = createConfigLoader({
     resolveFilePath: (root, options) => options.filePath ?? resolveWorkspacePath(root, AGENTS_CONFIG_FILENAME),
     selectReadFile: (options) => options.readFile,
     handleMissing: ({ filePath }) => {
@@ -38,13 +38,30 @@ const loadAgentCatalogInternal = createConfigLoader({
             }
             seenAgentIds.add(entry.id);
         }
-        const catalog = enabledAgents.map((entry) => buildAgentDefinition(entry));
-        validateAgentBinaries(catalog);
-        return catalog;
+        return { config, displayPath, enabledAgents };
     },
 });
+function loadAgentsConfig(options = {}) {
+    return loadAgentsConfigInternal(options);
+}
 export function loadAgentCatalog(options = {}) {
-    return loadAgentCatalogInternal(options);
+    const { enabledAgents } = loadAgentsConfig(options);
+    const catalog = enabledAgents.map((entry) => buildAgentDefinition(entry));
+    validateAgentBinaries(catalog);
+    return catalog;
+}
+export function loadAgentById(id, options = {}) {
+    const { config, enabledAgents } = loadAgentsConfig(options);
+    const entry = config.agents.find((agent) => agent.id === id);
+    if (!entry) {
+        throw new AgentNotFoundError(id, enabledAgents.map((agent) => agent.id));
+    }
+    if (entry.enabled === false) {
+        throw new AgentDisabledError(entry.id);
+    }
+    const definition = buildAgentDefinition(entry);
+    assertAgentBinary(definition);
+    return definition;
 }
 function validateAgentBinaries(agents) {
     for (const agent of agents) {

package/dist/configs/sandbox/defaults.js

@@ -10,7 +10,7 @@ export const DEFAULT_SANDBOX_PROVIDERS = [
     {
         id: "codex",
         network: {
-            allowedDomains: ["api.openai.com", "chatgpt.com"],
+            allowedDomains: ["api.openai.com", "chatgpt.com", "auth.openai.com"],
             deniedDomains: [],
             allowLocalBinding: false,
         },

package/dist/records/persistence.d.ts

@@ -54,7 +54,7 @@ type ReadRunRecordsFn = (options: ReadRunRecordsOptions) => Promise<RunRecord[]>
 export type RunIndexEntry = Pick<RunRecord, "runId" | "createdAt" | "status">;
 export interface RunIndexPayload {
     version: number;
-    runs: RunIndexEntry[];
+    sessions: RunIndexEntry[];
 }
 export declare const RUN_RECORD_FILENAME = "record.json";
 export type RunRecordBufferSnapshotEntry = {

package/dist/records/persistence.js

@@ -8,7 +8,7 @@ import { RunOptionValidationError, RunRecordMutationError, RunRecordNotFoundErro
 import { acquireHistoryLock } from "./history-lock.js";
 import { runRecordSchema } from "./types.js";
 export { HISTORY_LOCK_STALE_GRACE_MS } from "./history-lock.js";
-const RUN_INDEX_VERSION = 1;
+const RUN_INDEX_VERSION = 2;
 export const RUN_RECORD_FILENAME = "record.json";
 const HISTORY_LOCK_FILENAME = "history.lock";
 const BUFFER_FLUSH_DELAY_MS = 250;
@@ -18,7 +18,7 @@ const readRunRecordsInternal = async (options) => {
     if (limit !== undefined && (!Number.isInteger(limit) || limit <= 0)) {
         throw new RunOptionValidationError("limit", "must be a positive integer");
     }
-    const runsDir = getRunsDirectory(runsFilePath);
+    const sessionsDir = getSessionsDirectory(runsFilePath);
     let index;
     try {
         index = await readRunIndex(runsFilePath);
@@ -31,12 +31,12 @@ const readRunRecordsInternal = async (options) => {
         throw error;
     }
     const matches = [];
-    for (let i = index.runs.length - 1; i >= 0; i -= 1) {
-        const entry = index.runs[i];
+    for (let i = index.sessions.length - 1; i >= 0; i -= 1) {
+        const entry = index.sessions[i];
         if (!entry) {
             continue;
         }
-        const recordPath = join(runsDir, entry.runId, RUN_RECORD_FILENAME);
+        const recordPath = join(sessionsDir, entry.runId, RUN_RECORD_FILENAME);
         try {
             const record = await readRunRecordFromDisk(recordPath);
             if (predicate && !predicate(record)) {
@@ -86,11 +86,12 @@ export async function readRunRecords(options) {
 }
 export async function appendRunRecord(options) {
     const { root, runsFilePath, record } = options;
-    const runsDir = getRunsDirectory(runsFilePath);
-    const recordDir = join(runsDir, record.runId);
+    const runsRoot = getRunsDirectory(runsFilePath);
+    const sessionsDir = getSessionsDirectory(runsFilePath);
+    const recordDir = join(sessionsDir, record.runId);
     const recordPath = join(recordDir, RUN_RECORD_FILENAME);
     const displayPath = relativeToRoot(root, recordPath);
-    const lockPath = join(runsDir, HISTORY_LOCK_FILENAME);
+    const lockPath = join(runsRoot, HISTORY_LOCK_FILENAME);
     await mkdir(recordDir, { recursive: true });
     const releaseLock = await acquireHistoryLock(lockPath);
     try {
@@ -108,7 +109,7 @@ export async function appendRunRecord(options) {
             runId: record.runId,
             recordPath,
             lockPath,
-            runsDir,
+            runsDir: runsRoot,
             runsFilePath,
             root,
             record,
@@ -131,15 +132,16 @@ export async function appendRunRecord(options) {
 }
 export async function rewriteRunRecord(options) {
     const { root, runsFilePath, runId, mutate } = options;
-    const runsDir = getRunsDirectory(runsFilePath);
-    const recordPath = join(runsDir, runId, RUN_RECORD_FILENAME);
-    const lockPath = join(runsDir, HISTORY_LOCK_FILENAME);
+    const runsRoot = getRunsDirectory(runsFilePath);
+    const sessionsDir = getSessionsDirectory(runsFilePath);
+    const recordPath = join(sessionsDir, runId, RUN_RECORD_FILENAME);
+    const lockPath = join(runsRoot, HISTORY_LOCK_FILENAME);
     const entry = await getOrLoadBufferEntry({
         key: recordPath,
         runId,
         recordPath,
         lockPath,
-        runsDir,
+        runsDir: runsRoot,
         runsFilePath,
         root,
     });
@@ -161,8 +163,8 @@ export async function rewriteRunRecord(options) {
 }
 export async function getRunRecordSnapshot(options) {
     const { runsFilePath, runId } = options;
-    const runsDir = getRunsDirectory(runsFilePath);
-    const recordPath = join(runsDir, runId, RUN_RECORD_FILENAME);
+    const sessionsDir = getSessionsDirectory(runsFilePath);
+    const recordPath = join(sessionsDir, runId, RUN_RECORD_FILENAME);
     const buffered = runRecordBuffers.get(recordPath);
     if (buffered) {
         return structuredClone(buffered.record);
@@ -189,7 +191,7 @@ export async function flushAllRunRecordBuffers() {
 }
 export async function disposeRunRecordBuffer(options) {
     const { runsFilePath, runId } = options;
-    const recordPath = join(getRunsDirectory(runsFilePath), runId, RUN_RECORD_FILENAME);
+    const recordPath = join(getSessionsDirectory(runsFilePath), runId, RUN_RECORD_FILENAME);
     const entry = runRecordBuffers.get(recordPath);
     if (!entry) {
         return;
@@ -198,7 +200,7 @@ export async function disposeRunRecordBuffer(options) {
 }
 export async function flushRunRecordBuffer(options) {
     const { runsFilePath, runId } = options;
-    const recordPath = join(getRunsDirectory(runsFilePath), runId, RUN_RECORD_FILENAME);
+    const recordPath = join(getSessionsDirectory(runsFilePath), runId, RUN_RECORD_FILENAME);
     const entry = runRecordBuffers.get(recordPath);
     if (!entry) {
         return;
@@ -390,22 +392,30 @@ async function atomicWriteJson(path, payload) {
 function getRunsDirectory(runsFilePath) {
     return dirname(runsFilePath);
 }
+function getSessionsDirectory(runsFilePath) {
+    return join(getRunsDirectory(runsFilePath), "sessions");
+}
 async function readRunIndex(path) {
     try {
         const raw = await readFile(path, "utf8");
         const trimmed = raw.trim();
         if (!trimmed) {
-            return { version: RUN_INDEX_VERSION, runs: [] };
+            return { version: RUN_INDEX_VERSION, sessions: [] };
         }
         const parsed = JSON.parse(trimmed);
-        if (!Array.isArray(parsed.runs)) {
-            return { version: RUN_INDEX_VERSION, runs: [] };
-        }
-        return parsed;
+        const sessions = Array.isArray(parsed.sessions)
+            ? parsed.sessions
+            : Array.isArray(parsed.runs)
+                ? parsed.runs
+                : [];
+        return {
+            version: parsed.version ?? RUN_INDEX_VERSION,
+            sessions,
+        };
     }
     catch (error) {
         if (isFileSystemError(error) && error.code === "ENOENT") {
-            return { version: RUN_INDEX_VERSION, runs: [] };
+            return { version: RUN_INDEX_VERSION, sessions: [] };
         }
         if (error instanceof SyntaxError) {
             throw new RunRecordParseError(path, error.message);
@@ -415,15 +425,15 @@ async function readRunIndex(path) {
 }
 async function upsertRunIndexEntry(indexPath, entry) {
     const payload = await readRunIndex(indexPath);
-    const existingIndex = payload.runs.findIndex((run) => run.runId === entry.runId);
+    const existingIndex = payload.sessions.findIndex((run) => run.runId === entry.runId);
     if (existingIndex >= 0) {
-        payload.runs[existingIndex] = {
-            ...payload.runs[existingIndex],
+        payload.sessions[existingIndex] = {
+            ...payload.sessions[existingIndex],
             ...entry,
         };
     }
     else {
-        payload.runs.push(entry);
+        payload.sessions.push(entry);
     }
     payload.version = RUN_INDEX_VERSION;
     await atomicWriteJson(indexPath, payload);

package/dist/utils/git.d.ts

@@ -28,6 +28,7 @@ export interface GitCommitOptions {
     message: string;
     authorName?: string;
     authorEmail?: string;
+    bypassHooks?: boolean;
 }
 export declare function gitCommitAll(options: GitCommitOptions): Promise<void>;
 export interface GitDiffStatOptions {

package/dist/utils/git.js

@@ -79,15 +79,25 @@ export async function gitHasStagedChanges(cwd) {
     return output.length > 0;
 }
 export async function gitCommitAll(options) {
-    const { cwd, message, authorName = GIT_AUTHOR_NAME, authorEmail = GIT_AUTHOR_EMAIL, } = options;
-    await runGitCommand(["commit", "-m", message], {
+    const { cwd, message, authorName = GIT_AUTHOR_NAME, authorEmail = GIT_AUTHOR_EMAIL, bypassHooks = false, } = options;
+    const args = ["commit", "-m", message];
+    if (bypassHooks) {
+        args.push("--no-verify");
+    }
+    const env = {
+        GIT_AUTHOR_NAME: authorName,
+        GIT_AUTHOR_EMAIL: authorEmail,
+        GIT_COMMITTER_NAME: authorName,
+        GIT_COMMITTER_EMAIL: authorEmail,
+    };
+    if (bypassHooks) {
+        env.HUSKY = "0";
+        env.HUSKY_SKIP_HOOKS = "1";
+        env.LEFTHOOK = "0";
+    }
+    await runGitCommand(args, {
         cwd,
-        env: {
-            GIT_AUTHOR_NAME: authorName,
-            GIT_AUTHOR_EMAIL: authorEmail,
-            GIT_COMMITTER_NAME: authorName,
-            GIT_COMMITTER_EMAIL: authorEmail,
-        },
+        env,
     });
 }
 export async function gitDiffShortStat(options) {

package/dist/workspace/agents.js

@@ -89,6 +89,7 @@ export async function collectAgentArtifacts(options) {
             message: summary,
             authorName: persona.authorName,
             authorEmail: persona.authorEmail,
+            bypassHooks: true,
         }));
         commitSha = await runGitStep("Git rev-parse failed", async () => runGitCommand(["rev-parse", "HEAD"], { cwd: workspacePath }));
         const diffContent = await runGitStep("Git diff failed", async () => gitDiff({

package/dist/workspace/layout.js

@@ -114,11 +114,13 @@ export async function scaffoldAgentWorkspace(paths) {
             filesToInitialize.add(absolutePath);
         }
     }
+    for (const filePath of filesToInitialize) {
+        directoriesToEnsure.add(dirname(filePath));
+    }
     for (const dirPath of directoriesToEnsure) {
         await mkdir(dirPath, { recursive: true });
     }
     for (const filePath of filesToInitialize) {
-        await mkdir(dirname(filePath), { recursive: true });
         await writeFile(filePath, "", { encoding: "utf8" });
     }
 }

package/dist/workspace/setup.js

@@ -2,7 +2,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { ensureDirectoryExists, ensureFileExists, isDirectory, pathExists, } from "../utils/fs.js";
 import { relativeToRoot } from "../utils/path.js";
 import { WorkspaceMissingEntryError, WorkspaceNotInitializedError, } from "./errors.js";
-import { resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ENVIRONMENT_FILE, VORATIQ_EVALS_FILE, VORATIQ_RUNS_DIR, VORATIQ_RUNS_FILE, VORATIQ_SANDBOX_FILE, } from "./structure.js";
+import { resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ENVIRONMENT_FILE, VORATIQ_EVALS_FILE, VORATIQ_RUNS_DIR, VORATIQ_RUNS_FILE, VORATIQ_RUNS_SESSIONS_DIR, VORATIQ_SANDBOX_FILE, } from "./structure.js";
 import { buildDefaultAgentsTemplate, buildDefaultEnvironmentTemplate, buildDefaultEvalsTemplate, buildDefaultSandboxTemplate, } from "./templates.js";
 export async function createWorkspace(root) {
     const createdDirectories = [];
@@ -17,9 +17,14 @@ export async function createWorkspace(root) {
         await mkdir(runsDir, { recursive: true });
         createdDirectories.push(relativeToRoot(root, runsDir));
     }
+    const sessionsDir = resolveWorkspacePath(root, VORATIQ_RUNS_SESSIONS_DIR);
+    if (!(await pathExists(sessionsDir))) {
+        await mkdir(sessionsDir, { recursive: true });
+        createdDirectories.push(relativeToRoot(root, sessionsDir));
+    }
     const runsIndexPath = resolveWorkspacePath(root, VORATIQ_RUNS_FILE);
     if (!(await pathExists(runsIndexPath))) {
-        const initialIndex = JSON.stringify({ version: 1, runs: [] }, null, 2);
+        const initialIndex = JSON.stringify({ version: 2, sessions: [] }, null, 2);
         await writeFile(runsIndexPath, `${initialIndex}\n`, { encoding: "utf8" });
         createdFiles.push(relativeToRoot(root, runsIndexPath));
     }
@@ -56,6 +61,7 @@ export async function createWorkspace(root) {
 export async function validateWorkspace(root) {
     const workspaceDir = resolveWorkspacePath(root);
     const runsDir = resolveWorkspacePath(root, VORATIQ_RUNS_DIR);
+    const sessionsDir = resolveWorkspacePath(root, VORATIQ_RUNS_SESSIONS_DIR);
     const runsIndexPath = resolveWorkspacePath(root, VORATIQ_RUNS_FILE);
     const agentsConfigPath = resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
     const evalsConfigPath = resolveWorkspacePath(root, VORATIQ_EVALS_FILE);
@@ -65,6 +71,7 @@ export async function validateWorkspace(root) {
         const missingEntries = [
             `${relativeToRoot(root, workspaceDir)}/`,
             `${relativeToRoot(root, runsDir)}/`,
+            `${relativeToRoot(root, sessionsDir)}/`,
             relativeToRoot(root, runsIndexPath),
             relativeToRoot(root, agentsConfigPath),
             relativeToRoot(root, environmentConfigPath),
@@ -73,6 +80,7 @@ export async function validateWorkspace(root) {
         throw new WorkspaceNotInitializedError(missingEntries);
     }
     await ensureDirectoryExists(runsDir, () => new WorkspaceMissingEntryError(relativeToRoot(root, runsDir)));
+    await ensureDirectoryExists(sessionsDir, () => new WorkspaceMissingEntryError(relativeToRoot(root, sessionsDir)));
     await ensureFileExists(runsIndexPath, () => new WorkspaceMissingEntryError(relativeToRoot(root, runsIndexPath)));
     await ensureFileExists(agentsConfigPath, () => new WorkspaceMissingEntryError(relativeToRoot(root, agentsConfigPath)));
     await ensureFileExists(evalsConfigPath, () => new WorkspaceMissingEntryError(relativeToRoot(root, evalsConfigPath)));

package/dist/workspace/structure.d.ts

@@ -3,6 +3,7 @@ import type { ChatArtifactFormat } from "./chat/types.js";
 export declare const VORATIQ_DIR = ".voratiq";
 export declare const VORATIQ_RUNS_DIR = "runs";
 export declare const VORATIQ_RUNS_FILE = "runs/index.json";
+export declare const VORATIQ_RUNS_SESSIONS_DIR = "runs/sessions";
 export declare const VORATIQ_AGENTS_FILE = "agents.yaml";
 export declare const VORATIQ_EVALS_FILE = "evals.yaml";
 export declare const VORATIQ_ENVIRONMENT_FILE = "environment.yaml";

package/dist/workspace/structure.js

@@ -4,6 +4,7 @@ import { assertRepoRelativePath, resolvePathWithinRoot, } from "../utils/path.js
 export const VORATIQ_DIR = ".voratiq";
 export const VORATIQ_RUNS_DIR = "runs";
 export const VORATIQ_RUNS_FILE = "runs/index.json";
+export const VORATIQ_RUNS_SESSIONS_DIR = "runs/sessions";
 export const VORATIQ_AGENTS_FILE = "agents.yaml";
 export const VORATIQ_EVALS_FILE = "evals.yaml";
 export const VORATIQ_ENVIRONMENT_FILE = "environment.yaml";
@@ -28,7 +29,7 @@ export function resolveWorkspacePath(root, ...segments) {
 export function formatWorkspacePath(...segments) {
     return [VORATIQ_DIR, ...segments].join("/");
 }
-const RUNS_SEGMENT = VORATIQ_RUNS_DIR;
+const RUNS_SESSION_SEGMENTS = [VORATIQ_RUNS_DIR, "sessions"];
 function assertPathSegment(label, value) {
     if (typeof value !== "string") {
         throw new Error(`${label} must be a string`);
@@ -43,7 +44,7 @@ function assertPathSegment(label, value) {
 }
 function formatRunScopedPath(runId, ...segments) {
     const safeRunId = assertPathSegment("runId", runId);
-    const scoped = formatWorkspacePath(RUNS_SEGMENT, safeRunId, ...segments);
+    const scoped = formatWorkspacePath(...RUNS_SESSION_SEGMENTS, safeRunId, ...segments);
     return assertRepoRelativePath(scoped);
 }
 function formatAgentScopedPath(runId, agentId, ...segments) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "voratiq",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.2",
   "description": "Run multiple AI coding agents in parallel, compare their results, and apply the best solution.",
   "keywords": [
     "ai",