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

package/dist/competition/command-adapter.d.ts

@@ -0,0 +1,35 @@
+import { type CompetitionExecuteFailureContext, type CompetitionFailurePolicy, type CompetitionPreparationResult } from "./core.js";
+type Awaitable<T> = Promise<T> | T;
+/**
+ * Shared command adapter contract for competition-core orchestration.
+ *
+ * Lifecycle order:
+ * 1. `queueCandidate` (per input candidate)
+ * 2. `prepareCandidates`
+ * 3. `onPreparationFailure` (per preparation failure result)
+ * 4. `onCandidatePrepared` (per prepared candidate)
+ * 5. execution phase (`onCandidateRunning` -> `executeCandidate` -> `onCandidateCompleted`)
+ * 6. `cleanupPreparedCandidate` (once per prepared candidate, including abort/error paths)
+ * 7. `finalizeCompetition` (exactly once, including error paths)
+ */
+export interface CompetitionCommandAdapter<TCandidate, TPrepared, TResult> {
+    readonly failurePolicy?: CompetitionFailurePolicy;
+    readonly queueCandidate?: (candidate: TCandidate, index: number) => Awaitable<void>;
+    readonly prepareCandidates: (candidates: readonly TCandidate[]) => Awaitable<CompetitionPreparationResult<TPrepared, TResult>>;
+    readonly onPreparationFailure?: (result: TResult, index: number) => Awaitable<void>;
+    readonly onCandidatePrepared?: (prepared: TPrepared, index: number) => Awaitable<void>;
+    readonly executeCandidate: (prepared: TPrepared, index: number) => Awaitable<TResult>;
+    readonly onCandidateRunning?: (prepared: TPrepared, index: number) => Awaitable<void>;
+    readonly onCandidateCompleted?: (prepared: TPrepared, result: TResult, index: number) => Awaitable<void>;
+    readonly captureExecutionFailure?: (context: CompetitionExecuteFailureContext<TPrepared>) => Awaitable<TResult | undefined>;
+    readonly cleanupPreparedCandidate?: (prepared: TPrepared, index: number) => Awaitable<void>;
+    readonly finalizeCompetition?: () => Awaitable<void>;
+    readonly sortResults?: (left: TResult, right: TResult) => number;
+}
+export interface ExecuteCompetitionCommandInput<TCandidate, TPrepared, TResult> {
+    readonly candidates: readonly TCandidate[];
+    readonly maxParallel: number;
+    readonly adapter: CompetitionCommandAdapter<TCandidate, TPrepared, TResult>;
+}
+export declare function executeCompetitionWithAdapter<TCandidate, TPrepared, TResult>(input: ExecuteCompetitionCommandInput<TCandidate, TPrepared, TResult>): Promise<TResult[]>;
+export type { CompetitionExecuteFailureContext, CompetitionFailurePolicy, CompetitionPreparationResult, };

package/dist/competition/command-adapter.js

@@ -0,0 +1,20 @@
+import { executeCompetition, } from "./core.js";
+export async function executeCompetitionWithAdapter(input) {
+    const { candidates, maxParallel, adapter } = input;
+    return await executeCompetition({
+        candidates,
+        maxParallel,
+        queueCandidate: adapter.queueCandidate,
+        prepareCandidates: adapter.prepareCandidates,
+        onPreparationFailure: adapter.onPreparationFailure,
+        onPreparedCandidate: adapter.onCandidatePrepared,
+        executePreparedCandidate: adapter.executeCandidate,
+        onCandidateRunning: adapter.onCandidateRunning,
+        onCandidateCompleted: adapter.onCandidateCompleted,
+        captureExecutionFailure: adapter.captureExecutionFailure,
+        cleanupPreparedCandidate: adapter.cleanupPreparedCandidate,
+        finalizeCompetition: adapter.finalizeCompetition,
+        sortResults: adapter.sortResults,
+        failurePolicy: adapter.failurePolicy,
+    });
+}

package/dist/competition/core.d.ts

@@ -0,0 +1,41 @@
+type Awaitable<T> = Promise<T> | T;
+export type CompetitionFailurePolicy = "abort" | "continue";
+export interface CompetitionPreparationResult<TPrepared, TResult> {
+    readonly ready: readonly TPrepared[];
+    readonly failures: readonly TResult[];
+}
+export interface CompetitionExecuteFailureContext<TPrepared> {
+    readonly stage: "execute";
+    readonly prepared: TPrepared;
+    readonly index: number;
+    readonly error: unknown;
+}
+export interface BoundedCompetitionExecutionInput<TPrepared, TResult> {
+    readonly prepared: readonly TPrepared[];
+    readonly maxParallel: number;
+    readonly executePrepared: (prepared: TPrepared, index: number) => Awaitable<TResult>;
+    readonly onPreparedRunning?: (prepared: TPrepared, index: number) => Awaitable<void>;
+    readonly onPreparedCompleted?: (prepared: TPrepared, result: TResult, index: number) => Awaitable<void>;
+    readonly onExecutionFailure?: (context: CompetitionExecuteFailureContext<TPrepared>) => Awaitable<TResult | undefined>;
+    readonly cleanupPrepared?: (prepared: TPrepared, index: number) => Awaitable<void>;
+    readonly failurePolicy?: CompetitionFailurePolicy;
+}
+export interface CompetitionExecutionInput<TCandidate, TPrepared, TResult> {
+    readonly candidates: readonly TCandidate[];
+    readonly maxParallel: number;
+    readonly queueCandidate?: (candidate: TCandidate, index: number) => Awaitable<void>;
+    readonly prepareCandidates: (candidates: readonly TCandidate[]) => Awaitable<CompetitionPreparationResult<TPrepared, TResult>>;
+    readonly onPreparationFailure?: (result: TResult, index: number) => Awaitable<void>;
+    readonly onPreparedCandidate?: (prepared: TPrepared, index: number) => Awaitable<void>;
+    readonly executePreparedCandidate: (prepared: TPrepared, index: number) => Awaitable<TResult>;
+    readonly onCandidateRunning?: (prepared: TPrepared, index: number) => Awaitable<void>;
+    readonly onCandidateCompleted?: (prepared: TPrepared, result: TResult, index: number) => Awaitable<void>;
+    readonly captureExecutionFailure?: (context: CompetitionExecuteFailureContext<TPrepared>) => Awaitable<TResult | undefined>;
+    readonly cleanupPreparedCandidate?: (prepared: TPrepared, index: number) => Awaitable<void>;
+    readonly finalizeCompetition?: () => Awaitable<void>;
+    readonly sortResults?: (left: TResult, right: TResult) => number;
+    readonly failurePolicy?: CompetitionFailurePolicy;
+}
+export declare function runPreparedWithLimit<TPrepared, TResult>(input: BoundedCompetitionExecutionInput<TPrepared, TResult>): Promise<TResult[]>;
+export declare function executeCompetition<TCandidate, TPrepared, TResult>(input: CompetitionExecutionInput<TCandidate, TPrepared, TResult>): Promise<TResult[]>;
+export {};

package/dist/competition/core.js

@@ -0,0 +1,181 @@
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function pushError(state, error) {
+    const normalized = toError(error);
+    if (!state.primary) {
+        state.primary = normalized;
+        return;
+    }
+    state.secondary.push(normalized);
+}
+function throwCollectedErrors(state) {
+    if (state.primary && state.secondary.length > 0) {
+        throw new AggregateError([state.primary, ...state.secondary], state.primary.message);
+    }
+    if (state.primary) {
+        throw state.primary;
+    }
+    throw new Error("Competition execution failed without a captured error");
+}
+export async function runPreparedWithLimit(input) {
+    const { prepared, maxParallel, executePrepared, onPreparedRunning, onPreparedCompleted, onExecutionFailure, cleanupPrepared, failurePolicy = "abort", } = input;
+    if (prepared.length === 0) {
+        return [];
+    }
+    if (maxParallel <= 0) {
+        return [];
+    }
+    const workerCount = Math.max(1, Math.min(maxParallel, prepared.length));
+    const results = new Array(prepared.length);
+    const started = new Set();
+    const cleaned = new Set();
+    const errors = {
+        primary: undefined,
+        secondary: [],
+    };
+    let nextIndex = 0;
+    let shouldStop = false;
+    async function runCleanup(index) {
+        if (cleaned.has(index)) {
+            return;
+        }
+        cleaned.add(index);
+        if (!cleanupPrepared) {
+            return;
+        }
+        await cleanupPrepared(prepared[index], index);
+    }
+    async function worker() {
+        while (true) {
+            if (shouldStop && failurePolicy === "abort") {
+                return;
+            }
+            const current = nextIndex++;
+            if (current >= prepared.length) {
+                return;
+            }
+            started.add(current);
+            const entry = prepared[current];
+            try {
+                if (onPreparedRunning) {
+                    await onPreparedRunning(entry, current);
+                }
+                const result = await executePrepared(entry, current);
+                results[current] = result;
+                if (onPreparedCompleted) {
+                    await onPreparedCompleted(entry, result, current);
+                }
+            }
+            catch (error) {
+                const context = {
+                    stage: "execute",
+                    prepared: entry,
+                    index: current,
+                    error,
+                };
+                let captured;
+                if (onExecutionFailure) {
+                    captured = await onExecutionFailure(context);
+                }
+                if (captured !== undefined) {
+                    results[current] = captured;
+                }
+                else if (failurePolicy === "continue") {
+                    pushError(errors, error);
+                }
+                else {
+                    shouldStop = true;
+                    pushError(errors, error);
+                }
+            }
+            finally {
+                try {
+                    await runCleanup(current);
+                }
+                catch (error) {
+                    pushError(errors, error);
+                    if (failurePolicy === "abort") {
+                        shouldStop = true;
+                    }
+                }
+            }
+        }
+    }
+    const workers = new Array(workerCount);
+    for (let index = 0; index < workerCount; index += 1) {
+        workers[index] = worker();
+    }
+    await Promise.all(workers);
+    for (let index = 0; index < prepared.length; index += 1) {
+        if (!started.has(index) || !cleaned.has(index)) {
+            try {
+                await runCleanup(index);
+            }
+            catch (error) {
+                pushError(errors, error);
+            }
+        }
+    }
+    if (errors.primary) {
+        throwCollectedErrors(errors);
+    }
+    return results.filter((result) => result !== undefined);
+}
+export async function executeCompetition(input) {
+    const { candidates, maxParallel, queueCandidate, prepareCandidates, onPreparationFailure, onPreparedCandidate, executePreparedCandidate, onCandidateRunning, onCandidateCompleted, captureExecutionFailure, cleanupPreparedCandidate, finalizeCompetition, sortResults, failurePolicy = "abort", } = input;
+    const errors = {
+        primary: undefined,
+        secondary: [],
+    };
+    let results = [];
+    try {
+        for (const [index, candidate] of candidates.entries()) {
+            if (queueCandidate) {
+                await queueCandidate(candidate, index);
+            }
+        }
+        const preparation = await prepareCandidates(candidates);
+        for (const [index, failure] of preparation.failures.entries()) {
+            if (onPreparationFailure) {
+                await onPreparationFailure(failure, index);
+            }
+        }
+        for (const [index, preparedCandidate] of preparation.ready.entries()) {
+            if (onPreparedCandidate) {
+                await onPreparedCandidate(preparedCandidate, index);
+            }
+        }
+        const executionResults = await runPreparedWithLimit({
+            prepared: preparation.ready,
+            maxParallel,
+            executePrepared: executePreparedCandidate,
+            onPreparedRunning: onCandidateRunning,
+            onPreparedCompleted: onCandidateCompleted,
+            onExecutionFailure: captureExecutionFailure,
+            cleanupPrepared: cleanupPreparedCandidate,
+            failurePolicy,
+        });
+        results = [...preparation.failures, ...executionResults];
+        if (sortResults) {
+            results = [...results].sort(sortResults);
+        }
+    }
+    catch (error) {
+        pushError(errors, error);
+    }
+    finally {
+        if (finalizeCompetition) {
+            try {
+                await finalizeCompetition();
+            }
+            catch (error) {
+                pushError(errors, error);
+            }
+        }
+    }
+    if (errors.primary) {
+        throwCollectedErrors(errors);
+    }
+    return results;
+}

package/dist/competition/shared/extra-context.d.ts

@@ -0,0 +1,14 @@
+export interface ResolvedExtraContextFile {
+    readonly absolutePath: string;
+    readonly displayPath: string;
+    readonly stagedRelativePath: string;
+}
+export declare function resolveExtraContextFiles(options: {
+    root: string;
+    paths?: readonly string[];
+}): Promise<ResolvedExtraContextFile[]>;
+export declare function stageExtraContextFiles(options: {
+    contextPath: string;
+    files: readonly ResolvedExtraContextFile[];
+}): Promise<void>;
+export declare function appendExtraContextPromptSection(lines: string[], files: readonly ResolvedExtraContextFile[]): void;

package/dist/competition/shared/extra-context.js

@@ -0,0 +1,100 @@
+import { constants as fsConstants } from "node:fs";
+import { access, copyFile, mkdir, stat } from "node:fs/promises";
+import { basename, dirname, extname, join } from "node:path";
+import { isAbsolute } from "node:path";
+import { CliError } from "../../cli/errors.js";
+import { EXTRA_CONTEXT_STAGED_PREFIX, toExtraContextContextSubpath, } from "../../extra-context/contract.js";
+import { isFileSystemError } from "../../utils/fs.js";
+import { assertPathWithinRoot, normalizePathForDisplay, relativeToRoot, resolvePath, } from "../../utils/path.js";
+export async function resolveExtraContextFiles(options) {
+    const { root, paths } = options;
+    if (!paths || paths.length === 0) {
+        return [];
+    }
+    const resolved = [];
+    const allocatedBasenames = new Map();
+    for (const rawPath of paths) {
+        const trimmed = rawPath.trim();
+        if (trimmed.length === 0) {
+            throw new CliError("`--extra-context` paths must not be empty.");
+        }
+        const absolutePath = isAbsolute(trimmed)
+            ? trimmed
+            : resolvePath(root, trimmed);
+        let fileStat;
+        try {
+            fileStat = await stat(absolutePath);
+        }
+        catch (error) {
+            if (isFileSystemError(error) &&
+                ["EACCES", "EPERM"].includes(error.code)) {
+                throw new CliError(`Extra context file \`${trimmed}\` is not accessible.`, [`Resolved path: \`${absolutePath}\`.`], ["Ensure the file exists and is readable by the current user."]);
+            }
+            throw new CliError(`Extra context file \`${trimmed}\` not found.`, [], ["Pass a readable file path to `--extra-context`."]);
+        }
+        if (!fileStat.isFile()) {
+            throw new CliError(`Extra context path \`${trimmed}\` is not a file.`, [], ["Pass a readable file path to `--extra-context`."]);
+        }
+        try {
+            await access(absolutePath, fsConstants.R_OK);
+        }
+        catch (error) {
+            if (isFileSystemError(error) &&
+                ["EACCES", "EPERM"].includes(error.code)) {
+                throw new CliError(`Extra context file \`${trimmed}\` is not readable.`, [`Resolved path: \`${absolutePath}\`.`], ["Fix file permissions and re-run with `--extra-context`."]);
+            }
+            throw error;
+        }
+        const displayPath = resolveExtraContextDisplayPath(root, absolutePath);
+        const originalBasename = basename(absolutePath);
+        const allocatedBasename = allocateContextBasename(originalBasename, allocatedBasenames);
+        resolved.push({
+            absolutePath,
+            displayPath,
+            stagedRelativePath: `${EXTRA_CONTEXT_STAGED_PREFIX}${allocatedBasename}`,
+        });
+    }
+    return resolved;
+}
+export async function stageExtraContextFiles(options) {
+    const { contextPath, files } = options;
+    for (const file of files) {
+        const destination = resolveStagedDestinationPath({
+            contextPath,
+            stagedRelativePath: file.stagedRelativePath,
+        });
+        await mkdir(dirname(destination), { recursive: true });
+        await copyFile(file.absolutePath, destination);
+    }
+}
+export function appendExtraContextPromptSection(lines, files) {
+    if (files.length === 0) {
+        return;
+    }
+    lines.push("", "Extra context files (staged alongside the workspace):", ...files.map((file) => `- \`${file.stagedRelativePath}\` (source: \`${file.displayPath}\`)`), "- Treat these files as supplemental context for this invocation.");
+}
+function allocateContextBasename(originalBasename, allocations) {
+    const nextCount = (allocations.get(originalBasename) ?? 0) + 1;
+    allocations.set(originalBasename, nextCount);
+    if (nextCount === 1) {
+        return originalBasename;
+    }
+    const extension = extname(originalBasename);
+    const stem = extension.length > 0
+        ? originalBasename.slice(0, -extension.length)
+        : originalBasename;
+    return `${stem}-${nextCount}${extension}`;
+}
+function resolveStagedDestinationPath(options) {
+    const { contextPath, stagedRelativePath } = options;
+    return join(contextPath, toExtraContextContextSubpath(stagedRelativePath));
+}
+function resolveExtraContextDisplayPath(root, absolutePath) {
+    try {
+        assertPathWithinRoot(root, absolutePath);
+        return normalizePathForDisplay(relativeToRoot(root, absolutePath));
+    }
+    catch {
+        return normalizePathForDisplay(absolutePath);
+    }
+}

package/dist/competition/shared/preflight.d.ts

@@ -0,0 +1,11 @@
+export interface PreflightIssue {
+    readonly agentId: string;
+    readonly message: string;
+}
+export interface FormatPreflightIssueLinesOptions {
+    readonly maxChars?: number;
+    readonly unlabeledAgentIds?: readonly string[];
+}
+export declare const PREFLIGHT_SUMMARY_MAX_CHARS: 120;
+export declare const PREFLIGHT_HINT: "Run `voratiq init` to configure the workspace.";
+export declare function formatPreflightIssueLines(issues: readonly PreflightIssue[], options?: FormatPreflightIssueLinesOptions): string[];

package/dist/competition/shared/preflight.js

@@ -0,0 +1,39 @@
+export const PREFLIGHT_SUMMARY_MAX_CHARS = 120;
+export const PREFLIGHT_HINT = "Run `voratiq init` to configure the workspace.";
+export function formatPreflightIssueLines(issues, options = {}) {
+    const { maxChars = PREFLIGHT_SUMMARY_MAX_CHARS, unlabeledAgentIds = [] } = options;
+    const unlabeled = new Set(unlabeledAgentIds);
+    const lines = [];
+    for (const issue of issues) {
+        const messageLines = normalizeIssueMessage(issue.message);
+        for (const message of messageLines) {
+            const full = formatIssueLine(issue.agentId, message, unlabeled);
+            lines.push(truncateLine(full, maxChars));
+        }
+    }
+    return lines;
+}
+function formatIssueLine(agentId, message, unlabeledAgentIds) {
+    if (unlabeledAgentIds.has(agentId)) {
+        return `- ${message}`;
+    }
+    return `- ${agentId}: ${message}`;
+}
+function normalizeIssueMessage(message) {
+    const split = message
+        .split(/\r?\n/u)
+        .map((line) => line.replace(/\s+/gu, " ").trim())
+        .filter((line) => line.length > 0);
+    return split.length > 0 ? split : ["unknown error"];
+}
+function truncateLine(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    const suffix = "...";
+    if (maxChars <= suffix.length) {
+        return suffix.slice(0, maxChars);
+    }
+    const sliceLength = maxChars - suffix.length;
+    return `${value.slice(0, sliceLength).trimEnd()}${suffix}`;
+}

package/dist/competition/shared/prompt-helpers.d.ts

@@ -0,0 +1,16 @@
+export interface AppendConstraintsOptions {
+    extra?: string[];
+    readAccess?: string;
+    writeAccess?: string;
+}
+export interface WorkspaceArtifactRequirement {
+    instruction: string;
+    path: string;
+    schema?: {
+        content: string | readonly string[];
+        leadIn: string;
+    };
+}
+export declare function appendConstraints(lines: string[], options?: AppendConstraintsOptions): void;
+export declare function appendOutputRequirements(lines: string[], extra?: string[]): void;
+export declare function buildWorkspaceArtifactRequirements(requirements: readonly WorkspaceArtifactRequirement[], extra?: readonly string[]): string[];

package/dist/competition/shared/prompt-helpers.js

@@ -0,0 +1,27 @@
+export function appendConstraints(lines, options = {}) {
+    const { extra, readAccess, writeAccess } = options;
+    const accessLines = [];
+    if (readAccess) {
+        accessLines.push(`- Read access: \`${readAccess}\`.`);
+    }
+    if (writeAccess) {
+        accessLines.push(`- Write access: \`${writeAccess}\`.`);
+    }
+    lines.push("", "Constraints:", ...accessLines, "- You are sandboxed. If an operation is blocked, skip it and continue.", "- You are running headlessly. Do not pause for user interaction.", ...(extra ?? []));
+}
+export function appendOutputRequirements(lines, extra) {
+    lines.push("", "Output requirements:", ...(extra ?? []), "- Do not write files outside the workspace.");
+}
+export function buildWorkspaceArtifactRequirements(requirements, extra = []) {
+    const lines = requirements.flatMap((requirement) => {
+        const instructionLine = `- ${requirement.instruction} to \`${requirement.path}\` in the workspace root${requirement.schema ? `, ${requirement.schema.leadIn}:` : "."}`;
+        if (!requirement.schema) {
+            return [instructionLine];
+        }
+        const schemaLines = Array.isArray(requirement.schema.content)
+            ? requirement.schema.content
+            : [requirement.schema.content];
+        return [instructionLine, ...schemaLines.map((line) => `  ${line}`)];
+    });
+    return [...lines, ...extra];
+}

package/dist/competition/shared/prune.d.ts

@@ -0,0 +1 @@
+export declare function pruneWorkspace(workspacePath: string): Promise<void>;

package/dist/competition/shared/prune.js

@@ -0,0 +1,4 @@
+import { rm } from "node:fs/promises";
+export async function pruneWorkspace(workspacePath) {
+    await rm(workspacePath, { recursive: true, force: true }).catch(() => { });
+}

package/dist/competition/shared/sandbox-policy.d.ts

@@ -0,0 +1,9 @@
+export interface ComposeStageSandboxPolicyInput {
+    stageWriteProtectedPaths?: readonly string[];
+    stageReadProtectedPaths?: readonly string[];
+}
+export interface StageSandboxPolicy {
+    extraWriteProtectedPaths: string[];
+    extraReadProtectedPaths: string[];
+}
+export declare function composeStageSandboxPolicy(input?: ComposeStageSandboxPolicyInput): StageSandboxPolicy;

package/dist/competition/shared/sandbox-policy.js

@@ -0,0 +1,7 @@
+export function composeStageSandboxPolicy(input = {}) {
+    const { stageWriteProtectedPaths = [], stageReadProtectedPaths = [] } = input;
+    return {
+        extraWriteProtectedPaths: [...stageWriteProtectedPaths],
+        extraReadProtectedPaths: [...stageReadProtectedPaths],
+    };
+}

package/dist/competition/shared/teardown.d.ts

@@ -0,0 +1,36 @@
+export interface TeardownDiagnostic {
+    readonly label: string;
+    readonly error: unknown;
+}
+export type TeardownResource = {
+    readonly kind: "path";
+    readonly path: string;
+    readonly label?: string;
+} | {
+    readonly kind: "worktree";
+    readonly root: string;
+    readonly worktreePath: string;
+    readonly label?: string;
+} | {
+    readonly kind: "action";
+    readonly key: string;
+    readonly label: string;
+    readonly cleanup: () => Promise<void>;
+};
+export interface TeardownController {
+    readonly label: string;
+    addPath(path: string, label?: string): void;
+    addWorktree(options: {
+        root: string;
+        worktreePath: string;
+        label?: string;
+    }): void;
+    addAction(options: {
+        key: string;
+        label: string;
+        cleanup: () => Promise<void>;
+    }): void;
+    listResources(): readonly TeardownResource[];
+}
+export declare function createTeardownController(label: string): TeardownController;
+export declare function runTeardown(controller: TeardownController | undefined): Promise<readonly TeardownDiagnostic[]>;

package/dist/competition/shared/teardown.js

@@ -0,0 +1,101 @@
+import { rm } from "node:fs/promises";
+import { toErrorMessage } from "../../utils/errors.js";
+import { getGitStderr, removeWorktree } from "../../utils/git.js";
+export function createTeardownController(label) {
+    const resources = new Map();
+    return {
+        label,
+        addPath(path, resourceLabel) {
+            resources.set(`path:${path}`, {
+                kind: "path",
+                path,
+                ...(resourceLabel ? { label: resourceLabel } : {}),
+            });
+        },
+        addWorktree(options) {
+            const { root, worktreePath, label: resourceLabel } = options;
+            resources.set(`worktree:${root}:${worktreePath}`, {
+                kind: "worktree",
+                root,
+                worktreePath,
+                ...(resourceLabel ? { label: resourceLabel } : {}),
+            });
+        },
+        addAction(options) {
+            resources.set(`action:${options.key}`, {
+                kind: "action",
+                key: options.key,
+                label: options.label,
+                cleanup: options.cleanup,
+            });
+        },
+        listResources() {
+            return [...resources.values()];
+        },
+    };
+}
+export async function runTeardown(controller) {
+    if (!controller) {
+        return [];
+    }
+    const diagnostics = [];
+    for (const resource of controller.listResources()) {
+        try {
+            await cleanupTeardownResource(resource);
+        }
+        catch (error) {
+            const label = resourceLabel(resource);
+            diagnostics.push({ label, error });
+            console.warn(`[voratiq] Failed to teardown ${controller.label} ${label}: ${toErrorMessage(error)}`);
+        }
+    }
+    return diagnostics;
+}
+async function cleanupTeardownResource(resource) {
+    switch (resource.kind) {
+        case "path":
+            await rm(resource.path, { recursive: true, force: true });
+            return;
+        case "worktree":
+            await cleanupWorktree(resource);
+            return;
+        case "action":
+            await resource.cleanup();
+            return;
+    }
+}
+async function cleanupWorktree(resource) {
+    try {
+        await removeWorktree({
+            root: resource.root,
+            worktreePath: resource.worktreePath,
+        });
+        return;
+    }
+    catch (error) {
+        if (!isIgnorableMissingWorktreeError(error)) {
+            throw error;
+        }
+    }
+    await rm(resource.worktreePath, { recursive: true, force: true });
+}
+function isIgnorableMissingWorktreeError(error) {
+    const stderr = getGitStderr(error)?.toLowerCase() ?? "";
+    return (stderr.includes("is not a working tree") ||
+        stderr.includes("not a working tree") ||
+        stderr.includes("does not exist") ||
+        stderr.includes("no such file or directory"));
+}
+function resourceLabel(resource) {
+    if (resource.label) {
+        return `resource \`${resource.label}\``;
+    }
+    switch (resource.kind) {
+        case "path":
+            return `path \`${resource.path}\``;
+        case "worktree":
+            return `worktree \`${resource.worktreePath}\``;
+        case "action":
+            return `resource \`${resource.label}\``;
+    }
+}