@aionis/manifest 0.1.1

package/dist/resume.js

@@ -0,0 +1,452 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { RecoverInputKindSchema, RecoverResultSchema, recoverAionisManifestSource, recoverHandoffStoreRequest, recoverPublishedAionisManifest, recoverRuntimeHandoff, } from "./recover.js";
+export const AIONIS_MANIFEST_RESUME_RESULT_VERSION = "aionis_manifest_resume_result_v2";
+export const AIONIS_MANIFEST_RESUME_PRODUCT_PATHS = {
+    guide: "/v1/guide",
+    feedback: "/v1/feedback",
+};
+export const ResumeInputKindSchema = z.enum([
+    ...RecoverInputKindSchema.options,
+    "recover-result",
+]);
+const LowercaseSha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
+export const ProductToolSelectionReceiptSchema = z.object({
+    contract_version: z.literal("aionis_tool_selection_receipt_v1"),
+    decision_id: z.string().min(1),
+    decision_uri: z.string().min(1),
+    run_id: z.string().min(1),
+    selected_tool: z.string().min(1).nullable(),
+    candidates: z.array(z.string().min(1)).min(1),
+    policy_sha256: LowercaseSha256Schema,
+    context_sha256: LowercaseSha256Schema.optional(),
+    rule_evaluation_sha256: LowercaseSha256Schema.optional(),
+    source_rule_ids: z.array(z.string().min(1)),
+    created_at: z.string().min(1),
+}).strict();
+export const ProductGuideResumeRequestSchema = z.object({
+    tenant_id: z.string().min(1).optional(),
+    scope: z.string().min(1).optional(),
+    query_text: z.string().min(1),
+    mode: z.literal("full_power").default("full_power"),
+    run_id: z.string().min(1),
+    context: z.record(z.unknown()),
+    execution_state_v1: z.record(z.unknown()).optional(),
+    execution_packet_v1: z.record(z.unknown()).optional(),
+    tool_candidates: z.array(z.string().min(1)).min(1),
+    tool_strict: z.boolean().default(true),
+    include_shadow: z.boolean().default(false),
+    rules_limit: z.number().int().positive().max(200).default(50),
+    include_packets: z.literal(true).default(true),
+}).strict();
+export const ProductGuideResumePayloadSchema = z.object({
+    contract_version: z.literal("aionis_guide_result_v1"),
+    tenant_id: z.string().min(1),
+    scope: z.string().min(1),
+    consumer_agent_id: z.string().min(1).optional(),
+    guide_trace_id: z.string().min(1),
+    agent_context: z.record(z.unknown()),
+    tool_selection: ProductToolSelectionReceiptSchema.optional(),
+    memory_packet: z.record(z.unknown()).nullable().optional(),
+    guide_packet: z.record(z.unknown()).nullable().optional(),
+    source_map: z.record(z.unknown()),
+}).passthrough();
+export const ProductToolFeedbackResumeRequestSchema = z.object({
+    feedback_kind: z.literal("tool_selection"),
+    tenant_id: z.string().min(1),
+    scope: z.string().min(1),
+    actor: z.string().min(1).optional(),
+    guide_trace_id: z.string().min(1),
+    decision_id: z.string().min(1),
+    run_id: z.string().min(1),
+    selected_tool: z.string().min(1),
+    candidates: z.array(z.string().min(1)).min(1),
+    outcome: z.enum(["positive", "negative", "neutral"]),
+    context: z.record(z.unknown()),
+    include_shadow: z.boolean().default(false),
+    rules_limit: z.number().int().positive().max(200).default(50),
+    target: z.enum(["tool", "all"]).default("tool"),
+    note: z.string().min(1).optional(),
+    input_text: z.string().min(1),
+}).strict();
+export const ProductToolFeedbackResumePayloadSchema = z.object({
+    contract_version: z.literal("aionis_feedback_result_v1"),
+    tenant_id: z.string().min(1),
+    scope: z.string().min(1),
+    product_action: z.literal("feedback"),
+    feedback_kind: z.literal("tool_selection"),
+    tool_selection: ProductToolSelectionReceiptSchema,
+    feedback_result: z.object({
+        updated_rules: z.number().int().nonnegative(),
+        decision_id: z.string().min(1),
+    }).passthrough(),
+    run_lifecycle: z.object({
+        run_id: z.string().min(1),
+        lifecycle: z.object({
+            status: z.string().min(1),
+        }).passthrough(),
+    }).passthrough(),
+    source_map: z.record(z.unknown()),
+}).passthrough();
+export const ResumeSummarySchema = z.object({
+    selected_tool: z.string().nullable(),
+    decision_id: z.string().nullable(),
+    run_id: z.string().min(1),
+    resume_state: z.enum(["inspection_only", "feedback_applied", "lifecycle_advanced"]),
+    feedback_written: z.boolean(),
+    feedback_outcome: z.enum(["positive", "negative", "neutral"]).nullable(),
+    pre_feedback_run_status: z.string().nullable(),
+    post_feedback_run_status: z.string().nullable(),
+    lifecycle_transition: z.string().nullable(),
+    lifecycle_advanced: z.boolean(),
+    feedback_updated_rules: z.number().int().nonnegative().nullable(),
+});
+export const ResumeResultSchema = z.object({
+    resume_result_version: z.literal(AIONIS_MANIFEST_RESUME_RESULT_VERSION),
+    resumed_at: z.string().min(1),
+    base_url: z.string().min(1),
+    input_kind: ResumeInputKindSchema,
+    source_doc_id: z.string().min(1).nullable(),
+    source_doc_version: z.string().min(1).nullable(),
+    run_id: z.string().min(1),
+    resume_summary: ResumeSummarySchema,
+    recover_result: RecoverResultSchema.nullable(),
+    guide_request: ProductGuideResumeRequestSchema,
+    guide_response: z.object({
+        status: z.number().int().nonnegative(),
+        request_id: z.string().nullable(),
+        data: ProductGuideResumePayloadSchema,
+    }),
+    tool_feedback_request: ProductToolFeedbackResumeRequestSchema.nullable(),
+    tool_feedback_response: z.object({
+        status: z.number().int().nonnegative(),
+        request_id: z.string().nullable(),
+        data: ProductToolFeedbackResumePayloadSchema,
+    }).nullable(),
+});
+function joinUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function withTimeout(timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return {
+        signal: controller.signal,
+        cancel: () => clearTimeout(timer),
+    };
+}
+async function parseResponseBody(res) {
+    const contentType = (res.headers.get("content-type") ?? "").toLowerCase();
+    if (contentType.includes("application/json"))
+        return res.json();
+    const text = await res.text();
+    return text.length > 0 ? text : null;
+}
+function buildHeaders(args) {
+    const headers = { "content-type": "application/json" };
+    if (args.apiKey)
+        headers["x-api-key"] = args.apiKey;
+    if (args.adminToken)
+        headers["x-admin-token"] = args.adminToken;
+    if (args.authBearer) {
+        headers.authorization = args.authBearer.toLowerCase().startsWith("bearer ")
+            ? args.authBearer
+            : `Bearer ${args.authBearer}`;
+    }
+    if (args.requestId)
+        headers["x-request-id"] = args.requestId;
+    return headers;
+}
+function extractRequestId(headers) {
+    return headers.get("x-request-id") ?? headers.get("request-id") ?? null;
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0)
+            return value;
+    }
+    return undefined;
+}
+function maybeRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function maybeRecords(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter((entry) => !!entry && typeof entry === "object" && !Array.isArray(entry));
+}
+function readString(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function readNonNegativeInt(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+function buildResumeContext(recoverResult) {
+    const recovered = recoverResult.recover_response.data;
+    return {
+        intent: "doc_resume",
+        workflow_kind: "aionis_manifest",
+        handoff_anchor: recovered.anchor,
+        ...(recovered.control_profile_v1 ? { control_profile_v1: recovered.control_profile_v1 } : {}),
+        ...(recovered.execution_result_summary
+            ? { execution_result_summary: recovered.execution_result_summary }
+            : {}),
+        ...(maybeRecords(recovered.execution_artifacts)
+            ? { execution_artifacts: maybeRecords(recovered.execution_artifacts) }
+            : {}),
+        ...(maybeRecords(recovered.execution_evidence)
+            ? { execution_evidence: maybeRecords(recovered.execution_evidence) }
+            : {}),
+    };
+}
+export function buildProductGuideResumeRequest(args) {
+    const recovered = args.recoverResult.recover_response.data;
+    const executionReady = maybeRecord(recovered.execution_ready_handoff);
+    const handoff = maybeRecord(recovered.handoff);
+    const executionState = maybeRecord(recovered.execution_state_v1);
+    return ProductGuideResumeRequestSchema.parse({
+        tenant_id: args.tenantId ?? recovered.tenant_id,
+        scope: args.scope ?? recovered.scope,
+        query_text: args.queryText ?? firstString(executionReady?.next_action, executionState?.task_brief, handoff?.summary, recovered.anchor) ?? "resume recovered handoff",
+        mode: "full_power",
+        run_id: args.runId ?? randomUUID(),
+        context: buildResumeContext(args.recoverResult),
+        execution_state_v1: executionState ?? undefined,
+        execution_packet_v1: maybeRecord(recovered.execution_packet_v1) ?? undefined,
+        tool_candidates: args.candidates,
+        tool_strict: args.strict ?? true,
+        include_shadow: args.includeShadow ?? false,
+        rules_limit: args.rulesLimit ?? 50,
+        include_packets: true,
+    });
+}
+export function buildProductToolFeedbackResumeRequest(args) {
+    const receipt = args.guideResponse.tool_selection;
+    if (!receipt)
+        throw new Error("Guide did not expose a tool-selection receipt for feedback.");
+    const selectedTool = args.selectedTool ?? receipt.selected_tool;
+    if (!selectedTool)
+        throw new Error("Guide tool-selection receipt did not select a tool.");
+    return ProductToolFeedbackResumeRequestSchema.parse({
+        feedback_kind: "tool_selection",
+        tenant_id: args.guideResponse.tenant_id,
+        scope: args.guideResponse.scope,
+        actor: args.actor,
+        guide_trace_id: args.guideResponse.guide_trace_id,
+        decision_id: receipt.decision_id,
+        run_id: receipt.run_id,
+        selected_tool: selectedTool,
+        candidates: receipt.candidates,
+        outcome: args.outcome,
+        context: args.guideRequest.context,
+        include_shadow: args.guideRequest.include_shadow,
+        rules_limit: args.guideRequest.rules_limit,
+        target: args.target ?? "tool",
+        note: args.note,
+        input_text: args.inputText ?? args.note ?? args.guideRequest.query_text,
+    });
+}
+async function postJson(args) {
+    const timeout = withTimeout(args.timeoutMs ?? 10_000);
+    try {
+        const res = await fetch(joinUrl(args.baseUrl, args.path), {
+            method: "POST",
+            headers: buildHeaders(args),
+            body: JSON.stringify(args.body),
+            signal: timeout.signal,
+        });
+        const body = await parseResponseBody(res);
+        if (!res.ok) {
+            const message = body && typeof body === "object" && "message" in body && typeof body.message === "string"
+                ? String(body.message)
+                : `${args.path} failed with status ${res.status}`;
+            throw new Error(message);
+        }
+        return { status: res.status, request_id: extractRequestId(res.headers), body };
+    }
+    finally {
+        timeout.cancel();
+    }
+}
+export async function resumeRecoveredAionisManifest(args) {
+    const recoverResult = RecoverResultSchema.parse(args.recoverResult);
+    const guideRequest = buildProductGuideResumeRequest({
+        recoverResult,
+        queryText: args.queryText,
+        runId: args.runId,
+        tenantId: args.tenantId,
+        scope: args.scope,
+        candidates: args.candidates,
+        strict: args.strict,
+        includeShadow: args.includeShadow,
+        rulesLimit: args.rulesLimit,
+    });
+    const guideWrite = await postJson({
+        baseUrl: args.baseUrl,
+        path: AIONIS_MANIFEST_RESUME_PRODUCT_PATHS.guide,
+        body: guideRequest,
+        timeoutMs: args.timeoutMs,
+        apiKey: args.apiKey,
+        authBearer: args.authBearer,
+        adminToken: args.adminToken,
+        requestId: args.requestId,
+    });
+    const guideResponse = ProductGuideResumePayloadSchema.parse(guideWrite.body);
+    let toolFeedbackRequest = null;
+    let toolFeedbackResponse = null;
+    if (args.feedbackOutcome) {
+        toolFeedbackRequest = buildProductToolFeedbackResumeRequest({
+            guideRequest,
+            guideResponse,
+            outcome: args.feedbackOutcome,
+            actor: args.feedbackActor,
+            note: args.feedbackNote,
+            inputText: args.feedbackInputText,
+            target: args.feedbackTarget,
+            selectedTool: args.feedbackSelectedTool,
+        });
+        const feedbackWrite = await postJson({
+            baseUrl: args.baseUrl,
+            path: AIONIS_MANIFEST_RESUME_PRODUCT_PATHS.feedback,
+            body: toolFeedbackRequest,
+            timeoutMs: args.timeoutMs,
+            apiKey: args.apiKey,
+            authBearer: args.authBearer,
+            adminToken: args.adminToken,
+            requestId: args.requestId,
+        });
+        toolFeedbackResponse = {
+            status: feedbackWrite.status,
+            request_id: feedbackWrite.request_id,
+            data: ProductToolFeedbackResumePayloadSchema.parse(feedbackWrite.body),
+        };
+    }
+    const receipt = guideResponse.tool_selection ?? null;
+    const preStatus = receipt ? "decision_recorded" : null;
+    const runLifecycle = maybeRecord(toolFeedbackResponse?.data.run_lifecycle);
+    const postStatus = readString(maybeRecord(runLifecycle?.lifecycle), "status");
+    const lifecycleTransition = preStatus && postStatus && preStatus !== postStatus
+        ? `${preStatus} -> ${postStatus}`
+        : null;
+    const feedbackWritten = toolFeedbackResponse !== null;
+    const lifecycleAdvanced = lifecycleTransition !== null;
+    const feedbackResult = maybeRecord(toolFeedbackResponse?.data.feedback_result);
+    const resumeSummary = ResumeSummarySchema.parse({
+        selected_tool: receipt?.selected_tool ?? null,
+        decision_id: receipt?.decision_id ?? null,
+        run_id: receipt?.run_id ?? guideRequest.run_id,
+        resume_state: !feedbackWritten ? "inspection_only" : lifecycleAdvanced ? "lifecycle_advanced" : "feedback_applied",
+        feedback_written: feedbackWritten,
+        feedback_outcome: args.feedbackOutcome ?? null,
+        pre_feedback_run_status: preStatus,
+        post_feedback_run_status: postStatus,
+        lifecycle_transition: lifecycleTransition,
+        lifecycle_advanced: lifecycleAdvanced,
+        feedback_updated_rules: readNonNegativeInt(feedbackResult, "updated_rules"),
+    });
+    return ResumeResultSchema.parse({
+        resume_result_version: AIONIS_MANIFEST_RESUME_RESULT_VERSION,
+        resumed_at: args.resumedAt ?? new Date().toISOString(),
+        base_url: args.baseUrl,
+        input_kind: args.inputKind ?? "recover-result",
+        source_doc_id: recoverResult.source_doc_id,
+        source_doc_version: recoverResult.source_doc_version,
+        run_id: resumeSummary.run_id,
+        resume_summary: resumeSummary,
+        recover_result: recoverResult,
+        guide_request: guideRequest,
+        guide_response: {
+            status: guideWrite.status,
+            request_id: guideWrite.request_id,
+            data: guideResponse,
+        },
+        tool_feedback_request: toolFeedbackRequest,
+        tool_feedback_response: toolFeedbackResponse,
+    });
+}
+export async function resumePublishedAionisManifest(args) {
+    const recoverResult = await recoverPublishedAionisManifest({
+        publishResult: args.publishResult,
+        inputKind: "publish-result",
+        baseUrl: args.baseUrl,
+        timeoutMs: args.timeoutMs,
+        apiKey: args.apiKey,
+        authBearer: args.authBearer,
+        adminToken: args.adminToken,
+        requestId: args.requestId,
+        scope: args.scope,
+        tenantId: args.tenantId,
+    });
+    return resumeRecoveredAionisManifest({ ...args, recoverResult, inputKind: "publish-result" });
+}
+export async function resumeRuntimeHandoff(args) {
+    const recoverResult = await recoverRuntimeHandoff({
+        runtimeHandoff: args.runtimeHandoff,
+        baseUrl: args.baseUrl,
+        timeoutMs: args.timeoutMs,
+        apiKey: args.apiKey,
+        authBearer: args.authBearer,
+        adminToken: args.adminToken,
+        requestId: args.requestId,
+        scope: args.scope,
+        tenantId: args.tenantId,
+        actor: args.actor,
+        memoryLane: args.memoryLane,
+        title: args.title,
+        tags: args.tags,
+        repoRoot: args.repoRoot,
+        filePath: args.filePath,
+        symbol: args.symbol,
+        handoffKind: args.handoffKind,
+        limit: args.limit,
+    });
+    return resumeRecoveredAionisManifest({ ...args, recoverResult, inputKind: "runtime-handoff" });
+}
+export async function resumeHandoffStoreRequest(args) {
+    const recoverResult = await recoverHandoffStoreRequest({
+        handoffStoreRequest: args.handoffStoreRequest,
+        baseUrl: args.baseUrl,
+        timeoutMs: args.timeoutMs,
+        apiKey: args.apiKey,
+        authBearer: args.authBearer,
+        adminToken: args.adminToken,
+        requestId: args.requestId,
+        scope: args.scope,
+        tenantId: args.tenantId,
+        repoRoot: args.repoRoot,
+        filePath: args.filePath,
+        symbol: args.symbol,
+        handoffKind: args.handoffKind,
+        limit: args.limit,
+    });
+    return resumeRecoveredAionisManifest({ ...args, recoverResult, inputKind: "handoff-store-request" });
+}
+export async function resumeAionisManifestSource(args) {
+    const recoverResult = await recoverAionisManifestSource({
+        source: args.source,
+        inputPath: args.inputPath,
+        baseUrl: args.baseUrl,
+        timeoutMs: args.timeoutMs,
+        apiKey: args.apiKey,
+        authBearer: args.authBearer,
+        adminToken: args.adminToken,
+        requestId: args.requestId,
+        scope: args.scope,
+        tenantId: args.tenantId,
+        actor: args.actor,
+        memoryLane: args.memoryLane,
+        title: args.title,
+        tags: args.tags,
+        repoRoot: args.repoRoot,
+        filePath: args.filePath,
+        symbol: args.symbol,
+        currentStage: args.currentStage,
+        activeRole: args.activeRole,
+        handoffKind: args.handoffKind,
+        limit: args.limit,
+        allowCompileErrors: args.allowCompileErrors,
+    });
+    return resumeRecoveredAionisManifest({ ...args, recoverResult, inputKind: "source" });
+}

package/dist/run-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/run-cli.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import process from "node:process";
+import { AionisManifestExecutionResultSchema, AionisManifestRunInputKindSchema } from "./contracts.js";
+import { AionisManifestRunError, runAionisManifest } from "./run.js";
+class CliUsageError extends Error {
+}
+function printHelp() {
+    process.stdout.write([
+        "run-aionis-manifest",
+        "",
+        "Usage:",
+        "  run-aionis-manifest <input-file> [--input-kind source|compile-envelope|plan] --registry <path> [--out <path>] [--compact]",
+        "",
+        "Options:",
+        "  --input-kind <kind>   Select source, compile-envelope, or plan input. Default: source",
+        "  --registry <path>     Path to a module registry JSON file",
+        "  --out <path>          Write output JSON to a file instead of stdout",
+        "  --compact             Print compact JSON instead of pretty JSON",
+        "  --help                Show this message",
+        "",
+    ].join("\n"));
+}
+function parseArgs(argv) {
+    let inputPath = null;
+    const flags = {
+        inputKind: "source",
+        registry: null,
+        out: null,
+        compact: false,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (token === "--help" || token === "-h") {
+            flags.help = true;
+            continue;
+        }
+        if (token === "--compact") {
+            flags.compact = true;
+            continue;
+        }
+        if (token === "--input-kind") {
+            const next = argv[i + 1];
+            if (!next)
+                throw new CliUsageError("Missing value for --input-kind.");
+            flags.inputKind = AionisManifestRunInputKindSchema.parse(next);
+            i += 1;
+            continue;
+        }
+        if (token === "--registry") {
+            const next = argv[i + 1];
+            if (!next)
+                throw new CliUsageError("Missing value for --registry.");
+            flags.registry = next;
+            i += 1;
+            continue;
+        }
+        if (token === "--out") {
+            const next = argv[i + 1];
+            if (!next)
+                throw new CliUsageError("Missing value for --out.");
+            flags.out = next;
+            i += 1;
+            continue;
+        }
+        if (token.startsWith("--")) {
+            throw new CliUsageError(`Unknown flag '${token}'.`);
+        }
+        if (inputPath)
+            throw new CliUsageError("Only one input file may be provided.");
+        inputPath = token;
+    }
+    return { inputPath, flags };
+}
+async function writeOutput(pathname, contents) {
+    await mkdir(dirname(pathname), { recursive: true });
+    await writeFile(pathname, contents, "utf8");
+}
+async function main() {
+    const { inputPath, flags } = parseArgs(process.argv.slice(2));
+    if (flags.help) {
+        printHelp();
+        return;
+    }
+    if (!inputPath)
+        throw new CliUsageError("An input file path is required.");
+    if (!flags.registry)
+        throw new CliUsageError("A --registry path is required.");
+    const result = await runAionisManifest({
+        inputPath,
+        inputKind: flags.inputKind,
+        registryPath: flags.registry,
+    });
+    const parsed = AionisManifestExecutionResultSchema.parse(result);
+    const rendered = flags.compact ? JSON.stringify(parsed) : `${JSON.stringify(parsed, null, 2)}\n`;
+    if (flags.out) {
+        await writeOutput(resolve(process.cwd(), flags.out), rendered);
+    }
+    else {
+        process.stdout.write(rendered);
+    }
+    if (parsed.status === "failed") {
+        process.exitCode = 1;
+    }
+}
+main().catch((error) => {
+    if (error instanceof CliUsageError || error instanceof AionisManifestRunError) {
+        process.stderr.write(`${error.message}\n`);
+        if (error instanceof CliUsageError)
+            printHelp();
+        process.exitCode = error instanceof CliUsageError ? 2 : 1;
+        return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/dist/run.d.ts

@@ -0,0 +1,9 @@
+import type { AionisManifestRunInputKind, ExecutionResultV1 } from "./execute/types.js";
+export declare class AionisManifestRunError extends Error {
+}
+export declare function runAionisManifest(args: {
+    inputPath: string;
+    inputKind?: AionisManifestRunInputKind;
+    registryPath: string;
+    cwd?: string;
+}): Promise<ExecutionResultV1>;

package/dist/run.js

@@ -0,0 +1,43 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { compileAionisManifest } from "./compile.js";
+import { validateCompileEnvelope, ExecutionPlanSchema } from "./contracts.js";
+import { executeExecutionPlan } from "./execute.js";
+import { createModuleRegistryRuntimeFromFile } from "./registry/loadModuleRegistry.js";
+export class AionisManifestRunError extends Error {
+}
+function resolvePath(cwd, targetPath) {
+    return path.resolve(cwd ?? process.cwd(), targetPath);
+}
+async function loadJsonFile(resolvedPath) {
+    return JSON.parse(await readFile(resolvedPath, "utf8"));
+}
+function resolveInputKind(inputKind) {
+    return inputKind ?? "source";
+}
+export async function runAionisManifest(args) {
+    const inputKind = resolveInputKind(args.inputKind);
+    const resolvedInputPath = resolvePath(args.cwd, args.inputPath);
+    const resolvedRegistryPath = resolvePath(args.cwd, args.registryPath);
+    const runtime = await createModuleRegistryRuntimeFromFile({
+        registryPath: resolvedRegistryPath,
+    });
+    switch (inputKind) {
+        case "source": {
+            const source = await readFile(resolvedInputPath, "utf8");
+            const result = compileAionisManifest(source);
+            return executeExecutionPlan(result.plan, { runtime });
+        }
+        case "compile-envelope": {
+            const envelope = validateCompileEnvelope(await loadJsonFile(resolvedInputPath));
+            if (!envelope.artifacts.plan) {
+                throw new AionisManifestRunError(`Compile envelope '${resolvedInputPath}' does not contain a plan artifact. Re-run compile-aionis-manifest with --emit all or --emit plan.`);
+            }
+            return executeExecutionPlan(envelope.artifacts.plan, { runtime });
+        }
+        case "plan": {
+            const plan = ExecutionPlanSchema.parse(await loadJsonFile(resolvedInputPath));
+            return executeExecutionPlan(plan, { runtime });
+        }
+    }
+}

package/dist/runtime-handoff-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};