agentplane 0.3.6 → 0.3.8

package/dist/runner/result-manifest-policy.d.ts

@@ -0,0 +1,9 @@
+import type { RunnerResultManifest } from "./types.js";
+export declare function normalizeRecipeArtifactPrefixes(raw: string[] | undefined): string[];
+export declare function readRecipeArtifactPrefixesFromRunnerEnv(env: Record<string, string> | undefined): string[] | undefined;
+export declare function assertRunnerManifestArtifactPolicy(opts: {
+    adapter_id: string;
+    allowed_prefixes: string[] | undefined;
+    manifest: RunnerResultManifest | null;
+}): void;
+//# sourceMappingURL=result-manifest-policy.d.ts.map

package/dist/runner/result-manifest-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-manifest-policy.d.ts","sourceRoot":"","sources":["../../src/runner/result-manifest-policy.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAiBvD,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,CAuBnF;AAUD,wBAAgB,uCAAuC,CACrD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GACtC,MAAM,EAAE,GAAG,SAAS,CAatB;AAED,wBAAgB,kCAAkC,CAAC,IAAI,EAAE;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACvC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACvC,GAAG,IAAI,CAmCP"}

package/dist/runner/result-manifest-policy.js

@@ -0,0 +1,96 @@
+import path from "node:path";
+import { exitCodeForError } from "../cli/exit-codes.js";
+import { CliError } from "../shared/errors.js";
+function normalizeRelativePolicyPath(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return null;
+    const slashed = trimmed.replaceAll("\\", "/");
+    if (slashed.startsWith("/"))
+        return null;
+    if (/^[A-Za-z]:\//u.test(slashed))
+        return null;
+    const normalized = path.posix.normalize(slashed);
+    if (!normalized || normalized === "." || normalized === "..")
+        return null;
+    if (normalized.startsWith("../"))
+        return null;
+    return normalized.replace(/\/+$/u, "");
+}
+export function normalizeRecipeArtifactPrefixes(raw) {
+    const invalidPrefixes = [];
+    const normalizedPrefixes = (raw ?? [])
+        .map((entry) => {
+        const normalized = normalizeRelativePolicyPath(entry);
+        if (!normalized)
+            invalidPrefixes.push(entry);
+        return normalized;
+    })
+        .filter(Boolean);
+    if (invalidPrefixes.length > 0) {
+        throw new CliError({
+            exitCode: exitCodeForError("E_RUNTIME"),
+            code: "E_RUNTIME",
+            message: `Recipe writes_artifacts_to contains invalid relative prefixes: ${invalidPrefixes.join(", ")}.`,
+            context: {
+                policy_field: "writes_artifacts_to",
+                invalid_declared_prefixes: invalidPrefixes,
+            },
+        });
+    }
+    return normalizedPrefixes;
+}
+function isAllowedPath(pathValue, allowedPrefixes) {
+    const normalizedPath = normalizeRelativePolicyPath(pathValue);
+    if (!normalizedPath)
+        return false;
+    return allowedPrefixes.some((prefix) => normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`));
+}
+export function readRecipeArtifactPrefixesFromRunnerEnv(env) {
+    const raw = env?.AGENTPLANE_RECIPE_WRITES_ARTIFACTS_TO;
+    if (!raw)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(parsed))
+        return undefined;
+    return normalizeRecipeArtifactPrefixes(parsed.filter((entry) => typeof entry === "string"));
+}
+export function assertRunnerManifestArtifactPolicy(opts) {
+    if (!opts.manifest)
+        return;
+    const allowedPrefixes = normalizeRecipeArtifactPrefixes(opts.allowed_prefixes);
+    if (allowedPrefixes.length === 0)
+        return;
+    const invalidArtifactPaths = (opts.manifest.artifacts ?? [])
+        .map((artifact) => artifact.path)
+        .filter((pathValue) => !isAllowedPath(pathValue, allowedPrefixes));
+    const invalidEvidencePaths = (opts.manifest.evidence?.evidence_paths ?? []).filter((pathValue) => !isAllowedPath(pathValue, allowedPrefixes));
+    if (invalidArtifactPaths.length === 0 && invalidEvidencePaths.length === 0)
+        return;
+    const details = [];
+    if (invalidArtifactPaths.length > 0) {
+        details.push(`artifacts=${invalidArtifactPaths.join(", ")}`);
+    }
+    if (invalidEvidencePaths.length > 0) {
+        details.push(`evidence_paths=${invalidEvidencePaths.join(", ")}`);
+    }
+    throw new CliError({
+        exitCode: exitCodeForError("E_RUNTIME"),
+        code: "E_RUNTIME",
+        message: `Runner result manifest reported paths outside recipe writes_artifacts_to prefixes ` +
+            `(${allowedPrefixes.join(", ")}): ${details.join("; ")}.`,
+        context: {
+            adapter_id: opts.adapter_id,
+            policy_field: "writes_artifacts_to",
+            declared_value: allowedPrefixes,
+            invalid_artifact_paths: invalidArtifactPaths,
+            invalid_evidence_paths: invalidEvidencePaths,
+        },
+    });
+}

package/dist/runner/result-manifest.d.ts

@@ -0,0 +1,30 @@
+import type { RunnerResult, RunnerResultManifest } from "./types.js";
+export declare const RUNNER_RESULT_MANIFEST_SCHEMA_VERSION: 1;
+export declare class InvalidRunnerResultManifestError extends Error {
+    readonly result_path: string;
+    readonly reason: string;
+    readonly raw_content: string;
+    constructor(opts: {
+        result_path: string;
+        reason: string;
+        raw_content: string;
+    });
+}
+export declare function readRunnerResultManifest(resultPath: string): Promise<RunnerResultManifest | null>;
+export declare function invalidRunnerResultManifestPath(resultPath: string): string;
+export declare function sourceRunnerResultManifestPath(resultPath: string): string;
+export declare function preserveInvalidRunnerResultManifest(opts: {
+    result_path: string;
+    error: InvalidRunnerResultManifestError;
+}): Promise<string>;
+export declare function preserveRunnerResultManifestSource(resultPath: string): Promise<string | null>;
+export declare function writeRunnerResultManifest(opts: {
+    result_path: string;
+    manifest: RunnerResultManifest;
+}): Promise<void>;
+export declare function applyRunnerResultManifest(opts: {
+    base: RunnerResult;
+    manifest: RunnerResultManifest | null;
+}): RunnerResult;
+export declare function manifestFromRunnerResult(result: RunnerResult): RunnerResultManifest;
+//# sourceMappingURL=result-manifest.d.ts.map

package/dist/runner/result-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-manifest.d.ts","sourceRoot":"","sources":["../../src/runner/result-manifest.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,YAAY,EAEZ,oBAAoB,EAGrB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,qCAAqC,EAAG,CAAU,CAAC;AAIhE,qBAAa,gCAAiC,SAAQ,KAAK;IACzD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAEjB,IAAI,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE;CAO/E;AAsJD,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAkGtC;AAED,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAI1E;AAED,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAIzE;AAED,wBAAsB,mCAAmC,CAAC,IAAI,EAAE;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,gCAAgC,CAAC;CACzC,GAAG,OAAO,CAAC,MAAM,CAAC,CAKlB;AAED,wBAAsB,kCAAkC,CACtD,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAYxB;AAED,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,oBAAoB,CAAC;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhB;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACvC,GAAG,YAAY,CA4Bf;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,YAAY,GAAG,oBAAoB,CAoBnF"}

package/dist/runner/result-manifest.js

@@ -0,0 +1,322 @@
+import { mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { atomicWriteFile } from "@agentplaneorg/core";
+export const RUNNER_RESULT_MANIFEST_SCHEMA_VERSION = 1;
+const INVALID_RESULT_MANIFEST_SUFFIX = ".invalid.json";
+const SOURCE_RESULT_MANIFEST_SUFFIX = ".source.json";
+export class InvalidRunnerResultManifestError extends Error {
+    result_path;
+    reason;
+    raw_content;
+    constructor(opts) {
+        super(`Invalid runner result manifest at ${opts.result_path}: ${opts.reason}`);
+        this.name = "InvalidRunnerResultManifestError";
+        this.result_path = opts.result_path;
+        this.reason = opts.reason;
+        this.raw_content = opts.raw_content;
+    }
+}
+function invalidManifest(resultPath, reason, rawContent) {
+    throw new InvalidRunnerResultManifestError({
+        result_path: resultPath,
+        reason,
+        raw_content: rawContent,
+    });
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+const MACHINE_IDENTIFIER_RE = /^[a-z0-9]+(?:[._:-][a-z0-9]+)*$/;
+const MACHINE_IDENTIFIER_MAX_LENGTH = 64;
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const entries = value.map((entry) => {
+        if (typeof entry !== "string") {
+            throw new Error("entries must be strings");
+        }
+        const normalized = entry.trim();
+        if (!normalized) {
+            throw new Error("entries must be non-empty strings");
+        }
+        return normalized;
+    });
+    return entries.length > 0 ? entries : undefined;
+}
+function normalizeMachineIdentifier(value, field) {
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be a non-empty string`);
+    }
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error(`${field} must be a non-empty string`);
+    }
+    if (normalized.length > MACHINE_IDENTIFIER_MAX_LENGTH) {
+        throw new Error(`${field} must be at most ${String(MACHINE_IDENTIFIER_MAX_LENGTH)} characters`);
+    }
+    if (!MACHINE_IDENTIFIER_RE.test(normalized)) {
+        throw new Error(`${field} must match ${String(MACHINE_IDENTIFIER_RE)} and contain only lower-case machine-safe identifier tokens`);
+    }
+    return normalized;
+}
+function normalizeMachineIdentifierArray(value, field) {
+    if (!Array.isArray(value))
+        return undefined;
+    const entries = value.map((entry, index) => normalizeMachineIdentifier(entry, `${field}[${String(index)}]`));
+    return entries.length > 0 ? entries : undefined;
+}
+function normalizeArtifacts(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const artifacts = value.map((entry) => {
+        if (!isRecord(entry)) {
+            throw new Error("artifacts entries must be objects");
+        }
+        const pathValue = typeof entry.path === "string" ? entry.path.trim() : "";
+        if (!pathValue) {
+            throw new Error("artifacts[].path must be a non-empty string");
+        }
+        if (entry.label === undefined)
+            return { path: pathValue };
+        return {
+            path: pathValue,
+            label: normalizeMachineIdentifier(entry.label, "artifacts[].label"),
+        };
+    });
+    return artifacts.length > 0 ? artifacts : undefined;
+}
+function normalizeMetrics(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    const metrics = {};
+    if (candidate.duration_ms !== undefined) {
+        const duration = candidate.duration_ms;
+        if (typeof duration !== "number" || !Number.isInteger(duration) || duration < 0) {
+            throw new Error("metrics.duration_ms must be a non-negative integer");
+        }
+        metrics.duration_ms = duration;
+    }
+    if (candidate.stdout_bytes !== undefined) {
+        const stdoutBytes = candidate.stdout_bytes;
+        if (typeof stdoutBytes !== "number" || !Number.isInteger(stdoutBytes) || stdoutBytes < 0) {
+            throw new Error("metrics.stdout_bytes must be a non-negative integer");
+        }
+        metrics.stdout_bytes = stdoutBytes;
+    }
+    if (candidate.stderr_bytes !== undefined) {
+        const stderrBytes = candidate.stderr_bytes;
+        if (typeof stderrBytes !== "number" || !Number.isInteger(stderrBytes) || stderrBytes < 0) {
+            throw new Error("metrics.stderr_bytes must be a non-negative integer");
+        }
+        metrics.stderr_bytes = stderrBytes;
+    }
+    if (candidate.output_last_message_bytes !== undefined) {
+        const outputLastMessageBytes = candidate.output_last_message_bytes;
+        if (outputLastMessageBytes !== null &&
+            (typeof outputLastMessageBytes !== "number" ||
+                !Number.isInteger(outputLastMessageBytes) ||
+                outputLastMessageBytes < 0)) {
+            throw new Error("metrics.output_last_message_bytes must be null or a non-negative integer");
+        }
+        metrics.output_last_message_bytes = outputLastMessageBytes;
+    }
+    return Object.keys(metrics).length > 0 ? metrics : undefined;
+}
+function normalizeEvidence(value) {
+    if (!isRecord(value))
+        return undefined;
+    const evidence = {};
+    const evidencePaths = normalizeStringArray(value.evidence_paths);
+    if (evidencePaths)
+        evidence.evidence_paths = evidencePaths;
+    const changedPaths = normalizeStringArray(value.changed_paths);
+    if (changedPaths)
+        evidence.changed_paths = changedPaths;
+    const testsRun = normalizeStringArray(value.tests_run);
+    if (testsRun)
+        evidence.tests_run = testsRun;
+    const verificationCandidates = normalizeStringArray(value.verification_candidates);
+    if (verificationCandidates)
+        evidence.verification_candidates = verificationCandidates;
+    if (value.files_changed_count !== undefined) {
+        if (typeof value.files_changed_count !== "number" ||
+            !Number.isInteger(value.files_changed_count) ||
+            value.files_changed_count < 0) {
+            throw new Error("evidence.files_changed_count must be a non-negative integer");
+        }
+        evidence.files_changed_count = value.files_changed_count;
+    }
+    return Object.keys(evidence).length > 0 ? evidence : undefined;
+}
+function normalizeStatus(value) {
+    return value === "success" || value === "failed" || value === "cancelled" ? value : undefined;
+}
+function normalizeTimeoutReason(value) {
+    return value === "idle" || value === "wall_clock" ? value : undefined;
+}
+export async function readRunnerResultManifest(resultPath) {
+    try {
+        const rawText = await readFile(resultPath, "utf8");
+        let parsed;
+        try {
+            parsed = JSON.parse(rawText);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            invalidManifest(resultPath, `result.json must contain valid JSON (${message})`, rawText);
+        }
+        if (!isRecord(parsed)) {
+            invalidManifest(resultPath, "result.json must contain a JSON object", rawText);
+        }
+        const raw = parsed;
+        if (raw.schema_version !== RUNNER_RESULT_MANIFEST_SCHEMA_VERSION) {
+            invalidManifest(resultPath, `schema_version must be ${RUNNER_RESULT_MANIFEST_SCHEMA_VERSION}`, rawText);
+        }
+        const manifest = {
+            schema_version: RUNNER_RESULT_MANIFEST_SCHEMA_VERSION,
+        };
+        if (raw.status !== undefined) {
+            const status = normalizeStatus(raw.status);
+            if (!status) {
+                invalidManifest(resultPath, "status must be success, failed, or cancelled", rawText);
+            }
+            manifest.status = status;
+        }
+        if (raw.exit_code !== undefined) {
+            const exitCode = raw.exit_code;
+            if (exitCode !== null &&
+                (typeof exitCode !== "number" || !Number.isInteger(exitCode) || exitCode < 0)) {
+                invalidManifest(resultPath, "exit_code must be null or a non-negative integer", rawText);
+            }
+            manifest.exit_code = exitCode;
+        }
+        if (raw.summary !== undefined) {
+            if (typeof raw.summary !== "string" || !raw.summary.trim()) {
+                invalidManifest(resultPath, "summary must be a non-empty string when present", rawText);
+            }
+            manifest.summary = raw.summary.trim();
+        }
+        if (raw.stdout_summary !== undefined) {
+            if (typeof raw.stdout_summary !== "string" || !raw.stdout_summary.trim()) {
+                invalidManifest(resultPath, "stdout_summary must be a non-empty string when present", rawText);
+            }
+            manifest.stdout_summary = raw.stdout_summary.trim();
+        }
+        if (raw.stderr_summary !== undefined) {
+            if (typeof raw.stderr_summary !== "string" || !raw.stderr_summary.trim()) {
+                invalidManifest(resultPath, "stderr_summary must be a non-empty string when present", rawText);
+            }
+            manifest.stderr_summary = raw.stderr_summary.trim();
+        }
+        if (raw.timeout_reason !== undefined) {
+            const timeoutReason = normalizeTimeoutReason(raw.timeout_reason);
+            if (!timeoutReason) {
+                invalidManifest(resultPath, "timeout_reason must be idle or wall_clock when present", rawText);
+            }
+            manifest.timeout_reason = timeoutReason;
+        }
+        try {
+            manifest.artifacts = normalizeArtifacts(raw.artifacts);
+            manifest.findings = normalizeStringArray(raw.findings);
+            manifest.verification_hints = normalizeStringArray(raw.verification_hints);
+            manifest.capabilities_used = normalizeMachineIdentifierArray(raw.capabilities_used, "capabilities_used");
+            manifest.metrics = normalizeMetrics(raw.metrics);
+            manifest.evidence = normalizeEvidence(raw.evidence);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            invalidManifest(resultPath, message, rawText);
+        }
+        return manifest;
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+export function invalidRunnerResultManifestPath(resultPath) {
+    const dir = path.dirname(resultPath);
+    const base = path.basename(resultPath, ".json");
+    return path.join(dir, `${base}${INVALID_RESULT_MANIFEST_SUFFIX}`);
+}
+export function sourceRunnerResultManifestPath(resultPath) {
+    const dir = path.dirname(resultPath);
+    const base = path.basename(resultPath, ".json");
+    return path.join(dir, `${base}${SOURCE_RESULT_MANIFEST_SUFFIX}`);
+}
+export async function preserveInvalidRunnerResultManifest(opts) {
+    const invalidPath = invalidRunnerResultManifestPath(opts.result_path);
+    await mkdir(path.dirname(invalidPath), { recursive: true });
+    await atomicWriteFile(invalidPath, opts.error.raw_content, "utf8");
+    return invalidPath;
+}
+export async function preserveRunnerResultManifestSource(resultPath) {
+    try {
+        const rawContent = await readFile(resultPath, "utf8");
+        const sourcePath = sourceRunnerResultManifestPath(resultPath);
+        await mkdir(path.dirname(sourcePath), { recursive: true });
+        await atomicWriteFile(sourcePath, rawContent, "utf8");
+        return sourcePath;
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+export async function writeRunnerResultManifest(opts) {
+    await mkdir(path.dirname(opts.result_path), { recursive: true });
+    await atomicWriteFile(opts.result_path, `${JSON.stringify(opts.manifest, null, 2)}\n`, "utf8");
+}
+export function applyRunnerResultManifest(opts) {
+    if (!opts.manifest)
+        return opts.base;
+    const merged = {
+        ...opts.base,
+        status: opts.base.status === "cancelled" ? "cancelled" : (opts.manifest.status ?? opts.base.status),
+        exit_code: opts.base.status === "cancelled"
+            ? opts.base.exit_code
+            : (opts.manifest.exit_code ?? opts.base.exit_code),
+        summary: opts.manifest.summary ?? opts.base.summary,
+        stdout_summary: opts.manifest.stdout_summary ?? opts.base.stdout_summary,
+        stderr_summary: opts.manifest.stderr_summary ?? opts.base.stderr_summary,
+        timeout_reason: opts.manifest.timeout_reason ?? opts.base.timeout_reason,
+        artifacts: opts.manifest.artifacts ?? opts.base.artifacts,
+        findings: opts.manifest.findings ?? opts.base.findings,
+        verification_hints: opts.manifest.verification_hints ?? opts.base.verification_hints,
+        capabilities_used: opts.manifest.capabilities_used ?? opts.base.capabilities_used,
+        metrics: {
+            ...opts.base.metrics,
+            ...opts.manifest.metrics,
+        },
+        evidence: opts.manifest.evidence ?? opts.base.evidence,
+    };
+    if (merged.artifacts && merged.artifacts.length > 0) {
+        merged.output_paths = merged.artifacts.map((artifact) => artifact.path);
+    }
+    return merged;
+}
+export function manifestFromRunnerResult(result) {
+    return {
+        schema_version: RUNNER_RESULT_MANIFEST_SCHEMA_VERSION,
+        status: result.status,
+        exit_code: result.exit_code,
+        summary: result.summary,
+        stdout_summary: result.stdout_summary,
+        stderr_summary: result.stderr_summary,
+        timeout_reason: result.timeout_reason,
+        artifacts: result.artifacts ??
+            result.output_paths?.map((outputPath) => ({
+                path: outputPath,
+            })),
+        findings: result.findings,
+        verification_hints: result.verification_hints,
+        capabilities_used: result.capabilities_used,
+        metrics: result.metrics,
+        evidence: result.evidence,
+    };
+}

package/dist/runner/run-id.d.ts

@@ -0,0 +1,2 @@
+export declare function createRunnerRunId(date?: Date): string;
+//# sourceMappingURL=run-id.d.ts.map

package/dist/runner/run-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-id.d.ts","sourceRoot":"","sources":["../../src/runner/run-id.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,IAAI,GAAE,IAAiB,GAAG,MAAM,CAEjE"}

package/dist/runner/run-id.js

@@ -0,0 +1,3 @@
+export function createRunnerRunId(date = new Date()) {
+    return date.toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}

package/dist/runner/run-repository.d.ts

@@ -0,0 +1,51 @@
+import type { RunnerArtifactPaths, RunnerContextBundle, RunnerEvent, RunnerInvocation, RunnerRunRecord, RunnerRunState } from "./types.js";
+export declare function parseRunnerEventsText(text: string): RunnerEvent[];
+export declare function assertRunnerBundleMatchesTask(bundle: RunnerContextBundle, taskId: string, runId: string): void;
+export declare class RunnerRunRepository {
+    readonly paths: RunnerArtifactPaths;
+    constructor(paths: RunnerArtifactPaths);
+    static forTaskRun(opts: {
+        git_root: string;
+        workflow_dir: string;
+        task_id: string;
+        run_id: string;
+    }): RunnerRunRepository;
+    static fromBundle(bundle: RunnerContextBundle): RunnerRunRepository;
+    static fromInvocation(invocation: RunnerInvocation): RunnerRunRepository;
+    writePrepared(opts: {
+        bundle: RunnerContextBundle;
+        bootstrap_markdown?: string;
+        created_at?: string;
+        invocation?: RunnerInvocation;
+    }): Promise<RunnerRunState>;
+    readBundle(): Promise<RunnerContextBundle | null>;
+    readState(): Promise<RunnerRunState | null>;
+    readRecord(): Promise<RunnerRunRecord | null>;
+    readRequiredRecord(opts: {
+        task_id: string;
+        run_id: string;
+    }): Promise<RunnerRunRecord>;
+    writeState(state: RunnerRunState): Promise<void>;
+    appendEvent(event: RunnerEvent): Promise<void>;
+    readEventsTextRequired(opts: {
+        task_id: string;
+        run_id: string;
+    }): Promise<string>;
+    readEventsRequired(opts: {
+        task_id: string;
+        run_id: string;
+    }): Promise<{
+        events_text: string;
+        events: RunnerEvent[];
+    }>;
+    readTraceTextRequired(opts: {
+        task_id: string;
+        run_id: string;
+    }): Promise<string>;
+}
+export declare function resolveLatestRunnerRunId(opts: {
+    git_root: string;
+    workflow_dir: string;
+    task_id: string;
+}): Promise<string>;
+//# sourceMappingURL=run-repository.d.ts.map

package/dist/runner/run-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-repository.d.ts","sourceRoot":"","sources":["../../src/runner/run-repository.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,cAAc,EACf,MAAM,YAAY,CAAC;AAOpB,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAYjE;AAmCD,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,IAAI,CAkBN;AAED,qBAAa,mBAAmB;IAClB,QAAQ,CAAC,KAAK,EAAE,mBAAmB;gBAA1B,KAAK,EAAE,mBAAmB;IAE/C,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE;QACtB,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;KAChB,GAAG,mBAAmB;IAWvB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,mBAAmB,GAAG,mBAAmB;IAInE,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,gBAAgB,GAAG,mBAAmB;IAalE,aAAa,CAAC,IAAI,EAAE;QACxB,MAAM,EAAE,mBAAmB,CAAC;QAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,gBAAgB,CAAC;KAC/B,GAAG,OAAO,CAAC,cAAc,CAAC;IAIrB,UAAU,IAAI,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAIjD,SAAS,IAAI,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAI3C,UAAU,IAAI,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAU7C,kBAAkB,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,eAAe,CAAC;IAavF,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAOhD,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAO9C,sBAAsB,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IASlF,kBAAkB,CAAC,IAAI,EAAE;QAC7B,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;KAChB,GAAG,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,EAAE,CAAA;KAAE,CAAC;IAQrD,qBAAqB,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;CAiBxF;AAED,wBAAsB,wBAAwB,CAAC,IAAI,EAAE;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,MAAM,CAAC,CAoDlB"}