@multileaf/ai-workflow 0.1.0

package/dist/lockfile.js

@@ -0,0 +1,59 @@
+export function resolvePackage(pkg) {
+    return {
+        id: pkg.id,
+        version: pkg.version,
+        provider: pkg.provider,
+        source: pkg.source,
+        integrity: `sha256-${pkg.id}@${pkg.version}`,
+        permissions: [...pkg.permissions].sort(),
+    };
+}
+export function serializeLock(packages) {
+    const ordered = [...packages].sort((a, b) => a.id.localeCompare(b.id));
+    return `schema: 1\npackages:\n${ordered.map((pkg) => `  - id: ${pkg.id}\n    version: ${pkg.version}\n    provider: ${pkg.provider}\n    source: ${pkg.source}\n    integrity: ${pkg.integrity}\n    permissions: [${[...(pkg.permissions ?? [])].sort().join(", ")}]\n`).join("")}`;
+}
+export function parseLock(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines.at(-1) === "")
+        lines.pop();
+    if (lines[0] !== "schema: 1")
+        throw new Error("Lockfile schema must be version 1.");
+    if (lines[1] !== "packages:")
+        throw new Error("Lockfile packages section is required.");
+    const packages = [];
+    for (let index = 2; index < lines.length;) {
+        const id = requiredLockValue(lines[index], /^ {2}- id: (.+)$/, "id");
+        const version = requiredLockValue(lines[index + 1], /^ {4}version: (.+)$/, "version");
+        const provider = requiredLockValue(lines[index + 2], /^ {4}provider: (.+)$/, "provider");
+        const source = requiredLockValue(lines[index + 3], /^ {4}source: (.+)$/, "source");
+        const integrity = requiredLockValue(lines[index + 4], /^ {4}integrity: (.+)$/, "integrity");
+        index += 5;
+        let permissions;
+        if (lines[index]?.startsWith("    permissions:")) {
+            const value = lines[index].match(/^ {4}permissions: \[([^\]]*)\]$/)?.[1];
+            if (value === undefined)
+                throw new Error(`Lockfile permissions are invalid: ${id}`);
+            permissions = value === "" ? [] : value.split(",").map((permission) => permission.trim());
+            if (permissions.some((permission) => permission.length === 0))
+                throw new Error(`Lockfile permissions are invalid: ${id}`);
+            index += 1;
+        }
+        packages.push({
+            id,
+            version,
+            provider,
+            source,
+            integrity,
+            ...(permissions ? { permissions } : {}),
+        });
+    }
+    if (new Set(packages.map(({ id }) => id)).size !== packages.length)
+        throw new Error("Lockfile package identifiers must be unique.");
+    return packages;
+}
+function requiredLockValue(line, pattern, field) {
+    const value = line?.match(pattern)?.[1]?.trim();
+    if (!value)
+        throw new Error(`Lockfile package field is invalid: ${field}`);
+    return value;
+}

package/dist/manifest.d.ts

@@ -0,0 +1,15 @@
+import type { Target } from "./types.js";
+export type Manifest = {
+    schema: number;
+    project: {
+        name: string;
+    };
+    target: {
+        active: Target;
+    };
+    policies: {
+        artifactLanguage: string;
+    };
+};
+export declare function serializeManifest(manifest: Manifest): string;
+export declare function parseManifest(content: string): Manifest;

package/dist/manifest.js

@@ -0,0 +1,35 @@
+import { TARGETS } from "./types.js";
+export function serializeManifest(manifest) {
+    if (manifest.schema !== 1)
+        throw new Error("Manifest schema must be version 1.");
+    if (!manifest.project.name.trim())
+        throw new Error("Manifest project.name is required.");
+    if (!TARGETS.includes(manifest.target.active))
+        throw new Error(`Manifest target.active is unsupported: ${manifest.target.active}.`);
+    if (manifest.policies.artifactLanguage !== "en")
+        throw new Error("Manifest policies.artifact_language must be en.");
+    return `schema: 1\nproject:\n  name: ${manifest.project.name}\ntarget:\n  active: ${manifest.target.active}\npolicies:\n  artifact_language: en\n`;
+}
+export function parseManifest(content) {
+    const schema = valueOf(content, "schema");
+    const name = valueOf(content, "name");
+    const target = valueOf(content, "active");
+    const language = valueOf(content, "artifact_language");
+    if (schema !== "1")
+        throw new Error("Manifest schema must be version 1.");
+    if (!name)
+        throw new Error("Manifest project.name is required.");
+    if (!TARGETS.includes(target))
+        throw new Error(`Manifest target.active is unsupported: ${target || "missing"}.`);
+    if (language !== "en")
+        throw new Error("Manifest policies.artifact_language must be en.");
+    return {
+        schema: 1,
+        project: { name },
+        target: { active: target },
+        policies: { artifactLanguage: language },
+    };
+}
+function valueOf(content, key) {
+    return content.match(new RegExp(`^\\s*${key}:\\s*(.+)\\s*$`, "m"))?.[1]?.trim() ?? "";
+}

package/dist/migration.d.ts

@@ -0,0 +1,22 @@
+import type { Target } from "./types.js";
+export type ResourceMigration = {
+    source: string;
+    destination: string;
+};
+export type MigrationSnapshot = {
+    path: string;
+    existed: boolean;
+    contentBase64: string;
+};
+export declare function planNeutralResourceMigration(neutralRoot: string, relativeFiles: string[], target: Target): ResourceMigration[];
+export declare function serializeMigrationPreview(target: Target, migrations: ResourceMigration[], existingDestinations: string[]): string;
+export declare function serializeMigrationSnapshots(snapshots: MigrationSnapshot[]): string;
+export declare function parseMigrationSnapshots(encoded: string): MigrationSnapshot[];
+export declare function readResourceBytes(fs: {
+    read(path: string): string;
+    readBytes?(path: string): Uint8Array;
+}, path: string): Uint8Array;
+export declare function writeResourceBytes(fs: {
+    write(path: string, content: string): void;
+    writeBytes?(path: string, content: Uint8Array): void;
+}, path: string, content: Uint8Array): void;

package/dist/migration.js

@@ -0,0 +1,50 @@
+import { join } from "node:path";
+import { renderResourcePath } from "./adapter.js";
+import { RESOURCE_TYPES } from "./package-contract.js";
+export function planNeutralResourceMigration(neutralRoot, relativeFiles, target) {
+    return relativeFiles
+        .flatMap((relative) => {
+        const [candidateType, id, filename, extra] = relative.split("/");
+        if (extra || !RESOURCE_TYPES.includes(candidateType) || !id || !filename)
+            return [];
+        const type = candidateType;
+        const expected = type === "skills" ? "SKILL.md" : `${id}.md`;
+        if (filename !== expected)
+            return [];
+        return [
+            { source: join(neutralRoot, relative), destination: renderResourcePath(target, type, id) },
+        ];
+    })
+        .sort((left, right) => left.destination.localeCompare(right.destination));
+}
+export function serializeMigrationPreview(target, migrations, existingDestinations) {
+    const existing = new Set(existingDestinations);
+    const changes = migrations.map(({ destination }) => existing.has(destination) ? `update: ${destination}` : `add: ${destination}`);
+    return `Migration preview for ${target}:\n${changes.join("\n")}${changes.length ? "\n" : ""}remove: previous target ai-init\n`;
+}
+export function serializeMigrationSnapshots(snapshots) {
+    return Buffer.from(JSON.stringify(snapshots), "utf8").toString("base64");
+}
+export function parseMigrationSnapshots(encoded) {
+    const value = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+    if (!Array.isArray(value))
+        throw new Error("Migration resource snapshots are invalid.");
+    return value.map((snapshot) => {
+        if (typeof snapshot !== "object" ||
+            snapshot === null ||
+            typeof snapshot.path !== "string" ||
+            typeof snapshot.existed !== "boolean" ||
+            typeof snapshot.contentBase64 !== "string")
+            throw new Error("Migration resource snapshots are invalid.");
+        return snapshot;
+    });
+}
+export function readResourceBytes(fs, path) {
+    return fs.readBytes?.(path) ?? Buffer.from(fs.read(path), "utf8");
+}
+export function writeResourceBytes(fs, path, content) {
+    if (fs.writeBytes)
+        fs.writeBytes(path, content);
+    else
+        fs.write(path, Buffer.from(content).toString("utf8"));
+}

package/dist/orchestration.d.ts

@@ -0,0 +1,30 @@
+export declare const ORCHESTRATION_AGENTS: readonly ["codex", "claude", "gemini"];
+export type OrchestrationAgent = (typeof ORCHESTRATION_AGENTS)[number];
+export type OrchestrationTask = {
+    id: string;
+    agent: OrchestrationAgent;
+    prompt: string;
+    dependsOn: string[];
+};
+export type OrchestrationPlan = {
+    schema: 1;
+    id: string;
+    tasks: OrchestrationTask[];
+};
+export type OrchestrationTaskResult = {
+    id: string;
+    status: "passed" | "failed" | "blocked";
+    detail: string;
+};
+export interface AgentOrchestrator {
+    run(task: OrchestrationTask): Promise<{
+        success: boolean;
+        detail: string;
+    }>;
+}
+export declare function parseOrchestrationPlan(content: string): OrchestrationPlan;
+export declare function orchestrationWaves(plan: OrchestrationPlan): string[][];
+export declare function executeOrchestrationPlan(plan: OrchestrationPlan, orchestrator: AgentOrchestrator, maxParallel: number): Promise<OrchestrationTaskResult[]>;
+export declare function validateOrchestrationParallelism(value: number): number;
+export declare function serializeOrchestrationPreview(plan: OrchestrationPlan): string;
+export declare function serializeOrchestrationResults(plan: OrchestrationPlan, results: OrchestrationTaskResult[]): string;

package/dist/orchestration.js

@@ -0,0 +1,172 @@
+export const ORCHESTRATION_AGENTS = ["codex", "claude", "gemini"];
+export function parseOrchestrationPlan(content) {
+    if (/\r(?!\n)/.test(content))
+        throw new Error("Orchestration plan contains unsupported characters.");
+    const normalized = content.replace(/\r\n/g, "\n");
+    if ([...normalized].some((character) => character !== "\n" && isControl(character)))
+        throw new Error("Orchestration plan contains unsupported characters.");
+    const lines = normalized.split("\n").filter(Boolean);
+    if (lines.some((line) => !isPlanLine(line)))
+        throw new Error("Orchestration plan syntax is invalid.");
+    if (lines.length < 7 || lines[2] !== "tasks:" || (lines.length - 3) % 4 !== 0)
+        throw new Error("Orchestration plan structure is invalid.");
+    const schema = lines[0]?.match(/^schema:\s*(.+)$/)?.[1]?.trim();
+    if (schema !== "1")
+        throw new Error("Orchestration plan schema must be version 1.");
+    const id = lines[1]?.match(/^id:\s*(.+)$/)?.[1]?.trim() ?? "";
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(id))
+        throw new Error("Orchestration plan id must use lowercase letters, numbers, and hyphens.");
+    const taskCount = (lines.length - 3) / 4;
+    if (taskCount > 64)
+        throw new Error("Orchestration plan cannot exceed 64 tasks.");
+    const tasks = Array.from({ length: taskCount }, (_, index) => {
+        const offset = 3 + index * 4;
+        const taskId = lines[offset]?.match(/^\s{2}- id:\s*(.+)$/)?.[1]?.trim() ?? "";
+        const agent = orderedField(lines[offset + 1] ?? "", "agent");
+        const prompt = quotedValue(orderedField(lines[offset + 2] ?? "", "prompt"), "prompt");
+        const dependsOn = inlineList(orderedField(lines[offset + 3] ?? "", "depends_on"));
+        if (!/^TASK-\d+$/.test(taskId))
+            throw new Error(`Invalid orchestration task id: ${taskId}`);
+        if (!ORCHESTRATION_AGENTS.includes(agent))
+            throw new Error(`Unsupported orchestration agent for ${taskId}: ${agent}`);
+        if (!prompt.trim())
+            throw new Error(`Orchestration task prompt is required: ${taskId}`);
+        if ([...prompt].some(isControl))
+            throw new Error(`Orchestration task prompt contains unsupported characters: ${taskId}`);
+        if (prompt.length > 8000)
+            throw new Error(`Orchestration task prompt is too long: ${taskId}`);
+        return { id: taskId, agent: agent, prompt, dependsOn };
+    });
+    assertPlanGraph(tasks);
+    return { schema: 1, id, tasks };
+}
+export function orchestrationWaves(plan) {
+    const remaining = new Map(plan.tasks.map((task) => [task.id, task]));
+    const completed = new Set();
+    const waves = [];
+    while (remaining.size) {
+        const wave = [...remaining.values()]
+            .filter((task) => task.dependsOn.every((dependency) => completed.has(dependency)))
+            .map((task) => task.id)
+            .sort();
+        if (!wave.length)
+            throw new Error("Orchestration plan contains a dependency cycle.");
+        waves.push(wave);
+        wave.forEach((id) => {
+            remaining.delete(id);
+            completed.add(id);
+        });
+    }
+    return waves;
+}
+export async function executeOrchestrationPlan(plan, orchestrator, maxParallel) {
+    validateOrchestrationParallelism(maxParallel);
+    const tasks = new Map(plan.tasks.map((task) => [task.id, task]));
+    const results = new Map();
+    for (const wave of orchestrationWaves(plan)) {
+        for (let offset = 0; offset < wave.length; offset += maxParallel) {
+            const batch = wave.slice(offset, offset + maxParallel);
+            await Promise.all(batch.map(async (id) => {
+                const task = tasks.get(id);
+                if (!task)
+                    throw new Error(`Unknown orchestration task: ${id}`);
+                if (task.dependsOn.some((dependency) => results.get(dependency)?.status !== "passed")) {
+                    results.set(id, { id, status: "blocked", detail: "A dependency did not pass." });
+                    return;
+                }
+                try {
+                    const outcome = await orchestrator.run(task);
+                    results.set(id, {
+                        id,
+                        status: outcome.success ? "passed" : "failed",
+                        detail: safeDetail(outcome.detail),
+                    });
+                }
+                catch (error) {
+                    results.set(id, {
+                        id,
+                        status: "failed",
+                        detail: safeDetail(error instanceof Error ? error.message : String(error)),
+                    });
+                }
+            }));
+        }
+    }
+    return plan.tasks.map(({ id }) => results.get(id) ?? { id, status: "blocked", detail: "Not run." });
+}
+export function validateOrchestrationParallelism(value) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > 16)
+        throw new Error("Orchestration parallelism must be between 1 and 16.");
+    return value;
+}
+export function serializeOrchestrationPreview(plan) {
+    return `schema: 1\nplan: ${plan.id}\nwaves:\n${orchestrationWaves(plan)
+        .map((wave, index) => `  - index: ${index + 1}\n    tasks: [${wave.join(", ")}]`)
+        .join("\n")}\n`;
+}
+export function serializeOrchestrationResults(plan, results) {
+    return `schema: 1\nplan: ${plan.id}\nresults:\n${results
+        .map((result) => `  - id: ${result.id}\n    status: ${result.status}\n    detail: ${JSON.stringify(result.detail)}`)
+        .join("\n")}\n`;
+}
+function assertPlanGraph(tasks) {
+    const ids = tasks.map(({ id }) => id);
+    if (new Set(ids).size !== ids.length)
+        throw new Error("Orchestration task ids must be unique.");
+    const known = new Set(ids);
+    for (const task of tasks) {
+        if (new Set(task.dependsOn).size !== task.dependsOn.length)
+            throw new Error(`${task.id} dependencies must be unique.`);
+        if (task.dependsOn.includes(task.id))
+            throw new Error(`${task.id} cannot depend on itself.`);
+        const unknown = task.dependsOn.find((dependency) => !known.has(dependency));
+        if (unknown)
+            throw new Error(`${task.id} has an unknown dependency: ${unknown}`);
+    }
+    orchestrationWaves({ schema: 1, id: "validation", tasks });
+}
+function orderedField(line, name) {
+    const value = line.match(new RegExp(`^\\s{4}${name}:\\s*(.*)$`))?.[1]?.trim();
+    if (value === undefined)
+        throw new Error(`Orchestration task field order is invalid: ${name}`);
+    return value;
+}
+function quotedValue(value, name) {
+    if (!value.startsWith('"') || !value.endsWith('"'))
+        throw new Error(`Orchestration field '${name}' must be a JSON string.`);
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed !== "string")
+            throw new Error();
+        return parsed;
+    }
+    catch {
+        throw new Error(`Orchestration field '${name}' must be a valid JSON string.`);
+    }
+}
+function inlineList(value) {
+    if (!/^\[(?:TASK-\d+(?:,\s*TASK-\d+)*)?\]$/.test(value))
+        throw new Error("Orchestration dependencies must be an inline list of task ids.");
+    return value === "[]"
+        ? []
+        : value
+            .slice(1, -1)
+            .split(",")
+            .map((item) => item.trim());
+}
+function safeDetail(value) {
+    return value
+        .replace(/[\r\n\u0085\u2028\u2029]+/g, " ")
+        .trim()
+        .slice(0, 500);
+}
+function isPlanLine(line) {
+    return (/^(?:schema|id): .+$/.test(line) ||
+        line === "tasks:" ||
+        /^\s{2}- id: .+$/.test(line) ||
+        /^\s{4}(?:agent|prompt|depends_on): .+$/.test(line));
+}
+function isControl(value) {
+    const code = value.codePointAt(0) ?? 0;
+    return code <= 31 || code === 127 || code === 133 || code === 8232 || code === 8233;
+}

package/dist/organization-policy.d.ts

@@ -0,0 +1,14 @@
+export type OrganizationPolicy = {
+    schema: 1;
+    name: string;
+    approvedSources: string[];
+    deniedPermissions: string[];
+};
+export type PackagePolicySubject = {
+    provider: string;
+    source: string;
+    permissions: string[];
+};
+export declare function parseOrganizationPolicy(content: string): OrganizationPolicy;
+export declare function serializeOrganizationPolicy(policy: OrganizationPolicy): string;
+export declare function enforceOrganizationPolicy(policy: OrganizationPolicy, subject: PackagePolicySubject): void;

package/dist/organization-policy.js

@@ -0,0 +1,47 @@
+export function parseOrganizationPolicy(content) {
+    const schema = scalar(content, "schema");
+    const name = scalar(content, "name");
+    if (schema !== "1")
+        throw new Error("Organization policy schema must be version 1.");
+    if (!name)
+        throw new Error("Organization policy name is required.");
+    const approvedSources = list(content, "approved_sources");
+    if (!approvedSources.length)
+        throw new Error("Organization policy approved_sources must not be empty.");
+    return {
+        schema: 1,
+        name,
+        approvedSources: [...new Set(approvedSources)].sort(),
+        deniedPermissions: [...new Set(list(content, "denied_permissions"))].sort(),
+    };
+}
+export function serializeOrganizationPolicy(policy) {
+    return `schema: 1\nname: ${policy.name}\napproved_sources: [${policy.approvedSources.join(", ")}]\ndenied_permissions: [${policy.deniedPermissions.join(", ")}]\n`;
+}
+export function enforceOrganizationPolicy(policy, subject) {
+    const candidate = `${subject.provider}:${subject.source}`;
+    const approved = policy.approvedSources.some((pattern) => pattern.endsWith("*") ? candidate.startsWith(pattern.slice(0, -1)) : candidate === pattern);
+    if (!approved)
+        throw new Error(`Package source is not approved by ${policy.name}: ${candidate}`);
+    const denied = subject.permissions.filter((permission) => policy.deniedPermissions.includes(permission));
+    if (denied.length)
+        throw new Error(`Package permissions are denied by ${policy.name}: ${denied.join(", ")}`);
+}
+function scalar(content, key) {
+    const value = content.match(new RegExp(`^${key}:[ \\t]*([^\\r\\n]*)$`, "m"))?.[1]?.trim() ?? "";
+    if (value.length >= 2 &&
+        ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))))
+        return value.slice(1, -1).trim();
+    return value;
+}
+function list(content, key) {
+    const value = scalar(content, key);
+    if (!value.startsWith("[") || !value.endsWith("]"))
+        throw new Error(`Organization policy ${key} must be an inline list.`);
+    return value
+        .slice(1, -1)
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}

package/dist/package-audit.d.ts

@@ -0,0 +1,19 @@
+import type { PackageContract } from "./package-contract.js";
+export type PermissionReview = {
+    allowed: boolean;
+    requested: string[];
+    unapproved: string[];
+};
+export declare const PACKAGE_PERMISSIONS: {
+    readonly "read:repository": "low";
+    readonly "filesystem:read": "low";
+    readonly "filesystem:write": "high";
+    readonly "network:external": "high";
+    readonly "environment:read": "high";
+    readonly "process:execute": "critical";
+};
+export type PackagePermission = keyof typeof PACKAGE_PERMISSIONS;
+export declare function assertKnownPermissions(permissions: string[]): void;
+export declare function reviewPackagePermissions(pkg: PackageContract, approved: string[]): PermissionReview;
+export declare function serializePermissionReview(pkg: PackageContract): string;
+export declare function assertPackagePermissions(pkg: PackageContract, approved: string[]): void;

package/dist/package-audit.js

@@ -0,0 +1,28 @@
+export const PACKAGE_PERMISSIONS = {
+    "read:repository": "low",
+    "filesystem:read": "low",
+    "filesystem:write": "high",
+    "network:external": "high",
+    "environment:read": "high",
+    "process:execute": "critical",
+};
+export function assertKnownPermissions(permissions) {
+    const unknown = permissions.filter((permission) => !Object.prototype.hasOwnProperty.call(PACKAGE_PERMISSIONS, permission));
+    if (unknown.length)
+        throw new Error(`Unknown package permissions: ${unknown.join(", ")}`);
+}
+export function reviewPackagePermissions(pkg, approved) {
+    assertKnownPermissions(pkg.permissions);
+    const unapproved = pkg.permissions.filter((permission) => !approved.includes(permission));
+    return { allowed: unapproved.length === 0, requested: [...pkg.permissions], unapproved };
+}
+export function serializePermissionReview(pkg) {
+    reviewPackagePermissions(pkg, []);
+    const permissions = [...pkg.permissions].sort();
+    return `Package permission review: ${pkg.id}@${pkg.version}\n${permissions.length ? permissions.map((permission) => `- ${permission} (${PACKAGE_PERMISSIONS[permission]})`).join("\n") : "- none"}\nDecision: ${permissions.length ? "explicit approval required" : "no permissions requested"}\n`;
+}
+export function assertPackagePermissions(pkg, approved) {
+    const review = reviewPackagePermissions(pkg, approved);
+    if (!review.allowed)
+        throw new Error(`Package permissions require approval: ${review.unapproved.join(", ")}`);
+}

package/dist/package-contract.d.ts

@@ -0,0 +1,30 @@
+export declare const RESOURCE_TYPES: readonly ["skills", "rules", "agents", "hooks", "templates"];
+export type ResourceType = (typeof RESOURCE_TYPES)[number];
+export type PackageResource = {
+    id: string;
+    version: string;
+    path: string;
+};
+export type PackagePolicy = {
+    id: string;
+    value: string;
+};
+export type PackageContract = {
+    schema: number;
+    id: string;
+    version: string;
+    provider: string;
+    source: string;
+    resources: Record<ResourceType, PackageResource[]>;
+    dependencies: string[];
+    permissions: string[];
+    provenance: {
+        source: string;
+        checksum?: string;
+    };
+    policies?: PackagePolicy[];
+    engines?: Record<string, string>;
+    provides?: Record<ResourceType, string[]>;
+    targets?: string[];
+};
+export declare function validatePackageContract(content: string, resourceExists?: (path: string) => boolean): PackageContract;

package/dist/package-contract.js

@@ -0,0 +1,93 @@
+export const RESOURCE_TYPES = ["skills", "rules", "agents", "hooks", "templates"];
+export function validatePackageContract(content, resourceExists = () => true) {
+    const required = [
+        "schema",
+        "id",
+        "version",
+        "provider",
+        "source",
+        "resources",
+        "dependencies",
+        "permissions",
+        "provenance",
+    ];
+    for (const field of required) {
+        if (!new RegExp(`^${field}:`, "m").test(content))
+            throw new Error(`Package field '${field}' is required.`);
+    }
+    const schema = scalar(content, "schema");
+    if (schema !== "1")
+        throw new Error("Package schema must be version 1.");
+    const resources = Object.fromEntries(RESOURCE_TYPES.map((type) => [type, parseResources(content, type)]));
+    for (const type of RESOURCE_TYPES) {
+        const section = resourceSection(content, type);
+        const entries = section.match(/-\s*\{[^}]*\}/g) ?? [];
+        if (entries.length !== resources[type].length)
+            throw new Error(`Package resource entries in '${type}' require id, version, and path.`);
+        for (const resource of resources[type]) {
+            if (!resourceExists(resource.path))
+                throw new Error(`Package resource path does not exist: ${resource.path}`);
+        }
+    }
+    if (!resources.skills.length &&
+        !resources.rules.length &&
+        !resources.agents.length &&
+        !resources.hooks.length &&
+        !resources.templates.length)
+        throw new Error("Package resources must contain at least one resource.");
+    return {
+        schema: 1,
+        id: scalar(content, "id"),
+        version: scalar(content, "version"),
+        provider: scalar(content, "provider"),
+        source: scalar(content, "source"),
+        resources,
+        dependencies: list(content, "dependencies"),
+        permissions: list(content, "permissions"),
+        provenance: {
+            source: nestedScalar(content, "source") || scalar(content, "source"),
+            ...(nestedScalar(content, "checksum") ? { checksum: nestedScalar(content, "checksum") } : {}),
+        },
+        policies: parsePolicies(content),
+        ...(nestedScalar(content, "ai_workflow")
+            ? { engines: { ai_workflow: nestedScalar(content, "ai_workflow") } }
+            : {}),
+        ...(list(content, "targets").length ? { targets: list(content, "targets") } : {}),
+    };
+}
+function resourceSection(content, type) {
+    return content.match(new RegExp(`^  ${type}:\\n([\\s\\S]*?)(?=^\\w|\\s*$)`, "m"))?.[1] ?? "";
+}
+function parsePolicies(content) {
+    const section = content.match(/policies:\n((?:\s{2}- .*\n?)+)/)?.[1] ?? "";
+    return [...section.matchAll(/id:\s*([^,]+),\s*value:\s*([^ }]+)/g)].map((match) => ({
+        id: match[1].trim(),
+        value: match[2].trim(),
+    }));
+}
+function scalar(content, key) {
+    return (content
+        .match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1]
+        ?.replaceAll('"', "")
+        .trim() ?? "");
+}
+function nestedScalar(content, key) {
+    return (content
+        .match(new RegExp(`^\\s{2,}${key}:\\s*(.+)$`, "m"))?.[1]
+        ?.replaceAll('"', "")
+        .trim() ?? "");
+}
+function list(content, key) {
+    const value = scalar(content, key);
+    return value === "[]"
+        ? []
+        : value
+            .replace(/^\[|\]$/g, "")
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean);
+}
+function parseResources(content, type) {
+    const section = resourceSection(content, type);
+    return [...section.matchAll(/id:\s*([\w-]+), version:\s*([\d.]+), path:\s*([^ }]+)/g)].map((match) => ({ id: match[1], version: match[2], path: match[3] }));
+}

package/dist/package-integrity.d.ts

@@ -0,0 +1,8 @@
+export type PackageProvenance = {
+    checksum: string;
+    signature?: string;
+    signer?: string;
+};
+export type SignatureVerifier = (content: string, signature: string, signer?: string) => boolean;
+export declare function checksumPackage(content: string): string;
+export declare function verifyPackageProvenance(content: string, provenance: PackageProvenance, verifySignature?: SignatureVerifier): void;

package/dist/package-integrity.js

@@ -0,0 +1,15 @@
+import { createHash } from "node:crypto";
+export function checksumPackage(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+export function verifyPackageProvenance(content, provenance, verifySignature) {
+    const actual = checksumPackage(content);
+    if (actual !== provenance.checksum)
+        throw new Error(`Package checksum mismatch: expected ${provenance.checksum}, received ${actual}.`);
+    if (provenance.signature && !verifySignature)
+        throw new Error("Package signature requires a configured verifier.");
+    if (provenance.signature &&
+        verifySignature &&
+        !verifySignature(content, provenance.signature, provenance.signer))
+        throw new Error("Package signature verification failed.");
+}

package/dist/package-updates.d.ts

@@ -0,0 +1,11 @@
+import type { PackageContract } from "./package-contract.js";
+export type UpdateStatus = "update" | "current" | "incompatible" | "conflict";
+export type UpdatePlan = {
+    status: UpdateStatus;
+    reason?: string;
+};
+export declare function compareVersions(left: string, right: string): number;
+export declare function planPackageUpdate(current: {
+    id: string;
+    version: string;
+} | undefined, candidate: PackageContract, target: string, lockedVersions?: Map<string, string>): UpdatePlan;