agentplane 0.3.11 → 0.3.13

package/dist/commands/recipes/impl/manifest.js

@@ -1,229 +1,7 @@
-import { readFile } from "node:fs/promises";
-import { invalidFieldMessage, requiredFieldMessage } from "../../../cli/output.js";
-import { isRecord } from "../../../shared/guards.js";
-import { dedupeStrings } from "../../../shared/strings.js";
-import { normalizeAgentId, normalizeRecipeId, normalizeRecipeRelativePath, normalizeRecipeTags, normalizeScenarioId, normalizeSkillId, normalizeToolId, } from "./normalize.js";
-function normalizeRequiredString(raw, field) {
-    if (typeof raw !== "string")
-        throw new Error(invalidFieldMessage(field, "string"));
-    const value = raw.trim();
-    if (!value)
-        throw new Error(requiredFieldMessage(field));
-    return value;
-}
-function normalizeOptionalString(raw, field) {
-    if (raw === undefined)
-        return undefined;
-    if (typeof raw !== "string")
-        throw new Error(invalidFieldMessage(field, "string"));
-    const value = raw.trim();
-    return value || undefined;
-}
-function normalizeStringList(raw, field, opts) {
-    if (!Array.isArray(raw))
-        throw new Error(invalidFieldMessage(field, "string[]"));
-    const values = raw.map((value) => {
-        if (typeof value !== "string")
-            throw new Error(invalidFieldMessage(field, "string[]"));
-        const trimmed = value.trim();
-        if (!trimmed)
-            throw new Error(invalidFieldMessage(field, "string[]"));
-        return trimmed;
-    });
-    const deduped = dedupeStrings(values);
-    if ((opts?.minLength ?? 0) > 0 && deduped.length < (opts?.minLength ?? 0)) {
-        throw new Error(invalidFieldMessage(field, `string[${opts?.minLength ?? 0}+]`));
-    }
-    return deduped;
-}
-function normalizeOptionalStringList(raw, field) {
-    if (raw === undefined)
-        return undefined;
-    return normalizeStringList(raw, field);
-}
-function normalizeNumber(raw, field) {
-    if (raw === undefined)
-        return undefined;
-    if (typeof raw !== "number" || Number.isNaN(raw)) {
-        throw new Error(invalidFieldMessage(field, "number"));
-    }
-    return raw;
-}
-function normalizeCompatibility(raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!isRecord(raw))
-        throw new Error(invalidFieldMessage("manifest.compatibility", "object"));
-    return {
-        min_agentplane_version: normalizeOptionalString(raw.min_agentplane_version, "manifest.compatibility.min_agentplane_version"),
-        manifest_api_version: normalizeOptionalString(raw.manifest_api_version, "manifest.compatibility.manifest_api_version"),
-        scenario_api_version: normalizeOptionalString(raw.scenario_api_version, "manifest.compatibility.scenario_api_version"),
-        runtime_api_version: normalizeOptionalString(raw.runtime_api_version, "manifest.compatibility.runtime_api_version"),
-        platforms: normalizeOptionalStringList(raw.platforms, "manifest.compatibility.platforms"),
-        repo_types: normalizeOptionalStringList(raw.repo_types, "manifest.compatibility.repo_types"),
-    };
-}
-function normalizeRunProfile(raw, field) {
-    if (!isRecord(raw))
-        throw new Error(invalidFieldMessage(field, "object"));
-    return {
-        mode: normalizeRequiredString(raw.mode, `${field}.mode`),
-        sandbox: normalizeOptionalString(raw.sandbox, `${field}.sandbox`),
-        writes_artifacts_to: normalizeOptionalStringList(raw.writes_artifacts_to, `${field}.writes_artifacts_to`),
-    };
-}
-function normalizeSkills(raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!Array.isArray(raw))
-        throw new Error(invalidFieldMessage("manifest.skills", "array"));
-    return raw.map((entry, index) => {
-        if (!isRecord(entry))
-            throw new Error(invalidFieldMessage(`manifest.skills[${index}]`, "object"));
-        return {
-            id: normalizeSkillId(normalizeRequiredString(entry.id, `manifest.skills[${index}].id`)),
-            summary: normalizeRequiredString(entry.summary, `manifest.skills[${index}].summary`),
-            kind: normalizeRequiredString(entry.kind, `manifest.skills[${index}].kind`),
-            file: normalizeRecipeRelativePath(`manifest.skills[${index}].file`, normalizeRequiredString(entry.file, `manifest.skills[${index}].file`)),
-        };
-    });
-}
-function normalizeTools(raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!Array.isArray(raw))
-        throw new Error(invalidFieldMessage("manifest.tools", "array"));
-    return raw.map((entry, index) => {
-        if (!isRecord(entry))
-            throw new Error(invalidFieldMessage(`manifest.tools[${index}]`, "object"));
-        const runtime = normalizeRequiredString(entry.runtime, `manifest.tools[${index}].runtime`);
-        if (runtime !== "node" && runtime !== "bash") {
-            throw new Error(invalidFieldMessage(`manifest.tools[${index}].runtime`, '"node" | "bash"'));
-        }
-        return {
-            id: normalizeToolId(normalizeRequiredString(entry.id, `manifest.tools[${index}].id`)),
-            summary: normalizeRequiredString(entry.summary, `manifest.tools[${index}].summary`),
-            runtime,
-            entrypoint: normalizeRecipeRelativePath(`manifest.tools[${index}].entrypoint`, normalizeRequiredString(entry.entrypoint, `manifest.tools[${index}].entrypoint`)),
-            permissions: normalizeOptionalStringList(entry.permissions, `manifest.tools[${index}].permissions`),
-            timeout_ms: normalizeNumber(entry.timeout_ms, `manifest.tools[${index}].timeout_ms`),
-            cwd_policy: normalizeOptionalString(entry.cwd_policy, `manifest.tools[${index}].cwd_policy`),
-        };
-    });
-}
-function normalizeAgents(raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!Array.isArray(raw))
-        throw new Error(invalidFieldMessage("manifest.agents", "array"));
-    return raw.map((entry, index) => {
-        if (!isRecord(entry))
-            throw new Error(invalidFieldMessage(`manifest.agents[${index}]`, "object"));
-        return {
-            id: normalizeAgentId(normalizeRequiredString(entry.id, `manifest.agents[${index}].id`)),
-            display_name: normalizeRequiredString(entry.display_name, `manifest.agents[${index}].display_name`),
-            role: normalizeRequiredString(entry.role, `manifest.agents[${index}].role`),
-            summary: normalizeRequiredString(entry.summary, `manifest.agents[${index}].summary`),
-            skills: normalizeOptionalStringList(entry.skills, `manifest.agents[${index}].skills`),
-            tools: normalizeOptionalStringList(entry.tools, `manifest.agents[${index}].tools`),
-            file: normalizeRecipeRelativePath(`manifest.agents[${index}].file`, normalizeRequiredString(entry.file, `manifest.agents[${index}].file`)),
-        };
-    });
-}
-function normalizeScenarios(raw) {
-    if (!Array.isArray(raw) || raw.length === 0) {
-        throw new Error(invalidFieldMessage("manifest.scenarios", "non-empty array"));
-    }
-    return raw.map((entry, index) => {
-        if (!isRecord(entry)) {
-            throw new Error(invalidFieldMessage(`manifest.scenarios[${index}]`, "object"));
-        }
-        return {
-            id: normalizeScenarioId(normalizeRequiredString(entry.id, `manifest.scenarios[${index}].id`)),
-            name: normalizeRequiredString(entry.name, `manifest.scenarios[${index}].name`),
-            summary: normalizeRequiredString(entry.summary, `manifest.scenarios[${index}].summary`),
-            description: normalizeOptionalString(entry.description, `manifest.scenarios[${index}].description`),
-            use_when: normalizeStringList(entry.use_when, `manifest.scenarios[${index}].use_when`, {
-                minLength: 1,
-            }),
-            avoid_when: normalizeOptionalStringList(entry.avoid_when, `manifest.scenarios[${index}].avoid_when`),
-            required_inputs: normalizeStringList(entry.required_inputs, `manifest.scenarios[${index}].required_inputs`),
-            outputs: normalizeStringList(entry.outputs, `manifest.scenarios[${index}].outputs`),
-            permissions: normalizeStringList(Array.isArray(entry.permissions) ? entry.permissions : [], `manifest.scenarios[${index}].permissions`),
-            artifacts: normalizeStringList(Array.isArray(entry.artifacts) ? entry.artifacts : [], `manifest.scenarios[${index}].artifacts`),
-            agents_involved: normalizeStringList(entry.agents_involved, `manifest.scenarios[${index}].agents_involved`, { minLength: 1 }),
-            skills_used: normalizeStringList(Array.isArray(entry.skills_used) ? entry.skills_used : [], `manifest.scenarios[${index}].skills_used`),
-            tools_used: normalizeStringList(Array.isArray(entry.tools_used) ? entry.tools_used : [], `manifest.scenarios[${index}].tools_used`),
-            run_profile: normalizeRunProfile(entry.run_profile, `manifest.scenarios[${index}].run_profile`),
-            file: normalizeRecipeRelativePath(`manifest.scenarios[${index}].file`, normalizeRequiredString(entry.file, `manifest.scenarios[${index}].file`)),
-        };
-    });
-}
-function assertUniqueIds(field, items) {
-    const seen = new Set();
-    for (const item of items) {
-        if (seen.has(item.id)) {
-            throw new Error(invalidFieldMessage(field, `unique ids (duplicate: ${item.id})`));
-        }
-        seen.add(item.id);
-    }
-}
-function assertKnownReferences(field, refs, known) {
-    if (!refs || refs.length === 0)
-        return;
-    const missing = refs.filter((ref) => !known.has(ref));
-    if (missing.length > 0) {
-        throw new Error(invalidFieldMessage(field, `known ids (missing: ${missing.join(", ")})`));
-    }
+import { readRecipeManifest as readRecipeManifestBase, validateRecipeManifest as validateRecipeManifestBase, } from "@agentplaneorg/recipes";
+export async function readRecipeManifest(manifestPath) {
+    return readRecipeManifestBase(manifestPath);
 }
 export function validateRecipeManifest(raw) {
-    if (!isRecord(raw))
-        throw new Error(invalidFieldMessage("manifest", "object"));
-    if (raw.schema_version !== "1")
-        throw new Error(invalidFieldMessage("manifest.schema_version", '"1"'));
-    const id = normalizeRecipeId(normalizeRequiredString(raw.id, "manifest.id"));
-    const version = normalizeRequiredString(raw.version, "manifest.version");
-    const tags = normalizeRecipeTags(raw.tags);
-    const compatibility = normalizeCompatibility(raw.compatibility);
-    const skills = normalizeSkills(raw.skills);
-    const tools = normalizeTools(raw.tools);
-    const agents = normalizeAgents(raw.agents);
-    const scenarios = normalizeScenarios(raw.scenarios);
-    if (skills)
-        assertUniqueIds("manifest.skills", skills);
-    if (tools)
-        assertUniqueIds("manifest.tools", tools);
-    if (agents)
-        assertUniqueIds("manifest.agents", agents);
-    assertUniqueIds("manifest.scenarios", scenarios);
-    const skillIds = new Set((skills ?? []).map((skill) => skill.id));
-    const toolIds = new Set((tools ?? []).map((tool) => tool.id));
-    const agentIds = new Set((agents ?? []).map((agent) => agent.id));
-    for (const [index, agent] of (agents ?? []).entries()) {
-        assertKnownReferences(`manifest.agents[${index}].skills`, agent.skills, skillIds);
-        assertKnownReferences(`manifest.agents[${index}].tools`, agent.tools, toolIds);
-    }
-    for (const [index, scenario] of scenarios.entries()) {
-        assertKnownReferences(`manifest.scenarios[${index}].agents_involved`, scenario.agents_involved, agentIds);
-        assertKnownReferences(`manifest.scenarios[${index}].skills_used`, scenario.skills_used, skillIds);
-        assertKnownReferences(`manifest.scenarios[${index}].tools_used`, scenario.tools_used, toolIds);
-    }
-    return {
-        schema_version: "1",
-        id,
-        version,
-        name: normalizeRequiredString(raw.name, "manifest.name"),
-        summary: normalizeRequiredString(raw.summary, "manifest.summary"),
-        description: normalizeRequiredString(raw.description, "manifest.description"),
-        tags: tags.length > 0 ? tags : undefined,
-        compatibility,
-        skills,
-        agents,
-        tools,
-        scenarios,
-    };
-}
-export async function readRecipeManifest(manifestPath) {
-    const raw = JSON.parse(await readFile(manifestPath, "utf8"));
-    return validateRecipeManifest(raw);
+    return validateRecipeManifestBase(raw);
 }

package/dist/commands/recipes/impl/overlay-project.d.ts

@@ -0,0 +1,32 @@
+import { type CompiledRecipeAssetRegistry, type CompiledOverlayBundle, type ProjectRecipesLockFile } from "@agentplaneorg/recipes";
+export declare function readActiveRecipeIds(project: {
+    agentplaneDir: string;
+}): Promise<string[]>;
+export declare function setRecipeActive(opts: {
+    project: {
+        agentplaneDir: string;
+    };
+    recipeId: string;
+    active: boolean;
+}): Promise<string[]>;
+export declare function compileProjectOverlayArtifacts(project: {
+    agentplaneDir: string;
+}): Promise<{
+    bundle: CompiledOverlayBundle;
+    lock: ProjectRecipesLockFile;
+    assets: CompiledRecipeAssetRegistry;
+}>;
+export declare function refreshProjectOverlayArtifacts(project: {
+    agentplaneDir: string;
+}): Promise<{
+    bundle: CompiledOverlayBundle;
+    lock: ProjectRecipesLockFile;
+    assets: CompiledRecipeAssetRegistry;
+}>;
+export declare function readProjectOverlayBundle(project: {
+    agentplaneDir: string;
+}): Promise<CompiledOverlayBundle | null>;
+export declare function readProjectRecipeAssetRegistry(project: {
+    agentplaneDir: string;
+}): Promise<CompiledRecipeAssetRegistry | null>;
+//# sourceMappingURL=overlay-project.d.ts.map

package/dist/commands/recipes/impl/overlay-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-project.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/overlay-project.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,wBAAwB,CAAC;AAiJhC,wBAAsB,mBAAmB,CAAC,OAAO,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAM/F;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,OAAO,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAepB;AAED,wBAAsB,8BAA8B,CAAC,OAAO,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC;IAChG,MAAM,EAAE,qBAAqB,CAAC;IAC9B,IAAI,EAAE,sBAAsB,CAAC;IAC7B,MAAM,EAAE,2BAA2B,CAAC;CACrC,CAAC,CAiHD;AAED,wBAAsB,8BAA8B,CAAC,OAAO,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC;IAChG,MAAM,EAAE,qBAAqB,CAAC;IAC9B,IAAI,EAAE,sBAAsB,CAAC;IAC7B,MAAM,EAAE,2BAA2B,CAAC;CACrC,CAAC,CAUD;AAED,wBAAsB,wBAAwB,CAAC,OAAO,EAAE;IACtD,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAUxC;AAED,wBAAsB,8BAA8B,CAAC,OAAO,EAAE;IAC5D,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,2BAA2B,GAAG,IAAI,CAAC,CAU9C"}

package/dist/commands/recipes/impl/overlay-project.js

@@ -0,0 +1,282 @@
+import { mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { createEmptyOverlayBundle, hashOverlayInputs, } from "@agentplaneorg/recipes";
+import { writeJsonStableIfChanged } from "../../../shared/write-if-changed.js";
+import { readProjectInstalledRecipes } from "./project-installed-recipes.js";
+import { readProjectRecipesRegistry, writeProjectRecipesRegistry } from "./project-registry.js";
+import { resolveProjectInstalledRecipeDir, resolveProjectOverlayBundlePath, resolveProjectRecipeAssetsPath, resolveProjectRecipesDir, resolveProjectRecipesLockPath, } from "./paths.js";
+function ensureTrailingNewline(text) {
+    return text.endsWith("\n") ? text : `${text}\n`;
+}
+function stripMarkdownFrontmatter(text) {
+    if (!text.startsWith("---\n"))
+        return text;
+    const end = text.indexOf("\n---\n", 4);
+    if (end === -1)
+        return text;
+    return text.slice(end + 5);
+}
+function normalizePromptContent(text) {
+    return ensureTrailingNewline(stripMarkdownFrontmatter(text).trim());
+}
+function normalizeRecipeAssetContent(text) {
+    return ensureTrailingNewline(text.trimEnd());
+}
+function uniqueById(items) {
+    const seen = new Set();
+    const result = [];
+    for (const item of items) {
+        if (seen.has(item.id))
+            continue;
+        seen.add(item.id);
+        result.push(item);
+    }
+    return result;
+}
+function recipeAssetId(recipeId, kind, assetId) {
+    return `recipe:${recipeId}/${kind}:${assetId}`;
+}
+function relativeSource(project, absolutePath) {
+    return path.relative(project.agentplaneDir, absolutePath).replaceAll("\\", "/");
+}
+async function compileProjectRecipeAssets(opts) {
+    const entries = [];
+    for (const recipe of opts.installed.recipes) {
+        const recipeDir = recipe.project_path
+            ? path.join(resolveProjectRecipesDir(opts.project), recipe.project_path)
+            : resolveProjectInstalledRecipeDir(opts.project, recipe.id);
+        const manifest = recipe.manifest;
+        for (const agent of manifest.agents ?? []) {
+            const sourcePath = path.join(recipeDir, agent.file);
+            entries.push({
+                id: recipeAssetId(recipe.id, "agent", agent.id),
+                kind: "agent",
+                recipe_id: recipe.id,
+                recipe_version: recipe.version,
+                recipe_name: manifest.name,
+                asset_id: agent.id,
+                source: relativeSource(opts.project, sourcePath),
+                summary: agent.summary,
+                definition: agent,
+                content: normalizeRecipeAssetContent(await readFile(sourcePath, "utf8")),
+            });
+        }
+        for (const skill of manifest.skills ?? []) {
+            const sourcePath = path.join(recipeDir, skill.file);
+            entries.push({
+                id: recipeAssetId(recipe.id, "skill", skill.id),
+                kind: "skill",
+                recipe_id: recipe.id,
+                recipe_version: recipe.version,
+                recipe_name: manifest.name,
+                asset_id: skill.id,
+                source: relativeSource(opts.project, sourcePath),
+                summary: skill.summary,
+                definition: skill,
+                content: normalizeRecipeAssetContent(await readFile(sourcePath, "utf8")),
+            });
+        }
+        for (const tool of manifest.tools ?? []) {
+            entries.push({
+                id: recipeAssetId(recipe.id, "tool", tool.id),
+                kind: "tool",
+                recipe_id: recipe.id,
+                recipe_version: recipe.version,
+                recipe_name: manifest.name,
+                asset_id: tool.id,
+                source: relativeSource(opts.project, path.join(recipeDir, tool.entrypoint)),
+                summary: tool.summary,
+                definition: tool,
+            });
+        }
+        for (const scenario of manifest.scenarios ?? []) {
+            entries.push({
+                id: recipeAssetId(recipe.id, "scenario", scenario.id),
+                kind: "scenario",
+                recipe_id: recipe.id,
+                recipe_version: recipe.version,
+                recipe_name: manifest.name,
+                asset_id: scenario.id,
+                source: relativeSource(opts.project, path.join(recipeDir, scenario.file)),
+                summary: scenario.summary,
+                definition: scenario,
+            });
+        }
+        for (const [templateKey, content] of Object.entries(manifest.templates ?? {})) {
+            entries.push({
+                id: recipeAssetId(recipe.id, "template", templateKey),
+                kind: "template",
+                recipe_id: recipe.id,
+                recipe_version: recipe.version,
+                recipe_name: manifest.name,
+                asset_id: templateKey,
+                source: relativeSource(opts.project, path.join(recipeDir, "manifest.json")),
+                content,
+            });
+        }
+    }
+    return {
+        schema_version: 1,
+        kind: "recipe_asset_registry",
+        entries: uniqueById(entries).toSorted((left, right) => left.id.localeCompare(right.id)),
+    };
+}
+export async function readActiveRecipeIds(project) {
+    const registry = await readProjectRecipesRegistry(project);
+    return registry.recipes
+        .filter((entry) => entry.active)
+        .map((entry) => entry.id)
+        .toSorted();
+}
+export async function setRecipeActive(opts) {
+    const registry = await readProjectRecipesRegistry(opts.project);
+    const current = new Set();
+    const recipes = registry.recipes.map((entry) => {
+        const isTarget = entry.id === opts.recipeId;
+        const active = isTarget ? opts.active : entry.active;
+        if (active)
+            current.add(entry.id);
+        return isTarget ? { ...entry, active } : entry;
+    });
+    await writeProjectRecipesRegistry(opts.project, {
+        schema_version: 1,
+        updated_at: registry.updated_at,
+        recipes,
+    });
+    return [...current].toSorted();
+}
+export async function compileProjectOverlayArtifacts(project) {
+    const [activeIds, installed] = await Promise.all([
+        readActiveRecipeIds(project),
+        readProjectInstalledRecipes(project),
+    ]);
+    const bundle = createEmptyOverlayBundle();
+    const lock = { schema_version: 1, active: [] };
+    for (const recipeId of activeIds) {
+        const entry = installed.recipes.find((candidate) => candidate.id === recipeId);
+        if (!entry) {
+            throw new Error(`Active overlay is not installed: ${recipeId}`);
+        }
+        if (entry.manifest.kind !== "project_overlay") {
+            throw new Error(`Active recipe ${recipeId} is not a project overlay`);
+        }
+        const manifest = entry.manifest;
+        const recipeDir = entry.project_path
+            ? path.join(resolveProjectRecipesDir(project), entry.project_path)
+            : resolveProjectInstalledRecipeDir(project, entry.id);
+        const promptInputs = [];
+        if (manifest.requires) {
+            for (const required of manifest.requires) {
+                if (!activeIds.includes(required)) {
+                    throw new Error(`Overlay ${manifest.id} requires active overlay ${required}`);
+                }
+            }
+        }
+        if (manifest.conflicts) {
+            for (const conflict of manifest.conflicts) {
+                if (activeIds.includes(conflict.recipe_id)) {
+                    throw new Error(`Overlay ${manifest.id} conflicts with ${conflict.recipe_id}: ${conflict.reason}`);
+                }
+            }
+        }
+        for (const fragment of manifest.prompts ?? []) {
+            const absPath = path.join(recipeDir, fragment.file);
+            const content = normalizePromptContent(await readFile(absPath, "utf8"));
+            promptInputs.push({ id: fragment.id, content });
+            bundle.surfaces[fragment.surface].push({
+                ...fragment,
+                recipe_id: manifest.id,
+                recipe_version: manifest.version,
+                recipe_name: manifest.name,
+                summary: manifest.summary,
+                source: path.relative(project.agentplaneDir, absPath).replaceAll("\\", "/"),
+                content,
+            });
+            bundle.trace.push({
+                recipe_id: manifest.id,
+                recipe_version: manifest.version,
+                accepted: true,
+                reason: "compiled prompt fragment",
+                source: fragment.file,
+                surface: fragment.surface,
+                fragment_id: fragment.id,
+            });
+        }
+        for (const validator of manifest.validators ?? []) {
+            bundle.validators.push({
+                ...validator,
+                recipe_id: manifest.id,
+                recipe_version: manifest.version,
+            });
+            bundle.trace.push({
+                recipe_id: manifest.id,
+                recipe_version: manifest.version,
+                accepted: true,
+                reason: "compiled validator",
+                validator_id: validator.id,
+            });
+        }
+        bundle.active.push({
+            id: manifest.id,
+            version: manifest.version,
+            name: manifest.name,
+            summary: manifest.summary,
+        });
+        bundle.agents.push(...(manifest.agents ?? []));
+        bundle.tools.push(...(manifest.tools ?? []));
+        Object.assign(bundle.templates, manifest.templates ?? {});
+        lock.active.push({
+            id: manifest.id,
+            version: manifest.version,
+            kind: manifest.kind,
+            source: entry.source,
+            hash: hashOverlayInputs({ manifest, prompts: promptInputs }),
+        });
+    }
+    bundle.agents = uniqueById(bundle.agents);
+    bundle.tools = uniqueById(bundle.tools);
+    for (const surface of Object.keys(bundle.surfaces)) {
+        bundle.surfaces[surface] = bundle.surfaces[surface].toSorted((left, right) => (left.order ?? 0) - (right.order ?? 0) ||
+            left.recipe_id.localeCompare(right.recipe_id) ||
+            left.id.localeCompare(right.id));
+    }
+    lock.active = lock.active.toSorted((left, right) => left.id.localeCompare(right.id));
+    return {
+        bundle,
+        lock,
+        assets: await compileProjectRecipeAssets({ project, installed }),
+    };
+}
+export async function refreshProjectOverlayArtifacts(project) {
+    const compiled = await compileProjectOverlayArtifacts(project);
+    const bundlePath = resolveProjectOverlayBundlePath(project);
+    const lockPath = resolveProjectRecipesLockPath(project);
+    const assetsPath = resolveProjectRecipeAssetsPath(project);
+    await mkdir(path.dirname(bundlePath), { recursive: true });
+    await writeJsonStableIfChanged(bundlePath, compiled.bundle);
+    await writeJsonStableIfChanged(lockPath, compiled.lock);
+    await writeJsonStableIfChanged(assetsPath, compiled.assets);
+    return compiled;
+}
+export async function readProjectOverlayBundle(project) {
+    try {
+        return JSON.parse(await readFile(resolveProjectOverlayBundlePath(project), "utf8"));
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+export async function readProjectRecipeAssetRegistry(project) {
+    try {
+        return JSON.parse(await readFile(resolveProjectRecipeAssetsPath(project), "utf8"));
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}

package/dist/commands/recipes/impl/paths.d.ts

@@ -10,13 +10,31 @@ export declare function resolveInstalledRecipeDir(entry: {
 export declare function resolveProjectRecipesDir(resolved: {
     agentplaneDir: string;
 }): string;
-export declare function resolveProjectInstalledRecipeDir(resolved: {
+export declare function resolveProjectRecipesPackagesDir(resolved: {
+    agentplaneDir: string;
+}): string;
+export declare function resolveProjectRecipesRegistryPath(resolved: {
+    agentplaneDir: string;
+}): string;
+export declare function resolveProjectVendoredRecipeDir(resolved: {
     agentplaneDir: string;
 }, recipeId: string): string;
-export declare function resolveProjectRecipeInstallMetaPath(resolved: {
+export declare function resolveProjectInstalledRecipeDir(resolved: {
     agentplaneDir: string;
 }, recipeId: string): string;
 export declare function resolveProjectRecipesCacheDir(resolved: {
     agentplaneDir: string;
 }): string;
+export declare function resolveProjectRecipesLockPath(resolved: {
+    agentplaneDir: string;
+}): string;
+export declare function resolveProjectGeneratedDir(resolved: {
+    agentplaneDir: string;
+}): string;
+export declare function resolveProjectOverlayBundlePath(resolved: {
+    agentplaneDir: string;
+}): string;
+export declare function resolveProjectRecipeAssetsPath(resolved: {
+    agentplaneDir: string;
+}): string;
 //# sourceMappingURL=paths.d.ts.map

package/dist/commands/recipes/impl/paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/paths.ts"],"names":[],"mappings":"AAcA,wBAAgB,qBAAqB,IAAI,MAAM,CAI9C;AAED,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED,wBAAgB,2BAA2B,IAAI,MAAM,CAEpD;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED,wBAAgB,+BAA+B,IAAI,MAAM,CAExD;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAExF;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEpF;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,EACnC,QAAQ,EAAE,MAAM,GACf,MAAM,CAER;AAED,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,EACnC,QAAQ,EAAE,MAAM,GACf,MAAM,CAER;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEzF"}
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/paths.ts"],"names":[],"mappings":"AAeA,wBAAgB,qBAAqB,IAAI,MAAM,CAI9C;AAED,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED,wBAAgB,2BAA2B,IAAI,MAAM,CAEpD;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED,wBAAgB,+BAA+B,IAAI,MAAM,CAExD;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAExF;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEpF;AAED,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE5F;AAED,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE7F;AAED,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,EACnC,QAAQ,EAAE,MAAM,GACf,MAAM,CAER;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,EACnC,QAAQ,EAAE,MAAM,GACf,MAAM,CAER;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEzF;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEzF;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEtF;AAED,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE3F;AAED,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE1F"}

package/dist/commands/recipes/impl/paths.js

@@ -1,6 +1,6 @@
 import os from "node:os";
 import path from "node:path";
-import { AGENTPLANE_HOME_ENV, GLOBAL_RECIPES_DIR_NAME, INSTALLED_RECIPES_NAME, RECIPE_INSTALL_META_NAME, PROJECT_RECIPES_CACHE_DIR_NAME, RECIPES_DIR_NAME, RECIPES_REMOTE_INDEX_NAME, RECIPES_REMOTE_INDEX_SIG_NAME, } from "./constants.js";
+import { AGENTPLANE_HOME_ENV, GLOBAL_RECIPES_DIR_NAME, INSTALLED_RECIPES_NAME, PROJECT_RECIPES_PACKAGES_DIR_NAME, PROJECT_RECIPES_REGISTRY_NAME, PROJECT_RECIPES_CACHE_DIR_NAME, RECIPES_DIR_NAME, RECIPES_REMOTE_INDEX_NAME, RECIPES_REMOTE_INDEX_SIG_NAME, } from "./constants.js";
 export function resolveAgentplaneHome() {
     const overridden = process.env[AGENTPLANE_HOME_ENV]?.trim();
     if (overridden)
@@ -25,12 +25,30 @@ export function resolveInstalledRecipeDir(entry) {
 export function resolveProjectRecipesDir(resolved) {
     return path.join(resolved.agentplaneDir, RECIPES_DIR_NAME);
 }
-export function resolveProjectInstalledRecipeDir(resolved, recipeId) {
-    return path.join(resolveProjectRecipesDir(resolved), recipeId);
+export function resolveProjectRecipesPackagesDir(resolved) {
+    return path.join(resolveProjectRecipesDir(resolved), PROJECT_RECIPES_PACKAGES_DIR_NAME);
+}
+export function resolveProjectRecipesRegistryPath(resolved) {
+    return path.join(resolveProjectRecipesDir(resolved), PROJECT_RECIPES_REGISTRY_NAME);
 }
-export function resolveProjectRecipeInstallMetaPath(resolved, recipeId) {
-    return path.join(resolveProjectInstalledRecipeDir(resolved, recipeId), RECIPE_INSTALL_META_NAME);
+export function resolveProjectVendoredRecipeDir(resolved, recipeId) {
+    return path.join(resolveProjectRecipesPackagesDir(resolved), recipeId);
+}
+export function resolveProjectInstalledRecipeDir(resolved, recipeId) {
+    return resolveProjectVendoredRecipeDir(resolved, recipeId);
 }
 export function resolveProjectRecipesCacheDir(resolved) {
     return path.join(resolved.agentplaneDir, PROJECT_RECIPES_CACHE_DIR_NAME);
 }
+export function resolveProjectRecipesLockPath(resolved) {
+    return path.join(resolved.agentplaneDir, "recipes.lock.json");
+}
+export function resolveProjectGeneratedDir(resolved) {
+    return path.join(resolved.agentplaneDir, "generated");
+}
+export function resolveProjectOverlayBundlePath(resolved) {
+    return path.join(resolveProjectGeneratedDir(resolved), "overlay-bundle.json");
+}
+export function resolveProjectRecipeAssetsPath(resolved) {
+    return path.join(resolveProjectGeneratedDir(resolved), "recipe-assets.json");
+}

package/dist/commands/recipes/impl/project-installed-recipes.d.ts

@@ -1,7 +1,5 @@
-import type { InstalledRecipesFile, RecipeInstallMetadata } from "./types.js";
-export declare function readRecipeInstallMetadata(filePath: string): Promise<RecipeInstallMetadata | null>;
-export declare function writeRecipeInstallMetadata(filePath: string, metadata: RecipeInstallMetadata): Promise<void>;
+import type { ProjectInstalledRecipesFile } from "./types.js";
 export declare function readProjectInstalledRecipes(opts: {
     agentplaneDir: string;
-}): Promise<InstalledRecipesFile>;
+}): Promise<ProjectInstalledRecipesFile>;
 //# sourceMappingURL=project-installed-recipes.d.ts.map

package/dist/commands/recipes/impl/project-installed-recipes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project-installed-recipes.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/project-installed-recipes.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAwB,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAuCpG,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CASvC;AAED,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA0DhC"}
+{"version":3,"file":"project-installed-recipes.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/project-installed-recipes.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAA+B,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAiB3F,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CA8CvC"}