agentweaver 0.1.15 → 0.1.16

package/dist/runtime/artifact-registry.js

@@ -0,0 +1,402 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { buildArtifactId, buildLogicalKeyForPayload, buildPublicationKey, createProducerSummary, diagnosticsForManifest, inferPayloadContract, parseArtifactReference, validateArtifactManifest, } from "../artifact-manifest.js";
+import { artifactIndexFile, artifactManifestSidecarPath, ensureScopeWorkspaceDir, scopeArtifactsDir, scopeWorkspaceDir, } from "../artifacts.js";
+import { TaskRunnerError } from "../errors.js";
+import { isArtifactPayloadSchemaId, validateArtifactPayload, } from "../structured-artifacts.js";
+function nowIso8601() {
+    return new Date().toISOString();
+}
+function historyDir(scopeKey) {
+    return path.join(scopeArtifactsDir(scopeKey), "manifest-history");
+}
+function historyManifestPath(scopeKey, artifactId) {
+    return path.join(historyDir(scopeKey), `${encodeURIComponent(artifactId)}.manifest.json`);
+}
+function scopeKeyFromPayloadPath(payloadPath) {
+    const scopeMarker = `${path.sep}.agentweaver${path.sep}scopes${path.sep}`;
+    const markerIndex = payloadPath.lastIndexOf(scopeMarker);
+    if (markerIndex < 0) {
+        return null;
+    }
+    const scopePart = payloadPath.slice(markerIndex + scopeMarker.length);
+    return scopePart.split(path.sep)[0] || null;
+}
+function writeJsonAtomic(filePath, value) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    renameSync(tempPath, filePath);
+}
+function computeContentHash(payloadPath) {
+    const hash = createHash("sha256");
+    hash.update(readFileSync(payloadPath));
+    return `sha256:${hash.digest("hex")}`;
+}
+function toIndexRecord(manifest) {
+    const producerSummary = manifest.producer.summary ?? createProducerSummary(manifest.producer);
+    return {
+        artifact_id: manifest.artifact_id,
+        logical_key: manifest.logical_key,
+        payload_path: manifest.payload_path,
+        manifest_path: manifest.manifest_path,
+        version: manifest.version,
+        status: manifest.status,
+        schema_id: manifest.schema_id,
+        schema_version: manifest.schema_version,
+        created_at: manifest.created_at,
+        content_hash: manifest.content_hash,
+        producer_summary: producerSummary,
+        ...(manifest.supersedes ? { supersedes: manifest.supersedes } : {}),
+        is_latest: manifest.status === "ready",
+    };
+}
+function tryLoadManifest(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        validateArtifactManifest(parsed, filePath);
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function collectManifestFiles(rootDir) {
+    if (!existsSync(rootDir)) {
+        return [];
+    }
+    const queue = [rootDir];
+    const files = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        const entries = readdirSync(current, { withFileTypes: true })
+            .sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+                continue;
+            }
+            if (entry.isFile() && fullPath.endsWith(".manifest.json")) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files;
+}
+function collectScopeManifests(scopeKey) {
+    const allPaths = [
+        ...collectManifestFiles(scopeWorkspaceDir(scopeKey)),
+        ...collectManifestFiles(historyDir(scopeKey)),
+    ];
+    const manifests = new Map();
+    for (const filePath of allPaths) {
+        const manifest = tryLoadManifest(filePath);
+        if (!manifest) {
+            continue;
+        }
+        manifests.set(manifest.artifact_id, manifest);
+    }
+    return Array.from(manifests.values()).sort((left, right) => {
+        if (left.logical_key !== right.logical_key) {
+            return left.logical_key.localeCompare(right.logical_key);
+        }
+        return left.version - right.version;
+    });
+}
+function writeManifestSidecar(manifest) {
+    writeJsonAtomic(manifest.manifest_path, manifest);
+}
+function writeManifestHistory(scopeKey, manifest) {
+    writeJsonAtomic(historyManifestPath(scopeKey, manifest.artifact_id), manifest);
+}
+function isRegistryTempFile(scopeKey, filePath) {
+    const relativePath = path.relative(scopeWorkspaceDir(scopeKey), filePath);
+    if (relativePath.startsWith("..")) {
+        return false;
+    }
+    if (/\.manifest\.json\.tmp-[^/\\]+$/.test(relativePath)) {
+        return true;
+    }
+    return relativePath.startsWith(`${path.join(".artifacts", path.basename(artifactIndexFile(scopeKey)))}.tmp-`);
+}
+function removeStaleTempFiles(scopeKey) {
+    const workspaceDir = scopeWorkspaceDir(scopeKey);
+    if (!existsSync(workspaceDir)) {
+        return;
+    }
+    const queue = [workspaceDir];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        const entries = readdirSync(current, { withFileTypes: true })
+            .sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+                continue;
+            }
+            if (entry.isFile() && isRegistryTempFile(scopeKey, fullPath)) {
+                rmSync(fullPath, { force: true });
+            }
+        }
+    }
+}
+function indexRecordEquals(left, right) {
+    return left.artifact_id === right.artifact_id
+        && left.logical_key === right.logical_key
+        && left.payload_path === right.payload_path
+        && left.manifest_path === right.manifest_path
+        && left.version === right.version
+        && left.status === right.status
+        && left.schema_id === right.schema_id
+        && left.schema_version === right.schema_version
+        && left.created_at === right.created_at
+        && left.content_hash === right.content_hash
+        && left.producer_summary === right.producer_summary
+        && left.supersedes === right.supersedes
+        && left.is_latest === right.is_latest;
+}
+function selectLatestReadyManifest(manifests) {
+    return manifests
+        .filter((manifest) => manifest.status === "ready")
+        .sort((left, right) => right.version - left.version)[0] ?? null;
+}
+function selectNewestManifest(manifests) {
+    return manifests
+        .slice()
+        .sort((left, right) => right.version - left.version)[0] ?? null;
+}
+function buildScopeRecords(scopeKey, computeDiagnostics) {
+    const manifests = collectScopeManifests(scopeKey).map((manifest) => ({
+        ...manifest,
+        diagnostics: computeDiagnostics(manifest),
+    }));
+    const latestByLogicalKey = new Map();
+    for (const manifest of manifests) {
+        if (manifest.status === "ready") {
+            latestByLogicalKey.set(manifest.logical_key, manifest.artifact_id);
+        }
+    }
+    return manifests.map((manifest) => ({
+        ...toIndexRecord(manifest),
+        is_latest: latestByLogicalKey.get(manifest.logical_key) === manifest.artifact_id,
+        manifest,
+    }));
+}
+function readIndexProjection(scopeKey) {
+    const indexPath = artifactIndexFile(scopeKey);
+    if (!existsSync(indexPath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(indexPath, "utf8"));
+        return Array.isArray(parsed.records) ? parsed.records : null;
+    }
+    catch {
+        return null;
+    }
+}
+function syncIndexProjection(scopeKey, records) {
+    const projected = records.map(({ manifest: _manifest, ...record }) => record);
+    const current = readIndexProjection(scopeKey);
+    if (!current && projected.length === 0) {
+        return;
+    }
+    const needsRewrite = !current
+        || current.length !== projected.length
+        || current.some((record, index) => !indexRecordEquals(record, projected[index]));
+    if (!needsRewrite) {
+        return;
+    }
+    writeJsonAtomic(artifactIndexFile(scopeKey), {
+        scope: scopeKey,
+        generated_at: nowIso8601(),
+        records: projected,
+    });
+}
+export function createArtifactRegistry() {
+    return {
+        publish(input) {
+            ensureScopeWorkspaceDir(input.scopeKey);
+            removeStaleTempFiles(input.scopeKey);
+            const sidecarPath = artifactManifestSidecarPath(input.payloadPath);
+            const manifests = collectScopeManifests(input.scopeKey);
+            const logicalKey = input.logicalKey ?? buildLogicalKeyForPayload(input.scopeKey, input.payloadPath);
+            const publicationKey = buildPublicationKey({
+                runId: input.runId,
+                ...(input.publicationRunId ? { publicationRunId: input.publicationRunId } : {}),
+                flowId: input.flowId,
+                phaseId: input.phaseId,
+                stepId: input.stepId,
+                logicalKey,
+            });
+            const existing = manifests.find((candidate) => candidate.publication_key === publicationKey);
+            if (existing) {
+                if (existing.payload_path !== input.payloadPath) {
+                    throw new TaskRunnerError(`Manifest publication key collision for ${publicationKey}: ${existing.payload_path} and ${input.payloadPath} resolved to the same logical_key within one step.`);
+                }
+                return {
+                    ...toIndexRecord(existing),
+                    manifest: existing,
+                };
+            }
+            const contract = inferPayloadContract(input.scopeKey, input.payloadPath, {
+                ...(input.payloadFamily ? { payloadFamily: input.payloadFamily } : {}),
+                ...(input.schemaId ? { schemaId: input.schemaId } : {}),
+                ...(input.schemaVersion ? { schemaVersion: input.schemaVersion } : {}),
+            });
+            const versions = manifests
+                .filter((candidate) => candidate.logical_key === logicalKey)
+                .sort((left, right) => left.version - right.version);
+            const previousLatest = [...versions].reverse().find((candidate) => candidate.status === "ready") ?? versions.at(-1) ?? null;
+            const version = (versions.at(-1)?.version ?? 0) + 1;
+            const artifactId = buildArtifactId(input.scopeKey, logicalKey, version);
+            const manifest = {
+                artifact_id: artifactId,
+                logical_key: logicalKey,
+                scope: input.scopeKey,
+                run_id: input.runId,
+                flow_id: input.flowId,
+                phase_id: input.phaseId,
+                step_id: input.stepId,
+                kind: input.kind,
+                version,
+                payload_family: contract.payloadFamily,
+                schema_id: contract.schemaId,
+                schema_version: contract.schemaVersion,
+                created_at: nowIso8601(),
+                producer: {
+                    node: input.nodeKind,
+                    summary: createProducerSummary({
+                        node: input.nodeKind,
+                        ...(input.executor ? { executor: input.executor } : {}),
+                        ...(input.model ? { model: input.model } : {}),
+                    }),
+                    ...(input.executor ? { executor: input.executor } : {}),
+                    ...(input.model ? { model: input.model } : {}),
+                },
+                inputs: input.inputs,
+                content_hash: computeContentHash(input.payloadPath),
+                status: "ready",
+                payload_path: input.payloadPath,
+                manifest_path: sidecarPath,
+                publication_key: publicationKey,
+                ...(previousLatest ? { supersedes: previousLatest.artifact_id } : {}),
+            };
+            validateArtifactManifest(manifest, sidecarPath);
+            writeManifestHistory(input.scopeKey, manifest);
+            writeManifestSidecar(manifest);
+            if (previousLatest) {
+                const superseded = {
+                    ...previousLatest,
+                    status: "superseded",
+                    status_reason: `Superseded by ${artifactId}`,
+                };
+                writeManifestHistory(input.scopeKey, superseded);
+                if (previousLatest.manifest_path !== manifest.manifest_path) {
+                    writeManifestSidecar(superseded);
+                }
+            }
+            this.rebuildIndex(input.scopeKey);
+            return {
+                ...toIndexRecord(manifest),
+                manifest,
+            };
+        },
+        resolveArtifact(scopeKey, reference) {
+            removeStaleTempFiles(scopeKey);
+            const parsedReference = parseArtifactReference(reference);
+            if (!parsedReference) {
+                throw new TaskRunnerError(`Artifact reference '${reference}' is invalid. Expected an artifact_id or a logical reference in the form <logical_key>@latest or <logical_key>@vN.`);
+            }
+            const records = buildScopeRecords(scopeKey, this.computeDiagnostics);
+            syncIndexProjection(scopeKey, records);
+            const manifests = records.map((record) => record.manifest);
+            if (parsedReference.kind === "artifact-id") {
+                if (parsedReference.parsedId.scopeKey !== scopeKey) {
+                    throw new TaskRunnerError(`Artifact id '${reference}' belongs to scope '${parsedReference.parsedId.scopeKey}', expected '${scopeKey}'.`);
+                }
+                const manifest = manifests.find((candidate) => candidate.artifact_id === parsedReference.artifactId);
+                if (!manifest) {
+                    throw new TaskRunnerError(`Artifact '${reference}' was not found in scope '${scopeKey}'.`);
+                }
+                return manifest;
+            }
+            const candidates = manifests.filter((candidate) => candidate.logical_key === parsedReference.logicalKey);
+            if (parsedReference.version === "latest") {
+                const manifest = selectLatestReadyManifest(candidates);
+                if (!manifest) {
+                    throw new TaskRunnerError(`No ready artifact found for logical reference '${reference}' in scope '${scopeKey}'.`);
+                }
+                return manifest;
+            }
+            const manifest = candidates.find((candidate) => candidate.version === parsedReference.version);
+            if (!manifest) {
+                throw new TaskRunnerError(`Artifact reference '${reference}' was not found in scope '${scopeKey}'.`);
+            }
+            return manifest;
+        },
+        loadManifestByPayloadPath(payloadPath) {
+            const manifest = tryLoadManifest(artifactManifestSidecarPath(payloadPath));
+            const scopeKey = scopeKeyFromPayloadPath(payloadPath);
+            if (!scopeKey) {
+                return manifest;
+            }
+            removeStaleTempFiles(scopeKey);
+            const records = buildScopeRecords(scopeKey, this.computeDiagnostics);
+            syncIndexProjection(scopeKey, records);
+            const candidates = records
+                .map((record) => record.manifest)
+                .filter((candidate) => candidate.payload_path === payloadPath);
+            return selectLatestReadyManifest(candidates) ?? selectNewestManifest(candidates) ?? manifest;
+        },
+        listScopeArtifacts(scopeKey) {
+            removeStaleTempFiles(scopeKey);
+            const records = buildScopeRecords(scopeKey, this.computeDiagnostics);
+            syncIndexProjection(scopeKey, records);
+            return records;
+        },
+        rebuildIndex(scopeKey) {
+            removeStaleTempFiles(scopeKey);
+            const records = buildScopeRecords(scopeKey, this.computeDiagnostics);
+            syncIndexProjection(scopeKey, records);
+            return records;
+        },
+        resolveLineageInputFromPath(scopeKey, payloadPath) {
+            const manifest = this.loadManifestByPayloadPath(payloadPath);
+            if (!manifest) {
+                return {
+                    source: "external-path",
+                    path: payloadPath,
+                };
+            }
+            return {
+                source: "manifest",
+                path: payloadPath,
+                artifact_id: manifest.artifact_id,
+                logical_key: manifest.logical_key,
+                schema_id: manifest.schema_id,
+                schema_version: manifest.schema_version,
+            };
+        },
+        computeDiagnostics(manifest) {
+            return diagnosticsForManifest(manifest, (schemaId, payloadPath) => {
+                if (!isArtifactPayloadSchemaId(schemaId)) {
+                    throw new Error(`Structured artifact schema is not registered: ${schemaId}`);
+                }
+                validateArtifactPayload(payloadPath, schemaId);
+            });
+        },
+    };
+}

package/dist/runtime/design-review-input-contract.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
-import { designFile, designJsonFile, jiraAttachmentsContextFile, jiraAttachmentsManifestFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, planningAnswersJsonFile, qaFile, qaJsonFile, requireArtifacts, } from "../artifacts.js";
-import { TaskRunnerError } from "../errors.js";
+import { designFile, designJsonFile, instantTaskInputJsonFile, jiraAttachmentsContextFile, jiraAttachmentsManifestFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, planningAnswersJsonFile, qaFile, qaJsonFile, taskContextJsonFile, requireArtifacts, } from "../artifacts.js";
 import { validateStructuredArtifacts } from "../structured-artifacts.js";
+import { resolveLatestCompletedPlanningIteration } from "./planning-bundle.js";
 const OPTIONAL_INPUT_NOT_PROVIDED = "not provided";
 function requiredPlanningArtifactPaths(taskKey, iteration) {
     return {
@@ -11,19 +11,6 @@ function requiredPlanningArtifactPaths(taskKey, iteration) {
         planJsonFile: planJsonFile(taskKey, iteration),
     };
 }
-function resolveLatestCompletedPlanningIteration(taskKey) {
-    const latestKnownIteration = Math.max(latestArtifactIteration(taskKey, "design", "md") ?? 0, latestArtifactIteration(taskKey, "design", "json") ?? 0, latestArtifactIteration(taskKey, "plan", "md") ?? 0, latestArtifactIteration(taskKey, "plan", "json") ?? 0);
-    for (let iteration = latestKnownIteration; iteration >= 1; iteration -= 1) {
-        const requiredPaths = Object.values(requiredPlanningArtifactPaths(taskKey, iteration));
-        if (requiredPaths.every((candidate) => existsSync(candidate))) {
-            return iteration;
-        }
-    }
-    const fallbackIteration = latestKnownIteration || 1;
-    const fallbackPaths = Object.values(requiredPlanningArtifactPaths(taskKey, fallbackIteration));
-    requireArtifacts(fallbackPaths, "Design-review requires design and plan markdown/JSON artifacts from the latest completed planning run.");
-    throw new TaskRunnerError("Unreachable design-review planning artifact resolution state.");
-}
 function resolveOptionalPromptFile(filePath) {
     if (!existsSync(filePath)) {
         return {
@@ -79,7 +66,10 @@ function resolveOptionalQaPair(taskKey, iteration) {
  * deterministic when some context is absent.
  */
 export function resolveDesignReviewInputContract(taskKey) {
-    const planningIteration = resolveLatestCompletedPlanningIteration(taskKey);
+    const planningIteration = resolveLatestCompletedPlanningIteration(taskKey, {
+        requireQa: false,
+        missingMessage: "Design-review requires design and plan markdown/JSON artifacts from the latest completed planning run.",
+    });
     const requiredArtifacts = requiredPlanningArtifactPaths(taskKey, planningIteration);
     requireArtifacts(Object.values(requiredArtifacts), "Design-review requires design and plan markdown/JSON artifacts from the latest completed planning run.");
     validateStructuredArtifacts([
@@ -91,6 +81,11 @@ export function resolveDesignReviewInputContract(taskKey) {
     const jiraAttachmentsManifest = resolveOptionalPromptFile(jiraAttachmentsManifestFile(taskKey));
     const jiraAttachmentsContext = resolveOptionalPromptFile(jiraAttachmentsContextFile(taskKey));
     const planningAnswers = resolveOptionalValidatedStructuredFile(planningAnswersJsonFile(taskKey), "user-input/v1", "Design-review planning answers structured artifact is invalid.");
+    const taskContextIteration = latestArtifactIteration(taskKey, "task-context", "json");
+    const taskContext = taskContextIteration === null
+        ? { present: false, path: null, promptValue: OPTIONAL_INPUT_NOT_PROVIDED }
+        : resolveOptionalValidatedStructuredFile(taskContextJsonFile(taskKey, taskContextIteration), "task-context/v1", "Design-review task-context structured artifact is invalid.");
+    const taskInput = resolveOptionalValidatedStructuredFile(instantTaskInputJsonFile(taskKey), "user-input/v1", "Design-review instant-task input structured artifact is invalid.");
     return {
         planningIteration,
         ...requiredArtifacts,
@@ -107,6 +102,12 @@ export function resolveDesignReviewInputContract(taskKey) {
         hasPlanningAnswersJsonFile: planningAnswers.present,
         planningAnswersJsonFilePath: planningAnswers.path,
         planningAnswersJsonFile: planningAnswers.promptValue,
+        hasTaskContextJsonFile: taskContext.present,
+        taskContextJsonFilePath: taskContext.path,
+        taskContextJsonFile: taskContext.promptValue,
+        hasTaskInputJsonFile: taskInput.present,
+        taskInputJsonFilePath: taskInput.path,
+        taskInputJsonFile: taskInput.promptValue,
     };
 }
 export { OPTIONAL_INPUT_NOT_PROVIDED };

package/dist/runtime/env-loader.js

@@ -35,6 +35,9 @@ function globalConfigDir() {
 function ensureGlobalConfigDir() {
     mkdirSync(globalConfigDir(), { recursive: true });
 }
+export function agentweaverConfigDir() {
+    return globalConfigDir();
+}
 export function loadTieredEnv(projectDir) {
     ensureGlobalConfigDir();
     const shellEnvKeys = new Set(Object.keys(process.env));

package/dist/runtime/execution-routing-store.js

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { TaskRunnerError } from "../errors.js";
+import { resolveStoredExecutionRoutingSnapshot } from "./execution-routing.js";
+import { agentweaverConfigDir } from "./env-loader.js";
+const EXECUTION_ROUTING_STORE_VERSION = 1;
+function storePath() {
+    return path.join(agentweaverConfigDir(), "execution-routing.json");
+}
+function nowIso8601() {
+    return new Date().toISOString();
+}
+function emptyStore() {
+    return {
+        version: EXECUTION_ROUTING_STORE_VERSION,
+        namedPresets: {},
+        flowDefaults: {},
+        lastUsedByFlow: {},
+    };
+}
+function validateSelectedPreset(value, pathLabel) {
+    if (!value || typeof value !== "object") {
+        throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.selectedPreset.`);
+    }
+    const candidate = value;
+    if (typeof candidate.kind !== "string" || typeof candidate.label !== "string") {
+        throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.selectedPreset.`);
+    }
+    if (candidate.kind === "built-in" || candidate.kind === "named") {
+        if (typeof candidate.presetId !== "string" || candidate.presetId.trim().length === 0) {
+            throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.selectedPreset.presetId.`);
+        }
+        return {
+            kind: candidate.kind,
+            presetId: candidate.presetId,
+            label: candidate.label,
+        };
+    }
+    if (candidate.kind === "flow-default" || candidate.kind === "last-used" || candidate.kind === "custom") {
+        return {
+            kind: candidate.kind,
+            label: candidate.label,
+        };
+    }
+    throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.selectedPreset.kind.`);
+}
+function validateRoutingEntry(value, pathLabel) {
+    if (!value || typeof value !== "object") {
+        throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.`);
+    }
+    const candidate = value;
+    if (typeof candidate.updatedAt !== "string") {
+        throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.updatedAt.`);
+    }
+    return {
+        routing: resolveStoredExecutionRoutingSnapshot(candidate.routing),
+        selectedPreset: validateSelectedPreset(candidate.selectedPreset, pathLabel),
+        updatedAt: candidate.updatedAt,
+    };
+}
+function validateEntryMap(value, pathLabel) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new TaskRunnerError(`Invalid execution routing store section '${pathLabel}'.`);
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, validateRoutingEntry(entry, `${pathLabel}.${key}`)]));
+}
+function validateStore(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new TaskRunnerError("Execution routing store must be a JSON object.");
+    }
+    const candidate = raw;
+    if (candidate.version !== EXECUTION_ROUTING_STORE_VERSION) {
+        throw new TaskRunnerError(`Unsupported execution routing store version: ${String(candidate.version ?? "unknown")}.`);
+    }
+    return {
+        version: EXECUTION_ROUTING_STORE_VERSION,
+        namedPresets: validateEntryMap(candidate.namedPresets ?? {}, "namedPresets"),
+        flowDefaults: validateEntryMap(candidate.flowDefaults ?? {}, "flowDefaults"),
+        lastUsedByFlow: validateEntryMap(candidate.lastUsedByFlow ?? {}, "lastUsedByFlow"),
+    };
+}
+export function loadExecutionRoutingStore() {
+    const filePath = storePath();
+    if (!existsSync(filePath)) {
+        return emptyStore();
+    }
+    try {
+        return validateStore(JSON.parse(readFileSync(filePath, "utf8")));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new TaskRunnerError(`Failed to load execution routing store ${filePath}: ${message}. Delete or repair the file and try again.`);
+    }
+}
+export function saveExecutionRoutingStore(store) {
+    const filePath = storePath();
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempFilePath = `${filePath}.tmp`;
+    writeFileSync(`${tempFilePath}`, `${JSON.stringify(store, null, 2)}\n`, "utf8");
+    renameSync(tempFilePath, filePath);
+}
+function withUpdatedAt(entry) {
+    return {
+        ...entry,
+        updatedAt: nowIso8601(),
+    };
+}
+export function saveNamedExecutionPreset(name, routing, selectedPreset) {
+    const store = loadExecutionRoutingStore();
+    store.namedPresets[name] = withUpdatedAt({ routing, selectedPreset });
+    saveExecutionRoutingStore(store);
+}
+export function saveFlowDefaultExecutionRouting(flowKey, routing, selectedPreset) {
+    const store = loadExecutionRoutingStore();
+    store.flowDefaults[flowKey] = withUpdatedAt({ routing, selectedPreset });
+    saveExecutionRoutingStore(store);
+}
+export function saveLastUsedExecutionRouting(flowKey, routing, selectedPreset) {
+    const store = loadExecutionRoutingStore();
+    store.lastUsedByFlow[flowKey] = withUpdatedAt({ routing, selectedPreset });
+    saveExecutionRoutingStore(store);
+}
+export function getNamedExecutionPresets() {
+    return loadExecutionRoutingStore().namedPresets;
+}
+export function getFlowDefaultExecutionRouting(flowKey) {
+    return loadExecutionRoutingStore().flowDefaults[flowKey] ?? null;
+}
+export function getLastUsedExecutionRouting(flowKey) {
+    return loadExecutionRoutingStore().lastUsedByFlow[flowKey] ?? null;
+}
+export function executionRoutingStoreFile() {
+    return storePath();
+}