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

package/dist/utils/errors.d.ts

@@ -1,5 +1,7 @@
+export type GitRepositoryErrorReason = "no_repository" | "not_repository_root";
 export declare class GitRepositoryError extends Error {
-    constructor(message: string);
+    readonly reason: GitRepositoryErrorReason;
+    constructor(message: string, reason: GitRepositoryErrorReason);
 }
 export declare class ValidationError extends Error {
     constructor(message: string);

package/dist/utils/errors.js

@@ -1,7 +1,9 @@
 export class GitRepositoryError extends Error {
-    constructor(message) {
+    reason;
+    constructor(message, reason) {
         super(message);
         this.name = "GitRepositoryError";
+        this.reason = reason;
     }
 }
 export class ValidationError extends Error {

package/dist/utils/git.d.ts

@@ -21,6 +21,16 @@ export interface CreateWorktreeOptions {
     baseRevision: string;
 }
 export declare function createWorktree(options: CreateWorktreeOptions): Promise<void>;
+export interface CreateDetachedWorktreeOptions {
+    root: string;
+    worktreePath: string;
+    baseRevision: string;
+}
+export declare function createDetachedWorktree(options: CreateDetachedWorktreeOptions): Promise<void>;
+export declare function removeWorktree(options: {
+    root: string;
+    worktreePath: string;
+}): Promise<void>;
 export declare function gitAddAll(cwd: string): Promise<void>;
 export declare function gitHasStagedChanges(cwd: string): Promise<boolean>;
 export interface GitCommitOptions {

package/dist/utils/git.js

@@ -20,10 +20,10 @@ export async function assertGitRepository(root) {
         const repoRoot = await getGitRepositoryRoot(root);
         if (repoRoot !== null) {
             // We're in a repo but not at the root
-            throw new GitRepositoryError("Run `voratiq init` from the repository root.");
+            throw new GitRepositoryError("Run `voratiq init` from the repository root.", "not_repository_root");
         }
         // No git repository exists at all
-        throw new GitRepositoryError("No git repository found. Run `git init` or switch to an existing repository.");
+        throw new GitRepositoryError("No git repository found. Run `git init` or switch to an existing repository.", "no_repository");
     }
 }
 /**
@@ -68,6 +68,18 @@ export async function createWorktree(options) {
     const { root, worktreePath, branch, baseRevision } = options;
     await runGitCommand(["worktree", "add", "-b", branch, worktreePath, baseRevision], { cwd: root });
 }
+export async function createDetachedWorktree(options) {
+    const { root, worktreePath, baseRevision } = options;
+    await runGitCommand(["worktree", "add", "--detach", worktreePath, baseRevision], {
+        cwd: root,
+    });
+}
+export async function removeWorktree(options) {
+    const { root, worktreePath } = options;
+    await runGitCommand(["worktree", "remove", "--force", worktreePath], {
+        cwd: root,
+    });
+}
 export async function gitAddAll(cwd) {
     await runGitCommand(["add", "-A"], { cwd });
 }
@@ -107,7 +119,7 @@ export async function gitDiffShortStat(options) {
 }
 export async function gitDiff(options) {
     const { cwd, baseRevision, targetRevision } = options;
-    return runGitCommand(["diff", "--no-color", baseRevision, targetRevision], {
+    return runGitCommand(["diff", "--binary", "--no-color", baseRevision, targetRevision], {
         cwd,
         trim: false,
     });

package/dist/utils/output.d.ts

@@ -1,4 +1,8 @@
 import { type TerminalColor } from "./colors.js";
-export declare function formatCliOutput(value: string): string;
+export interface FormatCliOutputOptions {
+    leadingNewline?: boolean;
+    trailingNewline?: boolean;
+}
+export declare function formatCliOutput(value: string, options?: FormatCliOutputOptions): string;
 export declare function formatAlertMessage(label: string, color: TerminalColor, message: string): string;
 export declare function formatErrorMessage(message: string): string;

package/dist/utils/output.js

@@ -1,7 +1,9 @@
 import { colorize } from "./colors.js";
-export function formatCliOutput(value) {
+export function formatCliOutput(value, options = {}) {
     const trimmedEnd = value.trimEnd();
-    return `\n${trimmedEnd}\n\n`;
+    const leading = options.leadingNewline === false ? "" : "\n";
+    const trailing = options.trailingNewline === false ? "\n" : "\n\n";
+    return `${leading}${trimmedEnd}${trailing}`;
 }
 export function formatAlertMessage(label, color, message) {
     const prefix = colorize(`${label}:`, color);

package/dist/utils/process.d.ts

@@ -3,6 +3,7 @@ export interface StreamTarget {
     writable: Writable;
     endOnClose?: boolean;
 }
+export type ProcessOutputSource = "stdout" | "stderr";
 export interface SpawnStreamingProcessOptions {
     command: string;
     args?: string[];
@@ -13,7 +14,7 @@ export interface SpawnStreamingProcessOptions {
     stdout: StreamTarget;
     stderr: StreamTarget;
     /** Optional callback invoked for each chunk of stdout/stderr data. */
-    onData?: (chunk: Buffer) => void;
+    onData?: (chunk: Buffer, source: ProcessOutputSource) => void;
     /** Optional callback invoked when the process is spawned, providing the child process. */
     onSpawn?: (child: import("node:child_process").ChildProcess) => void;
     /**

package/dist/utils/process.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { RunProcessStreamError } from "../commands/run/errors.js";
+import { RunProcessStreamError } from "../domain/run/competition/errors.js";
 import { composeRestrictedEnvironment } from "./env.js";
 export async function spawnStreamingProcess(options) {
     const { command, args = [], cwd, env, shell = false, stdin, stdout, stderr, onData, onSpawn, abortSignal, detached = false, } = options;
@@ -24,8 +24,12 @@ export async function spawnStreamingProcess(options) {
             return;
         }
         if (onData) {
-            childStdout.on("data", onData);
-            childStderr.on("data", onData);
+            childStdout.on("data", (chunk) => {
+                onData(chunk, "stdout");
+            });
+            childStderr.on("data", (chunk) => {
+                onData(chunk, "stderr");
+            });
         }
         childStdout.pipe(stdout.writable, { end: false });
         childStderr.pipe(stderr.writable, { end: false });

package/dist/utils/session-id.d.ts

@@ -0,0 +1 @@
+export declare function generateSessionId(now?: Date): string;

package/dist/utils/session-id.js

@@ -0,0 +1,22 @@
+import { randomBytes } from "node:crypto";
+function generateSlug(length) {
+    const alphabet = "abcdefghijklmnopqrstuvwxyz";
+    const bytes = randomBytes(length);
+    let slug = "";
+    for (let index = 0; index < length; index += 1) {
+        const value = bytes[index] ?? 0;
+        slug += alphabet[value % alphabet.length];
+    }
+    return slug;
+}
+export function generateSessionId(now = new Date()) {
+    const pad = (value) => value.toString().padStart(2, "0");
+    const year = now.getUTCFullYear();
+    const month = pad(now.getUTCMonth() + 1);
+    const day = pad(now.getUTCDate());
+    const hours = pad(now.getUTCHours());
+    const minutes = pad(now.getUTCMinutes());
+    const seconds = pad(now.getUTCSeconds());
+    const slug = generateSlug(5);
+    return `${year}${month}${day}-${hours}${minutes}${seconds}-${slug}`;
+}

package/dist/utils/slug.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeSlug(value: string): string;
+export declare function slugify(value: string, fallback: string): string;

package/dist/utils/slug.js

@@ -0,0 +1,15 @@
+export function sanitizeSlug(value) {
+    const withoutLinks = value.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    const normalized = withoutLinks
+        .toLowerCase()
+        .replace(/[`*~]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+/u, "")
+        .replace(/-+$/u, "");
+    return normalized;
+}
+export function slugify(value, fallback) {
+    const normalized = sanitizeSlug(value);
+    return normalized.length > 0 ? normalized : fallback;
+}

package/dist/utils/voratiq-cli-target.d.ts

@@ -0,0 +1,9 @@
+export interface VoratiqCliTarget {
+    command: string;
+    argsPrefix: string[];
+}
+export declare function createEntrypointVoratiqCliTarget(input: {
+    cliEntrypoint: string | undefined;
+    nodeExecutable?: string;
+}): VoratiqCliTarget | undefined;
+export declare function resolveVoratiqCliTarget(): VoratiqCliTarget;

package/dist/utils/voratiq-cli-target.js

@@ -0,0 +1,58 @@
+import { realpathSync } from "node:fs";
+import process from "node:process";
+import { detectBinary } from "./binaries.js";
+export function createEntrypointVoratiqCliTarget(input) {
+    const { cliEntrypoint, nodeExecutable = process.execPath } = input;
+    if (!cliEntrypoint || cliEntrypoint.length === 0) {
+        return undefined;
+    }
+    const executableScriptEntrypoint = resolveNodeScriptEntrypoint(cliEntrypoint);
+    if (!executableScriptEntrypoint) {
+        return {
+            command: cliEntrypoint,
+            argsPrefix: [],
+        };
+    }
+    return {
+        command: nodeExecutable,
+        argsPrefix: [executableScriptEntrypoint],
+    };
+}
+export function resolveVoratiqCliTarget() {
+    const installedBinary = detectBinary("voratiq");
+    if (installedBinary) {
+        const executableScriptEntrypoint = resolveNodeScriptEntrypoint(installedBinary);
+        if (executableScriptEntrypoint) {
+            return {
+                command: process.execPath,
+                argsPrefix: [executableScriptEntrypoint],
+            };
+        }
+        return {
+            command: installedBinary,
+            argsPrefix: [],
+        };
+    }
+    return {
+        command: "voratiq",
+        argsPrefix: [],
+    };
+}
+function isNodeScriptEntrypoint(path) {
+    return path.endsWith(".js") || path.endsWith(".mjs") || path.endsWith(".cjs");
+}
+function resolveNodeScriptEntrypoint(path) {
+    if (isNodeScriptEntrypoint(path)) {
+        return path;
+    }
+    try {
+        const resolved = realpathSync(path);
+        if (isNodeScriptEntrypoint(resolved)) {
+            return resolved;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}

package/dist/workspace/agents.d.ts

@@ -1,33 +1,30 @@
-import { WorkspaceSetupRunError } from "../commands/run/errors.js";
+import type { SandboxStageId } from "../agents/runtime/policy.js";
 import type { AgentId } from "../configs/agents/types.js";
 import type { EnvironmentConfig } from "../configs/environment/types.js";
+import { WorkspaceSetupRunError } from "../domain/run/competition/errors.js";
 import { type AgentWorkspacePaths } from "./layout.js";
-export interface ArtifactCollectionResult {
-    summaryCaptured: boolean;
-    diffStatistics?: string;
-    commitSha?: string;
-    diffAttempted: boolean;
-    diffCaptured: boolean;
-}
 export interface SandboxPersona {
     authorName: string;
     authorEmail: string;
 }
-export declare function prepareAgentWorkspace(options: {
+export declare function prepareScratchAgentWorkspace(options: {
+    paths: AgentWorkspacePaths;
+}): Promise<void>;
+export declare function prepareStageAgentWorkspace(options: {
     paths: AgentWorkspacePaths;
     baseRevisionSha: string;
     root: string;
     agentId: AgentId;
-    runId: string;
+    sessionId: string;
+    stageId: SandboxStageId;
     environment: EnvironmentConfig;
 }): Promise<void>;
-export declare function collectAgentArtifacts(options: {
+export declare function prepareAgentWorkspace(options: {
+    paths: AgentWorkspacePaths;
     baseRevisionSha: string;
-    workspacePath: string;
-    summaryPath: string;
-    diffPath: string;
     root: string;
+    agentId: AgentId;
+    runId: string;
     environment: EnvironmentConfig;
-    persona: SandboxPersona;
-}): Promise<ArtifactCollectionResult>;
+}): Promise<void>;
 export declare function ensureWorkspaceError(error: unknown): WorkspaceSetupRunError;

package/dist/workspace/agents.js

@@ -1,15 +1,14 @@
-import { readFile, rm, writeFile } from "node:fs/promises";
-import { AgentProcessError, GitOperationError, WorkspaceSetupRunError, } from "../commands/run/errors.js";
+import { rm } from "node:fs/promises";
+import { WorkspaceSetupRunError } from "../domain/run/competition/errors.js";
 import { toErrorMessage } from "../utils/errors.js";
-import { createWorktree, gitAddAll, gitCommitAll, gitDiff, gitDiffShortStat, gitHasStagedChanges, runGitCommand, } from "../utils/git.js";
+import { createWorktree } from "../utils/git.js";
 import { resolvePath } from "../utils/path.js";
-import { enforceCredentialExclusion } from "./credential-guard.js";
-import { cleanupWorkspaceDependencies, ensureWorkspaceDependencies, WorkspaceDependencyCleanupError, } from "./dependencies.js";
+import { ensureWorkspaceDependencies } from "./dependencies.js";
 import { WorkspaceSetupError } from "./errors.js";
-import { scaffoldAgentWorkspace, WORKSPACE_SUMMARY_FILENAME, } from "./layout.js";
+import { scaffoldAgentWorkspace } from "./layout.js";
 import { ensureWorkspaceShim } from "./shim.js";
-export async function prepareAgentWorkspace(options) {
-    const { paths, baseRevisionSha, root, agentId, runId, environment } = options;
+export async function prepareScratchAgentWorkspace(options) {
+    const { paths } = options;
     try {
         await scaffoldAgentWorkspace(paths);
         await rm(resolvePath(paths.agentRoot, "tmp"), {
@@ -20,11 +19,15 @@ export async function prepareAgentWorkspace(options) {
     catch (error) {
         throw ensureWorkspaceError(error);
     }
+}
+export async function prepareStageAgentWorkspace(options) {
+    const { paths, baseRevisionSha, root, agentId, sessionId, stageId, environment, } = options;
+    await prepareScratchAgentWorkspace({ paths });
     try {
         await createWorktree({
             root,
             worktreePath: paths.workspacePath,
-            branch: `voratiq/run/${runId}/${agentId}`,
+            branch: `voratiq/${stageId}/${sessionId}/${agentId}`,
             baseRevision: baseRevisionSha,
         });
         await ensureWorkspaceDependencies({
@@ -40,111 +43,16 @@ export async function prepareAgentWorkspace(options) {
         throw ensureWorkspaceError(error);
     }
 }
-export async function collectAgentArtifacts(options) {
-    const { baseRevisionSha, workspacePath, summaryPath, diffPath, root, environment, persona, } = options;
-    let dependenciesCleanup = {
-        nodeRemoved: false,
-        pythonRemoved: false,
-    };
-    let cleanupFailed = false;
-    try {
-        dependenciesCleanup = await cleanupWorkspaceDependencies({
-            root,
-            workspacePath,
-            environment,
-        });
-    }
-    catch (error) {
-        cleanupFailed = true;
-        if (error instanceof WorkspaceDependencyCleanupError) {
-            dependenciesCleanup = error.cleanup;
-        }
-    }
-    let runFailed = true;
-    let artifactResult;
-    let dependencyRestoreError;
-    try {
-        await runGitStep("Git add failed", async () => gitAddAll(workspacePath));
-        const hasChangesBeforeSummary = await gitHasStagedChanges(workspacePath);
-        if (!hasChangesBeforeSummary) {
-            throw new AgentProcessError({
-                detail: "Agent process failed. No workspace changes detected.",
-            });
-        }
-        const { summary } = await harvestSummary({
-            workspacePath,
-            summaryPath,
-        });
-        await runGitStep("Git add failed", async () => gitAddAll(workspacePath));
-        const hasChanges = await gitHasStagedChanges(workspacePath);
-        if (!hasChanges) {
-            throw new AgentProcessError({
-                detail: "Agent process failed. No workspace changes detected.",
-            });
-        }
-        let diffStatistics;
-        let commitSha;
-        await runGitStep("Git commit failed", async () => gitCommitAll({
-            cwd: workspacePath,
-            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({
-            cwd: workspacePath,
-            baseRevision: baseRevisionSha,
-            targetRevision: "HEAD",
-        }));
-        await enforceCredentialExclusion({
-            workspacePath,
-            diffContent,
-        });
-        await writeFile(diffPath, diffContent, { encoding: "utf8" });
-        diffStatistics = await runGitStep("Git diff --shortstat failed", async () => gitDiffShortStat({
-            cwd: workspacePath,
-            baseRevision: baseRevisionSha,
-            targetRevision: "HEAD",
-        }));
-        runFailed = false;
-        artifactResult = {
-            summaryCaptured: true,
-            diffStatistics,
-            commitSha,
-            diffAttempted: true,
-            diffCaptured: true,
-        };
-    }
-    finally {
-        const cleanupTouched = dependenciesCleanup.nodeRemoved || dependenciesCleanup.pythonRemoved;
-        const shouldRestoreDependencies = cleanupTouched || cleanupFailed;
-        if (shouldRestoreDependencies) {
-            try {
-                await ensureWorkspaceDependencies({
-                    root,
-                    workspacePath,
-                    environment,
-                });
-            }
-            catch (error) {
-                if (!runFailed) {
-                    dependencyRestoreError = new AgentProcessError({
-                        detail: `[voratiq] Failed to restore workspace dependencies after export: ${toErrorMessage(error)}`,
-                    });
-                }
-            }
-        }
-    }
-    if (dependencyRestoreError) {
-        throw dependencyRestoreError;
-    }
-    if (!artifactResult) {
-        throw new AgentProcessError({
-            detail: "Agent process failed before artifacts were collected.",
-        });
-    }
-    return artifactResult;
+export async function prepareAgentWorkspace(options) {
+    return await prepareStageAgentWorkspace({
+        paths: options.paths,
+        baseRevisionSha: options.baseRevisionSha,
+        root: options.root,
+        agentId: options.agentId,
+        sessionId: options.runId,
+        stageId: "run",
+        environment: options.environment,
+    });
 }
 export function ensureWorkspaceError(error) {
     if (error instanceof WorkspaceSetupError) {
@@ -155,36 +63,3 @@ export function ensureWorkspaceError(error) {
     }
     return new WorkspaceSetupRunError(toErrorMessage(error));
 }
-async function harvestSummary(options) {
-    const { workspacePath, summaryPath } = options;
-    const workspaceSummaryPath = resolvePath(workspacePath, WORKSPACE_SUMMARY_FILENAME);
-    let raw;
-    try {
-        raw = await readFile(workspaceSummaryPath, "utf8");
-    }
-    catch (error) {
-        throw new AgentProcessError({ detail: toErrorMessage(error) });
-    }
-    const trimmed = raw.trim();
-    if (!trimmed) {
-        throw new AgentProcessError({
-            detail: "Agent process failed. Summary is empty.",
-        });
-    }
-    await writeFile(summaryPath, `${trimmed}\n`, { encoding: "utf8" });
-    await rm(workspaceSummaryPath, { force: true });
-    return {
-        summary: trimmed,
-    };
-}
-async function runGitStep(operationMessage, step) {
-    try {
-        return await step();
-    }
-    catch (error) {
-        throw new GitOperationError({
-            operation: operationMessage,
-            detail: toErrorMessage(error),
-        });
-    }
-}

package/dist/workspace/chat/artifacts.d.ts

@@ -10,5 +10,14 @@ export interface ChatArtifactCaptureResult {
 export interface PreserveChatArtifactsOptions {
     providerId: string;
     agentRoot: string;
+    searchEnv?: NodeJS.ProcessEnv;
+    baseline?: ProviderTranscriptBaseline;
 }
+export interface ProviderTranscriptSnapshotEntry {
+    path: string;
+    size: number;
+    mtimeMs: number;
+}
+export type ProviderTranscriptBaseline = readonly ProviderTranscriptSnapshotEntry[];
+export declare function snapshotProviderTranscripts(options: Omit<PreserveChatArtifactsOptions, "baseline">): Promise<ProviderTranscriptBaseline>;
 export declare function preserveProviderChatTranscripts(options: PreserveChatArtifactsOptions): Promise<ChatArtifactCaptureResult>;

package/dist/workspace/chat/artifacts.js

@@ -1,28 +1,39 @@
 import { once } from "node:events";
 import { createReadStream, createWriteStream } from "node:fs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, relative, resolve } from "node:path";
 import { finished } from "node:stream/promises";
 import { pathExists } from "../../utils/fs.js";
 import { ARTIFACTS_DIRNAME, CHAT_JSON_FILENAME, CHAT_JSONL_FILENAME, } from "../structure.js";
 import { findProviderTranscripts } from "./sources.js";
+export async function snapshotProviderTranscripts(options) {
+    const transcriptPaths = await findProviderTranscripts(options.providerId, {
+        agentRoot: options.agentRoot,
+        env: options.searchEnv,
+    });
+    return await collectTranscriptSnapshot(transcriptPaths);
+}
 export async function preserveProviderChatTranscripts(options) {
     const { providerId, agentRoot } = options;
     if (!providerId) {
         return { status: "not-found" };
     }
-    const existing = await locateExistingChatArtifact(agentRoot);
-    if (existing !== undefined) {
-        const { path, format } = existing;
+    let transcriptPaths;
+    try {
+        transcriptPaths = await findProviderTranscripts(providerId, {
+            agentRoot,
+            env: options.searchEnv,
+        });
+    }
+    catch (error) {
         return {
-            status: "already-exists",
-            artifactPath: path,
-            format,
+            status: "error",
+            error: error instanceof Error ? error : new Error(String(error)),
         };
     }
-    let transcriptPaths;
+    let candidatePaths;
     try {
-        transcriptPaths = await findProviderTranscripts(providerId, agentRoot);
+        candidatePaths = await filterTranscriptPathsAgainstBaseline(transcriptPaths, options.baseline);
     }
     catch (error) {
         return {
@@ -30,8 +41,16 @@ export async function preserveProviderChatTranscripts(options) {
             error: error instanceof Error ? error : new Error(String(error)),
         };
     }
-    const selection = selectTranscriptFiles(transcriptPaths);
+    const existing = await locateExistingChatArtifact(agentRoot);
+    const selection = selectTranscriptFiles(candidatePaths);
     if (!selection) {
+        if (existing !== undefined) {
+            return {
+                status: "already-exists",
+                artifactPath: existing.path,
+                format: existing.format,
+            };
+        }
         return { status: "not-found" };
     }
     const { format: selectionFormat, files } = selection;
@@ -50,7 +69,7 @@ export async function preserveProviderChatTranscripts(options) {
             await concatenateJsonlTranscripts(files, artifactPath);
         }
         return {
-            status: "captured",
+            status: existing ? "already-exists" : "captured",
             artifactPath,
             format: selectionFormat,
             sourceCount: files.length,
@@ -104,7 +123,7 @@ async function bundleJsonTranscripts(options) {
     for (const file of files) {
         const raw = await readFile(file, "utf8");
         transcripts.push({
-            source: relative(agentRoot, file),
+            source: toArtifactSourcePath(agentRoot, file),
             payload: parseJsonOrString(raw),
         });
     }
@@ -155,3 +174,54 @@ function parseJsonOrString(content) {
         return content;
     }
 }
+async function collectTranscriptSnapshot(transcriptPaths) {
+    const snapshots = [];
+    for (const path of transcriptPaths) {
+        try {
+            const details = await stat(path);
+            if (!details.isFile()) {
+                continue;
+            }
+            snapshots.push({
+                path,
+                size: details.size,
+                mtimeMs: details.mtimeMs,
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    snapshots.sort((left, right) => left.path.localeCompare(right.path));
+    return snapshots;
+}
+async function filterTranscriptPathsAgainstBaseline(transcriptPaths, baseline) {
+    if (!baseline || baseline.length === 0) {
+        return transcriptPaths;
+    }
+    const baselineByPath = new Map(baseline.map((entry) => [entry.path, entry]));
+    const freshPaths = [];
+    for (const path of transcriptPaths) {
+        const prior = baselineByPath.get(path);
+        if (!prior) {
+            freshPaths.push(path);
+            continue;
+        }
+        try {
+            const current = await stat(path);
+            if (!current.isFile() ||
+                current.size !== prior.size ||
+                current.mtimeMs !== prior.mtimeMs) {
+                freshPaths.push(path);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return freshPaths.sort();
+}
+function toArtifactSourcePath(agentRoot, file) {
+    const source = relative(agentRoot, file);
+    return source.startsWith("..") ? file : source;
+}