@voybio/ace-swarm 0.1.0

package/dist/runtime-profile.d.ts

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { type ArtifactSource } from "./helpers.js";
+import { type ValidationResult } from "./schemas.js";
+export declare const RUNTIME_PROFILE_REL_PATH = "agent-state/ACE_WORKFLOW.md";
+export declare const RUNTIME_PROFILE_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/ACE_RUNTIME_PROFILE.schema.json";
+export declare const RUNTIME_PROFILE_SCHEMA_NAME = "ace-runtime-profile@1.0.0";
+export declare const DEFAULT_RUNTIME_TOOL_REGISTRY_REL_PATH = "agent-state/runtime-tool-specs.json";
+export declare const DEFAULT_EXECUTOR_MAX_TURNS = 6;
+export declare const DEFAULT_EXECUTOR_TURN_TIMEOUT_MS = 300000;
+export declare const DEFAULT_VERICIFY_BRIDGE_REL_PATH = "agent-state/vericify/ace-bridge.json";
+export declare const DEFAULT_VERICIFY_PROCESS_POST_LOG_REL_PATH = "agent-state/vericify/process-posts.json";
+declare const runtimeProfileSchema: z.ZodObject<{
+    ace_runtime_version: z.ZodLiteral<"1.0.0">;
+    runtime: z.ZodObject<{
+        mode: z.ZodEnum<{
+            interactive: "interactive";
+            unattended: "unattended";
+        }>;
+        profile_name: z.ZodString;
+    }, z.core.$strict>;
+    workspace: z.ZodObject<{
+        root: z.ZodString;
+        retention: z.ZodEnum<{
+            delete: "delete";
+            archive: "archive";
+        }>;
+        hooks: z.ZodObject<{
+            after_create: z.ZodNullable<z.ZodString>;
+            before_run: z.ZodNullable<z.ZodString>;
+            after_run: z.ZodNullable<z.ZodString>;
+            before_remove: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    executor: z.ZodObject<{
+        command: z.ZodNullable<z.ZodString>;
+        approval_policy: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>]>;
+        thread_sandbox: z.ZodString;
+        turn_sandbox_policy: z.ZodNullable<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        max_turns: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        turn_timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strict>;
+    tools: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        registry_path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strict>>>;
+    autonomy: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        orchestrator_preflight: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        recall_context: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        state_sources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        before_run_checks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        stop_checks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        review_mode: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    }, z.core.$strict>>>;
+    continuity: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        source_paths: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        max_sources: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_excerpt_chars: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_total_chars: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_status_events: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_run_ledger_entries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        include_snapshot: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strict>>>;
+    tracker: z.ZodObject<{
+        kind: z.ZodEnum<{
+            memory: "memory";
+            none: "none";
+            external: "external";
+        }>;
+        config: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+    }, z.core.$strict>;
+    observability: z.ZodObject<{
+        http_enabled: z.ZodBoolean;
+        http_port: z.ZodNullable<z.ZodNumber>;
+        vericify_bridge: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            bridge_path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            process_post_path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RuntimeProfile = z.infer<typeof runtimeProfileSchema>;
+export interface RuntimeProfileSignature {
+    mtime_ms: number;
+    size: number;
+    content_sha256: string;
+}
+export interface RuntimeProfileSnapshot {
+    path: string;
+    source: ArtifactSource;
+    profile: RuntimeProfile;
+    prompt_template: string;
+    signature: RuntimeProfileSignature;
+}
+export type RuntimeProfileResult = (RuntimeProfileSnapshot & {
+    ok: true;
+    schema: typeof RUNTIME_PROFILE_SCHEMA_NAME;
+    cache_hit: boolean;
+}) | {
+    ok: false;
+    schema: typeof RUNTIME_PROFILE_SCHEMA_NAME;
+    path: string;
+    source: ArtifactSource;
+    errors: string[];
+    cache_hit: boolean;
+    signature?: RuntimeProfileSignature;
+};
+export declare function validateRuntimeProfileContent(raw: string): ValidationResult;
+export declare function loadRuntimeProfile(explicitPath?: string): RuntimeProfileResult;
+export declare function readRuntimeProfile(): RuntimeProfile;
+export declare function readRuntimePromptTemplate(): string;
+export declare function readRuntimeProfileState(): RuntimeProfileSnapshot;
+export declare function renderRuntimePrompt(templateContext: Record<string, unknown>): string;
+export declare function getRuntimeProfilePath(): string;
+export declare function getRuntimeProfileSchemaPath(): string;
+export {};
+//# sourceMappingURL=runtime-profile.d.ts.map

package/dist/runtime-profile.js

@@ -0,0 +1,532 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { z } from "zod";
+import { DEFAULTS_ROOT, resolveWorkspaceArtifactPath, resolveWorkspaceRoot, } from "./helpers.js";
+import { getStoreStatSync, getWorkspaceStorePath, parseVirtualStorePath, readStoreBlobSync, readStoreBlobByPathSync, toVirtualStorePath, } from "./store/store-snapshot.js";
+import { appendStatusEvent } from "./status-events.js";
+import { DEFAULT_AUTONOMY_POLICY, DEFAULT_CONTINUITY_POLICY, } from "./ace-autonomy.js";
+export const RUNTIME_PROFILE_REL_PATH = "agent-state/ACE_WORKFLOW.md";
+export const RUNTIME_PROFILE_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/ACE_RUNTIME_PROFILE.schema.json";
+export const RUNTIME_PROFILE_SCHEMA_NAME = "ace-runtime-profile@1.0.0";
+export const DEFAULT_RUNTIME_TOOL_REGISTRY_REL_PATH = "agent-state/runtime-tool-specs.json";
+export const DEFAULT_EXECUTOR_MAX_TURNS = 6;
+export const DEFAULT_EXECUTOR_TURN_TIMEOUT_MS = 300_000;
+export const DEFAULT_VERICIFY_BRIDGE_REL_PATH = "agent-state/vericify/ace-bridge.json";
+export const DEFAULT_VERICIFY_PROCESS_POST_LOG_REL_PATH = "agent-state/vericify/process-posts.json";
+const DEFAULT_RUNTIME_PROFILE_PATH = resolve(DEFAULTS_ROOT, RUNTIME_PROFILE_REL_PATH);
+const DEFAULT_RUNTIME_PROFILE_SCHEMA_PATH = resolve(DEFAULTS_ROOT, RUNTIME_PROFILE_SCHEMA_REL_PATH);
+const ANY_OBJECT = z.object({}).catchall(z.unknown());
+const STRING_LIST = z.array(z.string().min(1));
+const runtimeProfileSchema = z
+    .object({
+    ace_runtime_version: z.literal("1.0.0"),
+    runtime: z
+        .object({
+        mode: z.enum(["interactive", "unattended"]),
+        profile_name: z.string().min(1),
+    })
+        .strict(),
+    workspace: z
+        .object({
+        root: z.string().min(1),
+        retention: z.enum(["delete", "archive"]),
+        hooks: z
+            .object({
+            after_create: z.string().nullable(),
+            before_run: z.string().nullable(),
+            after_run: z.string().nullable(),
+            before_remove: z.string().nullable(),
+        })
+            .strict(),
+    })
+        .strict(),
+    executor: z
+        .object({
+        command: z.string().nullable(),
+        approval_policy: z.union([z.string(), ANY_OBJECT]),
+        thread_sandbox: z.string().min(1),
+        turn_sandbox_policy: ANY_OBJECT.nullable(),
+        max_turns: z.number().int().positive().optional().default(DEFAULT_EXECUTOR_MAX_TURNS),
+        turn_timeout_ms: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .default(DEFAULT_EXECUTOR_TURN_TIMEOUT_MS),
+    })
+        .strict(),
+    tools: z
+        .object({
+        registry_path: z
+            .string()
+            .min(1)
+            .optional()
+            .default(DEFAULT_RUNTIME_TOOL_REGISTRY_REL_PATH),
+    })
+        .strict()
+        .optional()
+        .default({ registry_path: DEFAULT_RUNTIME_TOOL_REGISTRY_REL_PATH }),
+    autonomy: z
+        .object({
+        orchestrator_preflight: z.boolean().optional().default(true),
+        recall_context: z.boolean().optional().default(true),
+        state_sources: STRING_LIST.optional().default([]),
+        before_run_checks: STRING_LIST.optional().default([]),
+        stop_checks: STRING_LIST.optional().default([]),
+        review_mode: z.string().min(1).nullable().optional().default(null),
+    })
+        .strict()
+        .optional()
+        .default(DEFAULT_AUTONOMY_POLICY),
+    continuity: z
+        .object({
+        enabled: z.boolean().optional().default(true),
+        source_paths: STRING_LIST.optional().default([]),
+        max_sources: z.number().int().positive().optional().default(6),
+        max_excerpt_chars: z.number().int().positive().optional().default(450),
+        max_total_chars: z.number().int().positive().optional().default(2600),
+        max_status_events: z.number().int().positive().optional().default(6),
+        max_run_ledger_entries: z.number().int().positive().optional().default(4),
+        include_snapshot: z.boolean().optional().default(true),
+    })
+        .strict()
+        .optional()
+        .default(DEFAULT_CONTINUITY_POLICY),
+    tracker: z
+        .object({
+        kind: z.enum(["none", "memory", "external"]),
+        config: ANY_OBJECT,
+    })
+        .strict(),
+    observability: z
+        .object({
+        http_enabled: z.boolean(),
+        http_port: z.number().int().min(0).nullable(),
+        vericify_bridge: z
+            .object({
+            enabled: z.boolean().optional().default(false),
+            bridge_path: z
+                .string()
+                .min(1)
+                .optional()
+                .default(DEFAULT_VERICIFY_BRIDGE_REL_PATH),
+            process_post_path: z
+                .string()
+                .min(1)
+                .optional()
+                .default(DEFAULT_VERICIFY_PROCESS_POST_LOG_REL_PATH),
+        })
+            .strict()
+            .optional()
+            .default({
+            enabled: false,
+            bridge_path: DEFAULT_VERICIFY_BRIDGE_REL_PATH,
+            process_post_path: DEFAULT_VERICIFY_PROCESS_POST_LOG_REL_PATH,
+        }),
+    })
+        .strict(),
+})
+    .strict();
+let lastLoadCache;
+let lastGoodSnapshot;
+function formatZodErrors(error) {
+    return error.issues.map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `${path}: ${issue.message}`;
+    });
+}
+function normalizeSource(path) {
+    return path === DEFAULT_RUNTIME_PROFILE_PATH ||
+        path === DEFAULT_RUNTIME_PROFILE_SCHEMA_PATH ||
+        path.startsWith(DEFAULTS_ROOT)
+        ? "package-defaults"
+        : "workspace";
+}
+function resolveRuntimeProfileTarget(explicitPath) {
+    if (explicitPath) {
+        const virtual = parseVirtualStorePath(explicitPath);
+        if (virtual) {
+            return {
+                path: explicitPath,
+                source: "store",
+                mode: "store",
+                key: virtual.key,
+            };
+        }
+        const resolved = explicitPath.startsWith("/")
+            ? resolve(explicitPath)
+            : resolveWorkspaceArtifactPath(explicitPath, "read");
+        return { path: resolved, source: normalizeSource(resolved), mode: "file" };
+    }
+    const workspacePath = resolveWorkspaceArtifactPath(RUNTIME_PROFILE_REL_PATH, "read");
+    if (existsSync(workspacePath)) {
+        return { path: workspacePath, source: "workspace", mode: "file" };
+    }
+    const workspaceRoot = resolveWorkspaceRoot();
+    const workflowKey = "knowledge/runtime/ACE_WORKFLOW.md";
+    const kernelWorkflowKey = "knowledge/kernel/ACE_WORKFLOW.md";
+    if (readStoreBlobSync(workspaceRoot, workflowKey)) {
+        const storePath = getWorkspaceStorePath(workspaceRoot);
+        return {
+            path: toVirtualStorePath(storePath, workflowKey),
+            source: "store",
+            mode: "store",
+            key: workflowKey,
+        };
+    }
+    if (readStoreBlobSync(workspaceRoot, kernelWorkflowKey)) {
+        const storePath = getWorkspaceStorePath(workspaceRoot);
+        return {
+            path: toVirtualStorePath(storePath, kernelWorkflowKey),
+            source: "store",
+            mode: "store",
+            key: kernelWorkflowKey,
+        };
+    }
+    return { path: DEFAULT_RUNTIME_PROFILE_PATH, source: "package-defaults", mode: "file" };
+}
+function hashContent(content) {
+    return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function signatureKey(signature) {
+    return `${signature.mtime_ms}:${signature.size}:${signature.content_sha256}`;
+}
+function computeSignature(path, content) {
+    const stat = statSync(path);
+    return {
+        mtime_ms: stat.mtimeMs,
+        size: stat.size,
+        content_sha256: hashContent(content),
+    };
+}
+function stripInlineComment(value) {
+    let inSingle = false;
+    let inDouble = false;
+    for (let idx = 0; idx < value.length; idx += 1) {
+        const char = value[idx];
+        const prev = idx > 0 ? value[idx - 1] : "";
+        if (char === "'" && !inDouble)
+            inSingle = !inSingle;
+        if (char === '"' && !inSingle && prev !== "\\")
+            inDouble = !inDouble;
+        if (char === "#" && !inSingle && !inDouble) {
+            const before = idx > 0 ? value[idx - 1] : "";
+            if (!before || /\s/.test(before)) {
+                return value.slice(0, idx).trimEnd();
+            }
+        }
+    }
+    return value.trimEnd();
+}
+function parseYamlScalar(rawValue, lineNumber) {
+    const value = stripInlineComment(rawValue.trim());
+    if (value === "null" || value === "~")
+        return null;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    if (value === "{}")
+        return {};
+    if (value === "[]")
+        return [];
+    if (/^-?\d+$/.test(value))
+        return Number(value);
+    if ((value.startsWith("[") && value.endsWith("]")) ||
+        (value.startsWith("{") && value.endsWith("}"))) {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            throw new Error(`line ${lineNumber}: invalid JSON-style scalar (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        const quote = value[0];
+        const inner = value.slice(1, -1);
+        if (quote === '"') {
+            return inner
+                .replace(/\\"/g, '"')
+                .replace(/\\n/g, "\n")
+                .replace(/\\r/g, "\r")
+                .replace(/\\t/g, "\t")
+                .replace(/\\\\/g, "\\");
+        }
+        return inner.replace(/''/g, "'");
+    }
+    return value;
+}
+function parseYamlFrontMatter(raw) {
+    const root = {};
+    const stack = [
+        { indent: -1, value: root },
+    ];
+    const lines = raw.split(/\r?\n/);
+    lines.forEach((line, index) => {
+        const lineNumber = index + 1;
+        if (!line.trim() || line.trimStart().startsWith("#"))
+            return;
+        if (line.includes("\t")) {
+            throw new Error(`line ${lineNumber}: tabs are not allowed in ACE runtime front matter`);
+        }
+        const indentMatch = line.match(/^ */);
+        const indent = indentMatch ? indentMatch[0].length : 0;
+        if (indent % 2 !== 0) {
+            throw new Error(`line ${lineNumber}: indentation must use multiples of two spaces`);
+        }
+        const trimmed = line.trim();
+        if (trimmed.startsWith("- ")) {
+            throw new Error(`line ${lineNumber}: arrays are not supported in ACE runtime front matter`);
+        }
+        const colonIndex = trimmed.indexOf(":");
+        if (colonIndex <= 0) {
+            throw new Error(`line ${lineNumber}: expected "key: value" mapping`);
+        }
+        const key = trimmed.slice(0, colonIndex).trim();
+        const valuePart = trimmed.slice(colonIndex + 1).trim();
+        if (!/^[A-Za-z0-9_-]+$/.test(key)) {
+            throw new Error(`line ${lineNumber}: invalid key "${key}"`);
+        }
+        while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+            stack.pop();
+        }
+        const parent = stack[stack.length - 1];
+        const expectedIndent = parent.indent < 0 ? 0 : parent.indent + 2;
+        if (indent > expectedIndent) {
+            throw new Error(`line ${lineNumber}: indentation jumps from ${parent.indent} to ${indent}`);
+        }
+        if (Object.prototype.hasOwnProperty.call(parent.value, key)) {
+            throw new Error(`line ${lineNumber}: duplicate key "${key}"`);
+        }
+        if (!valuePart) {
+            const child = {};
+            parent.value[key] = child;
+            stack.push({ indent, value: child });
+            return;
+        }
+        parent.value[key] = parseYamlScalar(valuePart, lineNumber);
+    });
+    return root;
+}
+function extractFrontMatter(raw) {
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/);
+    if (!match) {
+        throw new Error("ACE_WORKFLOW.md must start with YAML front matter delimited by leading and trailing --- lines");
+    }
+    const frontMatter = match[1];
+    const body = raw.slice(match[0].length);
+    return { front_matter: frontMatter, body };
+}
+function parseRuntimeProfileContent(raw) {
+    const { front_matter, body } = extractFrontMatter(raw);
+    if (body.length === 0) {
+        throw new Error("Runtime prompt template body is empty after the front matter boundary");
+    }
+    const parsedFrontMatter = parseYamlFrontMatter(front_matter);
+    const validation = runtimeProfileSchema.safeParse(parsedFrontMatter);
+    if (!validation.success) {
+        throw new Error(formatZodErrors(validation.error).join("; "));
+    }
+    return {
+        profile: validation.data,
+        prompt_template: body,
+    };
+}
+function emitRuntimeProfileEvent(eventType, input) {
+    try {
+        appendStatusEvent({
+            source_module: "capability-framework",
+            event_type: eventType,
+            status: eventType === "RUNTIME_PROFILE_INVALID" ? "fail" : "pass",
+            summary: eventType === "RUNTIME_PROFILE_INVALID"
+                ? `Runtime profile validation failed for ${input.path}`
+                : `Runtime profile ${eventType === "RUNTIME_PROFILE_LOADED" ? "loaded" : "reloaded"} from ${input.path}`,
+            payload: {
+                path: input.path,
+                source: input.source,
+                signature: input.signature,
+                errors: input.errors,
+            },
+        });
+    }
+    catch {
+        // Runtime profile reads must not fail due to observability side effects.
+    }
+}
+function ensureLastGoodSnapshot() {
+    const current = loadRuntimeProfile();
+    if (current.ok && lastGoodSnapshot)
+        return lastGoodSnapshot;
+    if (lastGoodSnapshot)
+        return lastGoodSnapshot;
+    const packaged = loadRuntimeProfile(DEFAULT_RUNTIME_PROFILE_PATH);
+    if (packaged.ok && lastGoodSnapshot)
+        return lastGoodSnapshot;
+    throw new Error(`Packaged ACE runtime profile is invalid: ${(packaged.ok ? [] : packaged.errors).join("; ")}`);
+}
+function resolveTemplatePath(context, path) {
+    return path.split(".").reduce((value, segment) => {
+        if (!value || typeof value !== "object")
+            return undefined;
+        return value[segment];
+    }, context);
+}
+function stringifyTemplateValue(value) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return JSON.stringify(value);
+}
+export function validateRuntimeProfileContent(raw) {
+    try {
+        parseRuntimeProfileContent(raw);
+        return { ok: true, schema: RUNTIME_PROFILE_SCHEMA_NAME };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            schema: RUNTIME_PROFILE_SCHEMA_NAME,
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}
+export function loadRuntimeProfile(explicitPath) {
+    const target = resolveRuntimeProfileTarget(explicitPath);
+    if (target.mode === "file" && !existsSync(target.path)) {
+        return {
+            ok: false,
+            schema: RUNTIME_PROFILE_SCHEMA_NAME,
+            path: target.path,
+            source: target.source,
+            cache_hit: false,
+            errors: [`Runtime profile file not found: ${target.path}`],
+        };
+    }
+    const virtualStore = target.mode === "store" ? parseVirtualStorePath(target.path) : undefined;
+    const raw = target.mode === "store"
+        ? virtualStore
+            ? readStoreBlobByPathSync(virtualStore.storePath, target.key ?? "")
+            : readStoreBlobSync(resolveWorkspaceRoot(), target.key ?? "")
+        : readFileSync(target.path, "utf-8");
+    if (typeof raw !== "string") {
+        return {
+            ok: false,
+            schema: RUNTIME_PROFILE_SCHEMA_NAME,
+            path: target.path,
+            source: target.source,
+            cache_hit: false,
+            errors: [`Runtime profile store entry not found: ${target.key ?? target.path}`],
+        };
+    }
+    const signature = target.mode === "store"
+        ? (() => {
+            const storePath = virtualStore?.storePath ?? getWorkspaceStorePath(resolveWorkspaceRoot());
+            const storeStat = getStoreStatSync(storePath);
+            return {
+                mtime_ms: storeStat?.mtimeMs ?? 0,
+                size: storeStat?.size ?? raw.length,
+                content_sha256: hashContent(raw),
+            };
+        })()
+        : computeSignature(target.path, raw);
+    const currentSignatureKey = signatureKey(signature);
+    if (lastLoadCache &&
+        lastLoadCache.path === target.path &&
+        lastLoadCache.source === target.source &&
+        lastLoadCache.signature_key === currentSignatureKey) {
+        return { ...lastLoadCache.result, cache_hit: true };
+    }
+    try {
+        const parsed = parseRuntimeProfileContent(raw);
+        const snapshot = {
+            path: target.path,
+            source: target.source,
+            profile: parsed.profile,
+            prompt_template: parsed.prompt_template,
+            signature,
+        };
+        const result = {
+            ok: true,
+            schema: RUNTIME_PROFILE_SCHEMA_NAME,
+            cache_hit: false,
+            ...snapshot,
+        };
+        const eventType = lastGoodSnapshot
+            ? "RUNTIME_PROFILE_RELOADED"
+            : "RUNTIME_PROFILE_LOADED";
+        lastGoodSnapshot = snapshot;
+        lastLoadCache = {
+            path: target.path,
+            source: target.source,
+            signature_key: currentSignatureKey,
+            result,
+        };
+        emitRuntimeProfileEvent(eventType, {
+            path: target.path,
+            source: target.source,
+            signature,
+        });
+        return result;
+    }
+    catch (error) {
+        const result = {
+            ok: false,
+            schema: RUNTIME_PROFILE_SCHEMA_NAME,
+            path: target.path,
+            source: target.source,
+            cache_hit: false,
+            signature,
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+        lastLoadCache = {
+            path: target.path,
+            source: target.source,
+            signature_key: currentSignatureKey,
+            result,
+        };
+        emitRuntimeProfileEvent("RUNTIME_PROFILE_INVALID", {
+            path: target.path,
+            source: target.source,
+            signature,
+            errors: result.errors,
+        });
+        return result;
+    }
+}
+export function readRuntimeProfile() {
+    return ensureLastGoodSnapshot().profile;
+}
+export function readRuntimePromptTemplate() {
+    return ensureLastGoodSnapshot().prompt_template;
+}
+export function readRuntimeProfileState() {
+    return ensureLastGoodSnapshot();
+}
+export function renderRuntimePrompt(templateContext) {
+    const active = ensureLastGoodSnapshot();
+    const renderContext = {
+        ...active.profile,
+        runtime_profile_path: active.path,
+        runtime_profile_source: active.source,
+        prompt_template: active.prompt_template,
+        ...templateContext,
+    };
+    return active.prompt_template.replace(/{{\s*([A-Za-z0-9_.-]+)\s*}}/g, (match, token) => {
+        const value = resolveTemplatePath(renderContext, token);
+        return value === undefined ? match : stringifyTemplateValue(value);
+    });
+}
+export function getRuntimeProfilePath() {
+    return ensureLastGoodSnapshot().path;
+}
+export function getRuntimeProfileSchemaPath() {
+    return DEFAULT_RUNTIME_PROFILE_SCHEMA_PATH;
+}
+//# sourceMappingURL=runtime-profile.js.map