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

package/dist/workspace/errors.js

@@ -11,15 +11,25 @@ export class WorkspaceError extends HintedError {
 export class WorkspaceMissingEntryError extends WorkspaceError {
     entryPath;
     constructor(entryPath) {
-        super(`Missing workspace entry: ${entryPath}`);
+        super(`Missing workspace entry: \`${entryPath}\`.`);
         this.entryPath = entryPath;
         this.name = "WorkspaceMissingEntryError";
     }
 }
+export class WorkspaceWrongTypeEntryError extends WorkspaceError {
+    entryPath;
+    expectedType;
+    constructor(entryPath, expectedType) {
+        super(`Wrong workspace entry type: \`${entryPath}\` must be a ${expectedType}.`);
+        this.entryPath = entryPath;
+        this.expectedType = expectedType;
+        this.name = "WorkspaceWrongTypeEntryError";
+    }
+}
 export class WorkspaceNotInitializedError extends WorkspaceError {
     missingEntries;
     constructor(missingEntries) {
-        super("Voratiq workspace not found; aborting run.", buildMissingEntryDetailLines(missingEntries), ["Run `voratiq init` from the repository root and rerun."]);
+        super("Voratiq workspace is not initialized.", buildMissingEntryDetailLines(missingEntries), ["Run `voratiq init` from the repository root, then retry."]);
         this.missingEntries = missingEntries;
         this.name = "WorkspaceNotInitializedError";
     }
@@ -38,6 +48,6 @@ function buildMissingEntryDetailLines(entries) {
     }
     return [
         "Missing workspace entries:",
-        ...entries.map((entry) => `  - ${entry}`),
+        ...entries.map((entry) => `  - \`${entry}\``),
     ];
 }

package/dist/workspace/layout.d.ts

@@ -5,16 +5,13 @@ export interface RunWorkspacePaths {
 }
 export declare function resolveRunWorkspacePaths(root: string, runId: string): RunWorkspacePaths;
 export declare function formatRunWorkspaceRelative(runId: string): string;
-export declare const WORKSPACE_SUMMARY_FILENAME: ".summary.txt";
 export interface AgentWorkspacePaths {
     agentRoot: string;
+    artifactsPath: string;
+    contextPath: string;
     stdoutPath: string;
     stderrPath: string;
-    diffPath: string;
-    summaryPath: string;
     workspacePath: string;
-    evalsDirPath: string;
-    promptPath: string;
     runtimeManifestPath: string;
     sandboxPath: string;
     sandboxHomePath: string;
@@ -26,5 +23,19 @@ export declare function buildAgentWorkspacePaths(options: {
     runId: string;
     agentId: AgentId;
 }): AgentWorkspacePaths;
-export declare function resolveRunPromptPath(root: string, runId: string): string;
+export declare function buildAgentSessionWorkspacePaths(options: {
+    root: string;
+    domain: string;
+    sessionId: string;
+    agentId: AgentId;
+}): AgentWorkspacePaths;
+export declare function buildScopedAgentWorkspacePaths(options: {
+    agentRoot: string;
+}): AgentWorkspacePaths;
 export declare function scaffoldAgentWorkspace(paths: AgentWorkspacePaths): Promise<void>;
+export declare function scaffoldAgentSessionWorkspace(options: {
+    root: string;
+    domain: string;
+    sessionId: string;
+    agentId: AgentId;
+}): Promise<AgentWorkspacePaths>;

package/dist/workspace/layout.js

@@ -1,7 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { normalizePathForDisplay, resolvePath } from "../utils/path.js";
-import { getAgentDiffPath, getAgentDirectoryPath, getAgentEvalsDirectoryPath, getAgentManifestPath, getAgentRuntimeDirectoryPath, getAgentSandboxDirectoryPath, getAgentSandboxHomePath, getAgentSandboxSettingsPath, getAgentStderrPath, getAgentStdoutPath, getAgentSummaryPath, getAgentWorkspaceDirectoryPath, getRunDirectoryPath, getRunPromptPath, } from "./structure.js";
+import { ARTIFACTS_DIRNAME, CONTEXT_DIRNAME, getAgentSessionArtifactsDirectoryPath, getAgentSessionContextDirectoryPath, getAgentSessionDirectoryPath, getAgentSessionManifestPath, getAgentSessionRuntimeDirectoryPath, getAgentSessionSandboxDirectoryPath, getAgentSessionSandboxHomePath, getAgentSessionSandboxSettingsPath, getAgentSessionStderrPath, getAgentSessionStdoutPath, getAgentSessionWorkspaceDirectoryPath, getRunDirectoryPath, MANIFEST_FILENAME, RUNTIME_DIRNAME, SANDBOX_DIRNAME, SANDBOX_SETTINGS_FILENAME, STDERR_FILENAME, STDOUT_FILENAME, VORATIQ_RUN_DIR, WORKSPACE_DIRNAME, } from "./structure.js";
 export function resolveRunWorkspacePaths(root, runId) {
     const relative = normalizePathForDisplay(getRunDirectoryPath(runId));
     const absolute = resolvePath(root, relative);
@@ -10,63 +10,55 @@ export function resolveRunWorkspacePaths(root, runId) {
 export function formatRunWorkspaceRelative(runId) {
     return normalizePathForDisplay(getRunDirectoryPath(runId));
 }
-export const WORKSPACE_SUMMARY_FILENAME = ".summary.txt";
 const AGENT_WORKSPACE_ARTIFACTS = {
-    stdoutPath: {
-        getRelativePath: ({ runId, agentId }) => getAgentStdoutPath(runId, agentId),
-        initializeEmptyFile: true,
+    artifactsPath: {
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionArtifactsDirectoryPath(domain, sessionId, agentId),
+        ensureDir: true,
     },
-    stderrPath: {
-        getRelativePath: ({ runId, agentId }) => getAgentStderrPath(runId, agentId),
-        initializeEmptyFile: true,
+    contextPath: {
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionContextDirectoryPath(domain, sessionId, agentId),
+        ensureDir: true,
     },
-    diffPath: {
-        getRelativePath: ({ runId, agentId }) => getAgentDiffPath(runId, agentId),
+    stdoutPath: {
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionStdoutPath(domain, sessionId, agentId),
         initializeEmptyFile: true,
     },
-    summaryPath: {
-        getRelativePath: ({ runId, agentId }) => getAgentSummaryPath(runId, agentId),
+    stderrPath: {
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionStderrPath(domain, sessionId, agentId),
         initializeEmptyFile: true,
     },
     workspacePath: {
-        getRelativePath: ({ runId, agentId }) => getAgentWorkspaceDirectoryPath(runId, agentId),
-        ensureDir: true,
-    },
-    evalsDirPath: {
-        getRelativePath: ({ runId, agentId }) => getAgentEvalsDirectoryPath(runId, agentId),
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionWorkspaceDirectoryPath(domain, sessionId, agentId),
         ensureDir: true,
     },
-    promptPath: {
-        getRelativePath: ({ runId }) => getRunPromptPath(runId),
-    },
     runtimeManifestPath: {
-        getRelativePath: ({ runId, agentId }) => getAgentManifestPath(runId, agentId),
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionManifestPath(domain, sessionId, agentId),
     },
     runtimePath: {
-        getRelativePath: ({ runId, agentId }) => getAgentRuntimeDirectoryPath(runId, agentId),
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionRuntimeDirectoryPath(domain, sessionId, agentId),
         ensureDir: true,
     },
     sandboxPath: {
-        getRelativePath: ({ runId, agentId }) => getAgentSandboxDirectoryPath(runId, agentId),
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionSandboxDirectoryPath(domain, sessionId, agentId),
         ensureDir: true,
     },
     sandboxHomePath: {
-        getRelativePath: ({ runId, agentId }) => getAgentSandboxHomePath(runId, agentId),
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionSandboxHomePath(domain, sessionId, agentId),
         ensureDir: true,
     },
     sandboxSettingsPath: {
-        getRelativePath: ({ runId, agentId }) => getAgentSandboxSettingsPath(runId, agentId),
+        getRelativePath: ({ domain, sessionId, agentId }) => getAgentSessionSandboxSettingsPath(domain, sessionId, agentId),
     },
 };
 function getAgentWorkspaceArtifactDescriptorEntries() {
     return Object.entries(AGENT_WORKSPACE_ARTIFACTS);
 }
 function resolveAgentWorkspaceArtifactPaths(options) {
-    const { root, runId, agentId } = options;
+    const { root, domain, sessionId, agentId } = options;
     const entries = getAgentWorkspaceArtifactDescriptorEntries();
     const map = Object.create(null);
     for (const [key, descriptor] of entries) {
-        const relative = normalizePathForDisplay(descriptor.getRelativePath({ runId, agentId }));
+        const relative = normalizePathForDisplay(descriptor.getRelativePath({ domain, sessionId, agentId }));
         map[key] = {
             relative,
             absolute: resolvePath(root, relative),
@@ -83,22 +75,44 @@ function buildAbsoluteArtifactPathMap(artifactPaths) {
 }
 export function buildAgentWorkspacePaths(options) {
     const { root, runId, agentId } = options;
+    return buildAgentSessionWorkspacePaths({
+        root,
+        domain: VORATIQ_RUN_DIR,
+        sessionId: runId,
+        agentId,
+    });
+}
+export function buildAgentSessionWorkspacePaths(options) {
+    const { root, domain, sessionId, agentId } = options;
     const artifactPaths = resolveAgentWorkspaceArtifactPaths({
         root,
-        runId,
+        domain,
+        sessionId,
         agentId,
     });
     const absoluteArtifacts = buildAbsoluteArtifactPathMap(artifactPaths);
-    const agentRelative = normalizePathForDisplay(getAgentDirectoryPath(runId, agentId));
+    const agentRelative = normalizePathForDisplay(getAgentSessionDirectoryPath(domain, sessionId, agentId));
     const agentRoot = resolvePath(root, agentRelative);
     return {
         agentRoot,
         ...absoluteArtifacts,
     };
 }
-export function resolveRunPromptPath(root, runId) {
-    const promptRelative = normalizePathForDisplay(getRunPromptPath(runId));
-    return resolvePath(root, promptRelative);
+export function buildScopedAgentWorkspacePaths(options) {
+    const { agentRoot } = options;
+    return {
+        agentRoot,
+        artifactsPath: resolvePath(agentRoot, ARTIFACTS_DIRNAME),
+        contextPath: resolvePath(agentRoot, CONTEXT_DIRNAME),
+        stdoutPath: resolvePath(agentRoot, ARTIFACTS_DIRNAME, STDOUT_FILENAME),
+        stderrPath: resolvePath(agentRoot, ARTIFACTS_DIRNAME, STDERR_FILENAME),
+        workspacePath: resolvePath(agentRoot, WORKSPACE_DIRNAME),
+        runtimeManifestPath: resolvePath(agentRoot, RUNTIME_DIRNAME, MANIFEST_FILENAME),
+        sandboxPath: resolvePath(agentRoot, SANDBOX_DIRNAME),
+        sandboxHomePath: resolvePath(agentRoot, SANDBOX_DIRNAME),
+        sandboxSettingsPath: resolvePath(agentRoot, RUNTIME_DIRNAME, SANDBOX_SETTINGS_FILENAME),
+        runtimePath: resolvePath(agentRoot, RUNTIME_DIRNAME),
+    };
 }
 export async function scaffoldAgentWorkspace(paths) {
     await mkdir(paths.agentRoot, { recursive: true });
@@ -124,3 +138,8 @@ export async function scaffoldAgentWorkspace(paths) {
         await writeFile(filePath, "", { encoding: "utf8" });
     }
 }
+export async function scaffoldAgentSessionWorkspace(options) {
+    const paths = buildAgentSessionWorkspacePaths(options);
+    await scaffoldAgentWorkspace(paths);
+    return paths;
+}

package/dist/workspace/promotion.d.ts

@@ -0,0 +1,32 @@
+export interface PromoteWorkspaceFileOptions {
+    /** Absolute path to the writable workspace root. */
+    workspacePath: string;
+    /** Absolute path to the artifacts directory for the agent. */
+    artifactsPath: string;
+    /** Relative path (within workspace) to the staged file. */
+    stagedRelativePath: string;
+    /** Relative path (within artifacts/) where the file should be promoted. */
+    artifactRelativePath: string;
+    /**
+     * Optional transform applied to the staged file contents before writing to
+     * artifacts. Receives the raw bytes read from the staged file.
+     */
+    transform?: (content: Buffer) => string | Buffer | Promise<string | Buffer>;
+    /**
+     * When the transform returns a string, this encoding is used when writing the
+     * artifact (defaults to utf8).
+     */
+    stringEncoding?: NodeJS.BufferEncoding;
+    /** Whether to delete the staged file after promotion (default: true). */
+    deleteStaged?: boolean;
+}
+export interface PromoteWorkspaceFileResult {
+    stagedPath: string;
+    artifactPath: string;
+}
+/**
+ * Promote a staged file written inside the sandboxed workspace into the
+ * trusted artifacts directory. This helper enforces path containment for both
+ * the source and destination and optionally transforms content before writing.
+ */
+export declare function promoteWorkspaceFile(options: PromoteWorkspaceFileOptions): Promise<PromoteWorkspaceFileResult>;

package/dist/workspace/promotion.js

@@ -0,0 +1,34 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve as resolvePath } from "node:path";
+import { assertPathWithinRoot } from "../utils/path.js";
+/**
+ * Promote a staged file written inside the sandboxed workspace into the
+ * trusted artifacts directory. This helper enforces path containment for both
+ * the source and destination and optionally transforms content before writing.
+ */
+export async function promoteWorkspaceFile(options) {
+    const workspacePath = options.workspacePath;
+    const artifactsPath = options.artifactsPath;
+    const stagedRelativePath = options.stagedRelativePath;
+    const artifactRelativePath = options.artifactRelativePath;
+    const transform = options.transform;
+    const stringEncoding = options.stringEncoding ?? "utf8";
+    const deleteStaged = options.deleteStaged !== false;
+    const stagedPath = assertPathWithinRoot(workspacePath, resolvePath(workspacePath, stagedRelativePath), {
+        message: `Staged path "${stagedRelativePath}" must stay inside workspace "${workspacePath}".`,
+    });
+    const artifactPath = assertPathWithinRoot(artifactsPath, resolvePath(artifactsPath, artifactRelativePath), {
+        message: `Artifact path "${artifactRelativePath}" must stay inside artifacts directory "${artifactsPath}".`,
+    });
+    const raw = await readFile(stagedPath);
+    const transformed = transform ? await transform(raw) : raw;
+    const payload = typeof transformed === "string"
+        ? Buffer.from(transformed, stringEncoding)
+        : transformed;
+    await mkdir(dirname(artifactPath), { recursive: true });
+    await writeFile(artifactPath, payload);
+    if (deleteStaged) {
+        await rm(stagedPath, { force: true }).catch(() => { });
+    }
+    return { stagedPath, artifactPath };
+}

package/dist/workspace/prune.d.ts

@@ -1,4 +1,4 @@
-import type { RunRecord } from "../records/types.js";
+import type { RunRecord } from "../domain/run/model/types.js";
 export declare function removeWorkspaceEntry(options: {
     path: string;
     root: string;

package/dist/workspace/run.d.ts

@@ -1,14 +1,12 @@
 import type { RunWorkspacePaths } from "./layout.js";
 export interface RunWorkspaceSetupResult {
     readonly runWorkspace: RunWorkspacePaths;
-    readonly prompt: string;
 }
 export interface WorkspaceSetupInput {
     readonly root: string;
     readonly runId: string;
-    readonly prompt: string;
 }
 /**
- * Prepare run workspace directory and write prompt file.
+ * Prepare run workspace directory.
  */
 export declare function prepareRunWorkspace(input: WorkspaceSetupInput): Promise<RunWorkspaceSetupResult>;

package/dist/workspace/run.js

@@ -1,14 +1,13 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { RunDirectoryExistsError } from "../commands/run/errors.js";
+import { mkdir } from "node:fs/promises";
+import { RunDirectoryExistsError } from "../domain/run/competition/errors.js";
 import { pathExists } from "../utils/fs.js";
 import { normalizePathForDisplay, relativeToRoot } from "../utils/path.js";
-import { cleanupRunWorkspace } from "./cleanup.js";
-import { resolveRunPromptPath, resolveRunWorkspacePaths } from "./layout.js";
+import { resolveRunWorkspacePaths } from "./layout.js";
 /**
- * Prepare run workspace directory and write prompt file.
+ * Prepare run workspace directory.
  */
 export async function prepareRunWorkspace(input) {
-    const { root, runId, prompt } = input;
+    const { root, runId } = input;
     const runWorkspace = resolveRunWorkspacePaths(root, runId);
     const runRoot = runWorkspace.absolute;
     if (await pathExists(runRoot)) {
@@ -16,13 +15,5 @@ export async function prepareRunWorkspace(input) {
         throw new RunDirectoryExistsError(runId, displayPath);
     }
     await mkdir(runRoot, { recursive: true });
-    try {
-        const promptPath = resolveRunPromptPath(root, runId);
-        await writeFile(promptPath, prompt, { encoding: "utf8" });
-    }
-    catch (error) {
-        await cleanupRunWorkspace(runRoot);
-        throw error;
-    }
-    return { runWorkspace, prompt };
+    return { runWorkspace };
 }

package/dist/workspace/setup.d.ts

@@ -1,3 +1,11 @@
 import type { CreateWorkspaceResult } from "./types.js";
+export interface RepairWorkspaceStructureResult {
+    readonly repaired: boolean;
+    readonly createdDirectories: string[];
+    readonly createdFiles: string[];
+}
 export declare function createWorkspace(root: string): Promise<CreateWorkspaceResult>;
+export declare function repairWorkspaceStructure(root: string, options?: {
+    restoreShippedVerificationTemplates?: boolean;
+}): Promise<RepairWorkspaceStructureResult>;
 export declare function validateWorkspace(root: string): Promise<void>;