@aionis/sdk 0.1.1 → 0.1.6

package/dist/index.js

@@ -41,6 +41,351 @@ function rehydrateHintMemoryIds(value) {
         .map((entry) => asRecord(entry)?.memory_id)
         .filter((entry) => typeof entry === "string" && entry.length > 0);
 }
+function rehydrateHintArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const record = asRecord(entry);
+        const memoryId = record?.memory_id;
+        if (!record || typeof memoryId !== "string" || memoryId.length === 0)
+            return [];
+        const reason = typeof record.reason === "string" && record.reason.length > 0 ? record.reason : undefined;
+        return [{
+                memory_id: memoryId,
+                ...(reason ? { reason } : {}),
+                required: record.required === undefined ? true : record.required !== false,
+            }];
+    });
+}
+function commandPostureArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const record = asRecord(entry);
+        if (!record)
+            return [];
+        const posture = record.posture;
+        const surface = record.surface;
+        const memoryId = record.memory_id;
+        const instruction = record.instruction;
+        const reason = record.reason;
+        if (!isCommandPostureKind(posture)
+            || !isCommandPostureSurface(surface)
+            || typeof memoryId !== "string"
+            || memoryId.length === 0
+            || typeof instruction !== "string"
+            || instruction.length === 0
+            || typeof reason !== "string"
+            || reason.length === 0) {
+            return [];
+        }
+        return [{
+                posture,
+                surface,
+                memory_id: memoryId,
+                instruction,
+                reason,
+                target_files: stringArray(record.target_files),
+            }];
+    });
+}
+function isRouteContractSource(value) {
+    return value === "target_files"
+        || value === "should_continue"
+        || value === "inspect_first"
+        || value === "must_not";
+}
+function routeContractTargetArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const record = asRecord(entry);
+        if (!record || typeof record.target !== "string" || record.target.length === 0 || !isRouteContractSource(record.source)) {
+            return [];
+        }
+        const sourceMemoryId = typeof record.source_memory_id === "string" && record.source_memory_id.length > 0
+            ? record.source_memory_id
+            : undefined;
+        const reason = typeof record.reason === "string" && record.reason.length > 0 ? record.reason : undefined;
+        return [{
+                target: record.target,
+                ...(sourceMemoryId ? { source_memory_id: sourceMemoryId } : {}),
+                source: record.source,
+                ...(reason ? { reason } : {}),
+            }];
+    });
+}
+function routeContractActiveTargetArray(value) {
+    const records = Array.isArray(value) ? value : [];
+    return routeContractTargetArray(records).map((entry, index) => {
+        const record = asRecord(records[index]);
+        return {
+            ...entry,
+            artifact_status: record?.artifact_status === "may_be_absent" ? "may_be_absent" : "unknown",
+            missing_policy: "restore_or_create_if_task_consistent_or_rehydrate",
+        };
+    });
+}
+function routeContractPendingArtifactArray(value) {
+    const records = Array.isArray(value) ? value : [];
+    return routeContractTargetArray(records).map((entry, index) => {
+        const record = asRecord(records[index]);
+        const actions = stringArray(record?.allowed_actions).filter((action) => action === "create" || action === "restore" || action === "rehydrate" || action === "report_conflict");
+        const preferred = stringArray(record?.preferred_action_order).filter((action) => action === "create" || action === "restore" || action === "rehydrate" || action === "report_conflict");
+        return {
+            ...entry,
+            status: "unknown_until_host_observation",
+            when: "if_active_target_is_missing",
+            allowed_actions: actions.length > 0 ? actions : ["create", "restore", "rehydrate", "report_conflict"],
+            preferred_action_order: preferred.length > 0 ? preferred : ["create", "restore", "rehydrate", "report_conflict"],
+            terminal_inspect_allowed: false,
+        };
+    });
+}
+function routeContractEvidenceSourceArray(value) {
+    return routeContractTargetArray(value).map((entry) => ({
+        ...entry,
+        evidence_use: "reference_only",
+        direction_policy: "must_not_be_primary_route",
+    }));
+}
+function routeContractBlockedRouteArray(value) {
+    return routeContractTargetArray(value).map((entry) => ({
+        ...entry,
+        direction_policy: "blocked_route",
+        evidence_use: "counter_evidence_only",
+    }));
+}
+function routeContractActionPolicy(value) {
+    const record = asRecord(value);
+    const preferred = stringArray(record?.missing_active_target_preferred_order).filter((action) => action === "create" || action === "restore" || action === "rehydrate" || action === "report_conflict");
+    return {
+        missing_active_target_preferred_order: preferred.length > 0 ? preferred : ["create", "restore", "rehydrate", "report_conflict"],
+        terminal_inspect_allowed: false,
+        reference_fallback_requires: "explicit_raw_evidence_or_operator_confirmation",
+    };
+}
+function routeContractMemoryIds(value) {
+    const contract = asRecord(value);
+    if (!contract)
+        return [];
+    const rows = [
+        ...routeContractTargetArray(contract.active_targets),
+        ...routeContractTargetArray(contract.pending_artifacts),
+        ...routeContractTargetArray(contract.reference_only_targets),
+        ...routeContractTargetArray(contract.blocked_direction_targets),
+        ...routeContractTargetArray(contract.evidence_sources),
+        ...routeContractTargetArray(contract.blocked_routes),
+    ];
+    return rows
+        .map((entry) => entry.source_memory_id)
+        .filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((entry) => entry.length > 0)));
+}
+function guideTraceId(value) {
+    const entry = asRecord(value)?.guide_trace_id;
+    return typeof entry === "string" && entry.length > 0 ? entry : null;
+}
+function safeAgentPromptFromGuide(guide) {
+    try {
+        return agentPromptFromGuide(guide);
+    }
+    catch {
+        return "";
+    }
+}
+function receiptFromGuideTrace(guide) {
+    const guideRecord = asRecord(guide);
+    const candidates = [
+        asRecord(asRecord(guideRecord?.memory_decision_trace)?.memory_use_receipt),
+        asRecord(guideRecord?.memory_use_receipt),
+        asRecord(asRecord(guideRecord?.agent_context)?.memory_use_receipt),
+    ];
+    const receipt = candidates.find((entry) => entry?.contract_version === "aionis_memory_use_receipt_v1");
+    return receipt ? receipt : null;
+}
+function decisionSummariesFromSurfaces(input) {
+    const rows = [];
+    const seen = new Set();
+    const push = (entry) => {
+        if (seen.has(entry.memory_id))
+            return;
+        seen.add(entry.memory_id);
+        rows.push(entry);
+    };
+    for (const memoryId of input.useNow) {
+        push({
+            memory_id: memoryId,
+            agent_surface: "use_now",
+            decision_kind: "used",
+            actionable: true,
+            reason_codes: ["agent_context.use_now_memory_ids"],
+        });
+    }
+    for (const memoryId of input.inspect) {
+        push({
+            memory_id: memoryId,
+            agent_surface: "inspect_before_use",
+            decision_kind: "downgraded",
+            actionable: false,
+            reason_codes: ["agent_context.inspect_before_use_memory_ids"],
+        });
+    }
+    for (const memoryId of input.doNotUse) {
+        push({
+            memory_id: memoryId,
+            agent_surface: "do_not_use",
+            decision_kind: "blocked",
+            actionable: false,
+            reason_codes: ["agent_context.do_not_use_memory_ids"],
+        });
+    }
+    for (const memoryId of input.rehydrate) {
+        push({
+            memory_id: memoryId,
+            agent_surface: "rehydrate",
+            decision_kind: "rehydrate",
+            actionable: false,
+            reason_codes: ["agent_context.rehydrate_hints"],
+        });
+    }
+    return rows;
+}
+function generatedMemoryUseReceipt(guide) {
+    const context = asRecord(agentContextFromGuide(guide));
+    const useNow = uniqueStrings(stringArray(context?.use_now_memory_ids));
+    const inspect = uniqueStrings(stringArray(context?.inspect_before_use_memory_ids));
+    const doNotUse = uniqueStrings(stringArray(context?.do_not_use_memory_ids));
+    const rehydrate = uniqueStrings(rehydrateHintMemoryIds(context?.rehydrate_hints));
+    const exposed = uniqueStrings([
+        ...stringArray(context?.memory_ids),
+        ...useNow,
+        ...inspect,
+        ...doNotUse,
+        ...rehydrate,
+        ...commandPostureArray(context?.command_posture).map((entry) => entry.memory_id),
+        ...routeContractMemoryIds(context?.route_contract),
+    ]);
+    const prompt = safeAgentPromptFromGuide(guide);
+    return {
+        contract_version: "aionis_memory_use_receipt_v1",
+        intended_use: "memory_use_audit",
+        agent_prompt_included: false,
+        runtime_mutation: false,
+        guide_trace_id: guideTraceId(guide),
+        history_used: exposed.length > 0,
+        actionable_history_used: useNow.length > 0,
+        prompt_char_count: prompt.length,
+        exposed_memory_ids: exposed,
+        use_now_memory_ids: useNow,
+        inspect_before_use_memory_ids: inspect,
+        do_not_use_memory_ids: doNotUse,
+        rehydrate_memory_ids: rehydrate,
+        attributed_memory_ids: [],
+        unattributed_recalled_memory_ids: [],
+        read_only_signal_memory_ids: uniqueStrings([...inspect, ...doNotUse, ...rehydrate]),
+        decision_summaries: decisionSummariesFromSurfaces({ useNow, inspect, doNotUse, rehydrate }),
+        risk_flags: stringArray(asRecord(context?.risk)?.reasons),
+        summary: useNow.length > 0
+            ? "Aionis exposed adjudicated actionable execution memory."
+            : exposed.length > 0
+                ? "Aionis exposed adjudicated non-actionable memory surfaces."
+                : "Aionis did not expose reusable memory for this guide.",
+    };
+}
+function targetList(rows) {
+    return uniqueStrings(rows.map((entry) => entry.target));
+}
+function repoPresenceMap(state) {
+    const out = new Map();
+    for (const target of state?.existing_files ?? [])
+        out.set(target, true);
+    for (const target of state?.missing_files ?? [])
+        out.set(target, false);
+    for (const entry of state?.files ?? [])
+        out.set(entry.target, entry.exists);
+    return out;
+}
+function truncateText(text, maxChars) {
+    if (maxChars <= 0)
+        return "";
+    if (text.length <= maxChars)
+        return text;
+    const marker = "\n...[truncated by Aionis SDK context budget]...";
+    if (maxChars <= marker.length)
+        return marker.slice(0, maxChars);
+    return `${text.slice(0, maxChars - marker.length).trimEnd()}${marker}`;
+}
+function defaultExecutionPromptBudget(profile) {
+    switch (profile) {
+        case "compact": return 6_000;
+        case "high_recall": return 24_000;
+        case "balanced": return 12_000;
+    }
+}
+function taskLines(task) {
+    if (!task)
+        return [];
+    if (typeof task === "string")
+        return [`- ${task}`];
+    return [
+        task.task_signature ? `- task_signature: ${task.task_signature}` : "",
+        task.run_id ? `- run_id: ${task.run_id}` : "",
+        task.query_text ? `- query: ${task.query_text}` : "",
+        task.goal ? `- goal: ${task.goal}` : "",
+    ].filter((entry) => entry.length > 0);
+}
+function bulletLines(values, empty) {
+    return values.length > 0 ? values.map((entry) => `- ${entry}`) : [`- ${empty}`];
+}
+function postureLines(rows, posture, empty) {
+    const filtered = rows.filter((entry) => entry.posture === posture);
+    if (filtered.length === 0)
+        return [`- ${empty}`];
+    return filtered.map((entry) => {
+        const targets = entry.target_files.length > 0 ? ` targets=${entry.target_files.join(", ")}` : "";
+        return `- ${entry.memory_id}: ${entry.instruction} (${entry.reason})${targets}`;
+    });
+}
+function rehydrateRequestsFromGuide(guide) {
+    const context = asRecord(agentContextFromGuide(guide));
+    const fromHints = rehydrateHintArray(context?.rehydrate_hints);
+    const fromPosture = commandPostureArray(context?.command_posture)
+        .filter((entry) => entry.posture === "rehydrate_first")
+        .map((entry) => ({
+        memory_id: entry.memory_id,
+        reason: entry.reason || entry.instruction,
+        required: true,
+    }));
+    const byId = new Map();
+    for (const entry of [...fromHints, ...fromPosture]) {
+        const previous = byId.get(entry.memory_id);
+        byId.set(entry.memory_id, {
+            memory_id: entry.memory_id,
+            reason: previous?.reason ?? entry.reason,
+            required: (previous?.required ?? false) || entry.required,
+        });
+    }
+    return Array.from(byId.values());
+}
+function isCommandPostureKind(value) {
+    return value === "must_not"
+        || value === "should_continue"
+        || value === "inspect_first"
+        || value === "rehydrate_first"
+        || value === "optional_context";
+}
+function isCommandPostureSurface(value) {
+    return value === "current"
+        || value === "procedure"
+        || value === "use_now"
+        || value === "inspect_before_use"
+        || value === "do_not_use"
+        || value === "rehydrate"
+        || value === "context";
+}
 function rememberNodeType(kind) {
     switch (kind) {
         case "preference": return "self_model";
@@ -92,6 +437,157 @@ function rememberBody(body) {
         }),
     });
 }
+function requiredString(value, message) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        throw new Error(message);
+    return trimmed;
+}
+function executionMemoryLane(input) {
+    if (input.memory_lane)
+        return input.memory_lane;
+    return input.team_id?.trim() ? "shared" : "private";
+}
+function executionResultSummary(input) {
+    if (!input.outcome || input.outcome === "unknown")
+        return undefined;
+    return stripUndefined({
+        status: input.outcome === "succeeded" ? "passed" : input.outcome,
+        summary: input.summary,
+        evidence_refs: input.evidence_ref ? [input.evidence_ref] : undefined,
+    });
+}
+function executionFeedbackOutcome(input) {
+    if (input.feedback_outcome)
+        return input.feedback_outcome;
+    if (input.outcome === "succeeded")
+        return "positive";
+    if (input.outcome === "failed" || input.outcome === "blocked" || input.outcome === "interrupted")
+        return "negative";
+    return "neutral";
+}
+function executionVerifierStatus(input) {
+    if (input.verifier_status)
+        return input.verifier_status;
+    if (input.outcome === "succeeded")
+        return "passed";
+    if (input.outcome === "failed" || input.outcome === "blocked" || input.outcome === "interrupted")
+        return "failed";
+    return "unknown";
+}
+function executionToolStatus(input) {
+    if (input.tool_status)
+        return input.tool_status;
+    if (input.outcome === "succeeded")
+        return "succeeded";
+    if (input.outcome === "failed" || input.outcome === "blocked" || input.outcome === "interrupted")
+        return "failed";
+    return "unknown";
+}
+function executionAgentId(input) {
+    return requiredString(input.agent_id, "Aionis execution helper requires agent_id.");
+}
+function executionRole(input) {
+    return input.role ?? "agent";
+}
+function executionScopeOptions(input) {
+    return stripUndefined({
+        tenant_id: input.tenant_id,
+        scope: input.scope,
+    });
+}
+function executionObserveBase(input) {
+    const memoryLane = executionMemoryLane(input);
+    if (memoryLane === "shared" && !input.team_id?.trim()) {
+        throw new Error("Aionis shared execution memory requires team_id. Use memory_lane: \"private\" for single-agent memory.");
+    }
+    const agentId = executionAgentId(input);
+    return stripUndefined({
+        auto_embed: input.auto_embed ?? true,
+        memory_lane: memoryLane,
+        producer_agent_id: agentId,
+        owner_agent_id: memoryLane === "private" ? agentId : undefined,
+        owner_team_id: input.team_id,
+    });
+}
+function executionPayload(input) {
+    const result = executionResultSummary(input);
+    return stripUndefined({
+        run_id: input.run_id,
+        task_id: input.task_id,
+        task_family: input.task_family,
+        task_signature: input.task_signature,
+        workflow_signature: input.workflow_signature,
+        title: input.title,
+        summary: input.summary,
+        outcome: input.outcome ?? "unknown",
+        target_files: input.target_files,
+        workflow_steps: input.workflow_steps,
+        tool_set: input.tool_set,
+        acceptance_checks: input.acceptance_checks,
+        continuation_hint: input.continuation_hint,
+        resume_hint: input.resume_hint,
+        reuse_hint: input.reuse_hint,
+        confidence: input.confidence,
+        raw_ref: input.raw_ref,
+        evidence_ref: input.evidence_ref,
+        evidence: input.evidence,
+        artifacts: input.artifacts,
+        verification: input.verification,
+        slots: stripUndefined({
+            task_signature: input.task_signature,
+            ...(result ? { execution_result_summary: result } : {}),
+            ...(input.slots ?? {}),
+        }),
+        ...(input.execution ?? {}),
+    });
+}
+function executionHandoffPayload(input) {
+    const agentId = executionAgentId(input);
+    const memoryLane = executionMemoryLane(input);
+    const anchor = input.anchor ?? `${input.task_signature}:${input.run_id}:${agentId}`;
+    const handoffKind = input.handoff_kind ?? "task_handoff";
+    return stripUndefined({
+        memory_lane: memoryLane,
+        actor: agentId,
+        producer_agent_id: agentId,
+        owner_agent_id: memoryLane === "private" ? agentId : undefined,
+        owner_team_id: input.team_id,
+        anchor,
+        handoff_kind: handoffKind,
+        file_path: input.file_path,
+        repo_root: input.repo_root,
+        symbol: input.symbol,
+        task_family: input.task_family,
+        task_signature: input.task_signature,
+        workflow_signature: input.workflow_signature,
+        title: input.title,
+        summary: input.summary,
+        handoff_text: input.handoff_text ?? input.continuation_hint ?? input.summary,
+        risk: input.risk,
+        acceptance_checks: input.acceptance_checks,
+        tags: input.tags,
+        target_files: input.target_files,
+        next_action: input.next_action ?? input.continuation_hint,
+        must_change: input.must_change,
+        must_remove: input.must_remove,
+        must_keep: input.must_keep,
+        execution_result_summary: executionResultSummary(input),
+        execution_artifacts: input.artifacts,
+        execution_evidence: input.evidence,
+        execution_state_v1: input.execution_state_v1,
+        execution_packet_v1: input.execution_packet_v1,
+        control_profile_v1: input.control_profile_v1,
+        execution_transitions_v1: input.execution_transitions_v1,
+        execution_tree_disabled: input.execution_tree_disabled,
+        execution_tree_default_disabled: input.execution_tree_default_disabled,
+        execution_tree_v1: input.execution_tree_v1,
+        execution_tree_operations_v1: input.execution_tree_operations_v1,
+        trajectory: input.trajectory,
+        trajectory_hints: input.trajectory_hints,
+        ...(input.handoff ?? {}),
+    });
+}
 async function readResponseBody(response) {
     const text = await response.text();
     if (!text)
@@ -104,6 +600,7 @@ async function readResponseBody(response) {
     }
 }
 export class AionisClient {
+    execution;
     baseUrl;
     apiKey;
     tenantId;
@@ -119,6 +616,7 @@ export class AionisClient {
         this.headers = { ...(options.headers ?? {}) };
         this.defaultGuideMode = options.default_guide_mode === undefined ? "full_power" : options.default_guide_mode;
         this.fetchImpl = options.fetchImpl ?? fetch;
+        this.execution = new AionisExecutionClient(this);
     }
     async observe(body, options) {
         return this.post("/v1/observe", body, options);
@@ -172,14 +670,24 @@ export class AionisClient {
         return payload;
     }
     guideBody(body, options) {
-        if (body.mode !== undefined || body.context_mode !== undefined)
-            return body;
+        const compactBody = stripUndefined(body);
         const guideMode = options?.guide_mode === undefined ? this.defaultGuideMode : options.guide_mode;
+        if (compactBody.mode !== undefined)
+            return compactBody;
+        if (compactBody.context_mode !== undefined) {
+            if (compactBody.context_mode === "compact_agent" && guideMode) {
+                return {
+                    mode: guideMode,
+                    ...compactBody,
+                };
+            }
+            return compactBody;
+        }
         if (!guideMode)
-            return body;
+            return compactBody;
         return {
             mode: guideMode,
-            ...body,
+            ...compactBody,
         };
     }
     requestHeaders(options) {
@@ -191,6 +699,147 @@ export class AionisClient {
         };
     }
 }
+export class AionisExecutionClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    compileAgentContext(input) {
+        return compileExecutionAgentContext(input);
+    }
+    async observeStep(input, options) {
+        return this.client.observe({
+            ...executionObserveBase(input),
+            input_text: input.input_text ?? `${input.title}\n${input.summary}`,
+            execution: executionPayload(input),
+        }, {
+            ...executionScopeOptions(input),
+            ...(options ?? {}),
+        });
+    }
+    async handoff(input, options) {
+        return this.client.observe({
+            ...executionObserveBase(input),
+            handoff: executionHandoffPayload(input),
+        }, {
+            ...executionScopeOptions(input),
+            ...(options ?? {}),
+        });
+    }
+    async guideForRole(input, options) {
+        const agentId = executionAgentId(input);
+        return this.client.guide({
+            query_text: input.query_text,
+            agent_role: executionRole(input),
+            consumer_agent_id: agentId,
+            consumer_team_id: input.team_id,
+            run_id: input.run_id,
+            context: {
+                task_id: input.task_id,
+                task_signature: input.task_signature,
+                task_family: input.task_family,
+                workflow_signature: input.workflow_signature,
+                ...(input.context ?? {}),
+            },
+            execution_tree_v1: input.execution_tree_v1 ?? undefined,
+            tool_candidates: input.tool_candidates,
+            limit: input.limit ?? 10,
+            include_packets: input.include_packets ?? true,
+            mode: input.mode,
+            context_mode: input.context_mode,
+            context_char_budget: input.context_char_budget,
+            context_token_budget: input.context_token_budget,
+            context_compaction_profile: input.context_compaction_profile,
+            context_optimization_profile: input.context_optimization_profile,
+            ...(input.guide ?? {}),
+        }, {
+            ...executionScopeOptions(input),
+            ...(options ?? {}),
+        });
+    }
+    async observeOutcome(input, options) {
+        const observe = await this.observeStep(input, options);
+        const feedback = input.feedback === false ? null : await this.feedbackFromOutcome(input, options);
+        return { observe, feedback };
+    }
+    async feedbackFromOutcome(input, options) {
+        const usedMemoryIds = input.used_memory_ids ?? [];
+        if (usedMemoryIds.length === 0)
+            return null;
+        if (input.guide) {
+            return this.client.feedback(feedbackFromGuide({
+                guide: input.guide,
+                reason: input.feedback_reason ?? input.summary,
+                run_id: input.run_id,
+                outcome: executionFeedbackOutcome(input),
+                used_memory_ids: usedMemoryIds,
+                used_surface: input.used_surface ?? "use_now",
+                actor: input.agent_id,
+                verifier_status: executionVerifierStatus(input),
+                tool_status: executionToolStatus(input),
+                runtime_signal_refs: input.runtime_signal_refs,
+            }), {
+                ...executionScopeOptions(input),
+                ...(options ?? {}),
+            });
+        }
+        if (!input.guide_trace_id)
+            return null;
+        return this.client.feedback({
+            target: "memory",
+            reason: input.feedback_reason ?? input.summary,
+            run_id: input.run_id,
+            outcome: executionFeedbackOutcome(input),
+            used_surface: input.used_surface ?? "use_now",
+            actor: input.agent_id,
+            guide_trace_id: input.guide_trace_id,
+            used_memory_ids: usedMemoryIds,
+            verifier_status: executionVerifierStatus(input),
+            tool_status: executionToolStatus(input),
+            runtime_signal_refs: input.runtime_signal_refs,
+        }, {
+            ...executionScopeOptions(input),
+            ...(options ?? {}),
+        });
+    }
+    async measureRun(input, options) {
+        return this.client.measure(measureInputFromGuideLoop({
+            task: {
+                task_id: input.task_id ?? input.run_id,
+                run_id: input.run_id,
+                task_signature: input.task_signature,
+                task_family: input.task_family,
+            },
+            before_guide: input.before_guide,
+            after_guide: input.after_guide,
+            feedback_result: input.feedback_result,
+            sufficient_evidence: input.sufficient_evidence,
+            evidence_ids: input.evidence_ids,
+            tenant_id: input.tenant_id,
+            scope: input.scope,
+            product_trace: {
+                workflow_signature: input.workflow_signature,
+                ...(input.product_trace ?? {}),
+            },
+        }), options);
+    }
+    async snapshotRun(input, options) {
+        return this.client.snapshot(snapshotInputFromGuideLoop({
+            run_id: input.run_id,
+            task_signature: input.task_signature,
+            task_family: input.task_family,
+            guide: input.guide,
+            measure_result: input.measure_result,
+            include_markdown: input.include_markdown,
+            tenant_id: input.tenant_id,
+            scope: input.scope,
+            extra: {
+                workflow_signature: input.workflow_signature,
+                ...(input.extra ?? {}),
+            },
+        }), options);
+    }
+}
 export function createAionisClient(options) {
     return new AionisClient(options);
 }
@@ -208,6 +857,12 @@ export function agentPromptFromGuide(guide) {
     }
     return promptText;
 }
+export function rehydrateHintsFromGuide(guide) {
+    return rehydrateRequestsFromGuide(guide);
+}
+export function memoryUseReceiptFromGuide(guide) {
+    return receiptFromGuideTrace(guide) ?? generatedMemoryUseReceipt(guide);
+}
 export function memoryIdsFromGuide(guide) {
     const context = asRecord(agentContextFromGuide(guide));
     const ids = [
@@ -216,9 +871,194 @@ export function memoryIdsFromGuide(guide) {
         ...stringArray(context?.inspect_before_use_memory_ids),
         ...stringArray(context?.do_not_use_memory_ids),
         ...rehydrateHintMemoryIds(context?.rehydrate_hints),
+        ...commandPostureArray(context?.command_posture).map((entry) => entry.memory_id),
+        ...routeContractMemoryIds(context?.route_contract),
     ];
     return Array.from(new Set(ids));
 }
+export function routeContractFromGuide(guide) {
+    const contract = asRecord(asRecord(agentContextFromGuide(guide))?.route_contract);
+    if (!contract)
+        return null;
+    return {
+        active_targets: routeContractActiveTargetArray(contract.active_targets),
+        pending_artifacts: routeContractPendingArtifactArray(contract.pending_artifacts),
+        reference_only_targets: routeContractTargetArray(contract.reference_only_targets),
+        blocked_direction_targets: routeContractTargetArray(contract.blocked_direction_targets),
+        evidence_sources: routeContractEvidenceSourceArray(Array.isArray(contract.evidence_sources) ? contract.evidence_sources : contract.reference_only_targets),
+        blocked_routes: routeContractBlockedRouteArray(Array.isArray(contract.blocked_routes) ? contract.blocked_routes : contract.blocked_direction_targets),
+        conflict_policy: "do_not_treat_missing_active_target_as_superseded",
+        fallback_policy: "do_not_promote_reference_or_blocked_targets",
+        action_policy: routeContractActionPolicy(contract.action_policy),
+    };
+}
+export function activeRouteTargetsFromGuide(guide) {
+    return routeContractFromGuide(guide)?.active_targets.map((entry) => entry.target) ?? [];
+}
+export function pendingArtifactTargetsFromGuide(guide) {
+    return routeContractFromGuide(guide)?.pending_artifacts.map((entry) => entry.target) ?? [];
+}
+export function referenceOnlyRouteTargetsFromGuide(guide) {
+    return routeContractFromGuide(guide)?.reference_only_targets.map((entry) => entry.target) ?? [];
+}
+export function blockedDirectionRouteTargetsFromGuide(guide) {
+    return routeContractFromGuide(guide)?.blocked_direction_targets.map((entry) => entry.target) ?? [];
+}
+export function evidenceSourcesFromGuide(guide) {
+    return routeContractFromGuide(guide)?.evidence_sources ?? [];
+}
+export function blockedRoutesFromGuide(guide) {
+    return routeContractFromGuide(guide)?.blocked_routes ?? [];
+}
+export function compileExecutionAgentContext(input) {
+    const profile = input.budget_profile ?? "balanced";
+    const maxPromptChars = input.max_prompt_chars ?? defaultExecutionPromptBudget(profile);
+    const basePrompt = safeAgentPromptFromGuide(input.guide);
+    const routeContract = routeContractFromGuide(input.guide);
+    const commandPosture = commandPostureFromGuide(input.guide);
+    const receipt = memoryUseReceiptFromGuide(input.guide);
+    const rehydrateRequests = rehydrateHintsFromGuide(input.guide);
+    const useNowMemoryIds = receipt.use_now_memory_ids;
+    const inspectMemoryIds = receipt.inspect_before_use_memory_ids;
+    const doNotUseMemoryIds = receipt.do_not_use_memory_ids;
+    const activeTargets = routeContract ? targetList(routeContract.active_targets) : [];
+    const pendingArtifacts = routeContract ? targetList(routeContract.pending_artifacts) : [];
+    const referenceOnlyTargets = routeContract ? targetList(routeContract.evidence_sources.length > 0
+        ? routeContract.evidence_sources
+        : routeContract.reference_only_targets) : [];
+    const blockedDirectionTargets = routeContract ? targetList(routeContract.blocked_routes.length > 0
+        ? routeContract.blocked_routes
+        : routeContract.blocked_direction_targets) : [];
+    const presence = repoPresenceMap(input.repo_state);
+    const missingActiveTargets = activeTargets.filter((target) => presence.get(target) === false);
+    const warnings = [];
+    if (missingActiveTargets.length > 0) {
+        warnings.push({
+            code: "missing_active_target",
+            message: "An active route target is absent in the observed workspace; treat it as pending work, not stale memory.",
+            targets: missingActiveTargets,
+        });
+    }
+    if (blockedDirectionTargets.length > 0) {
+        warnings.push({
+            code: "blocked_route_present",
+            message: "Blocked or retired targets are counter-evidence only and must not become the primary route.",
+            targets: blockedDirectionTargets,
+        });
+    }
+    if (referenceOnlyTargets.length > 0) {
+        warnings.push({
+            code: "reference_only_target_present",
+            message: "Reference-only targets may be inspected for evidence but must not be promoted into the chosen route.",
+            targets: referenceOnlyTargets,
+        });
+    }
+    if (rehydrateRequests.length > 0) {
+        warnings.push({
+            code: "rehydrate_recommended",
+            message: "Aionis exposed rehydrate pointers for evidence that should be expanded before exact use.",
+            memory_ids: rehydrateRequests.map((entry) => entry.memory_id),
+        });
+    }
+    const contractSections = [
+        "AIONIS_EXECUTION_AGENT_CONTEXT v1",
+        "Treat this as the SDK-compiled execution-memory contract. Runtime remains the authority for memory admission.",
+        "",
+        "TASK",
+        ...taskLines(input.task),
+        ...(taskLines(input.task).length === 0 ? ["- Continue the current host task."] : []),
+        "",
+        "EXECUTION CONTRACT",
+        "- Follow active targets and should_continue memories as the current execution route.",
+        "- If an active target is missing, treat it as pending work to create or restore when task-consistent; do not fall back to blocked or reference-only paths because they exist.",
+        "- Reference-only targets may be read for evidence, but they are not valid primary routes without explicit host confirmation.",
+        "- Blocked, must_not, stale, failed, or retired routes are counter-evidence only.",
+        "- If compact evidence is insufficient for a precise edit, request rehydrate instead of guessing.",
+        ...(input.additional_instructions ?? []).map((entry) => `- ${entry}`),
+        "",
+        "ACTIVE_TARGETS",
+        ...bulletLines(activeTargets, "none"),
+        "",
+        "MISSING_ACTIVE_TARGETS",
+        ...bulletLines(missingActiveTargets, "none observed"),
+        "",
+        "PENDING_ARTIFACTS",
+        ...bulletLines(pendingArtifacts, "none"),
+        "",
+        "SHOULD_CONTINUE",
+        ...postureLines(commandPosture, "should_continue", "none"),
+        "",
+        "INSPECT_BEFORE_USE",
+        ...postureLines(commandPosture, "inspect_first", "none"),
+        "",
+        "DO_NOT_USE",
+        ...postureLines(commandPosture, "must_not", "none"),
+        "",
+        "REFERENCE_ONLY_TARGETS",
+        ...bulletLines(referenceOnlyTargets, "none"),
+        "",
+        "BLOCKED_DIRECTION_TARGETS",
+        ...bulletLines(blockedDirectionTargets, "none"),
+        "",
+        "REHYDRATE_REQUESTS",
+        ...(rehydrateRequests.length > 0
+            ? rehydrateRequests.map((entry) => `- ${entry.memory_id}${entry.reason ? `: ${entry.reason}` : ""}`)
+            : ["- none"]),
+    ];
+    const contractPrompt = contractSections.join("\n");
+    const includeBasePrompt = input.include_base_prompt ?? true;
+    const baseHeader = "\n\nBASE_AIONIS_CONTEXT\n";
+    const baseBudget = includeBasePrompt ? Math.max(0, maxPromptChars - contractPrompt.length - baseHeader.length) : 0;
+    const renderedBasePrompt = includeBasePrompt && basePrompt.length > 0 ? truncateText(basePrompt, baseBudget) : "";
+    const agentPrompt = renderedBasePrompt
+        ? truncateText(`${contractPrompt}${baseHeader}${renderedBasePrompt}`, maxPromptChars)
+        : truncateText(contractPrompt, maxPromptChars);
+    return {
+        contract_version: "aionis_execution_agent_context_v1",
+        budget_profile: profile,
+        agent_prompt: agentPrompt,
+        base_prompt: basePrompt,
+        prompt_char_count: agentPrompt.length,
+        route_contract: routeContract,
+        command_posture: commandPosture,
+        memory_use_receipt: receipt,
+        rehydrate_requests: rehydrateRequests,
+        use_now_memory_ids: useNowMemoryIds,
+        inspect_before_use_memory_ids: inspectMemoryIds,
+        do_not_use_memory_ids: doNotUseMemoryIds,
+        active_targets: activeTargets,
+        missing_active_targets: missingActiveTargets,
+        pending_artifacts: pendingArtifacts,
+        reference_only_targets: referenceOnlyTargets,
+        blocked_direction_targets: blockedDirectionTargets,
+        execution_warnings: warnings,
+    };
+}
+export function compileCodingAgentContext(input) {
+    return compileExecutionAgentContext(input);
+}
+export function commandPostureFromGuide(guide, posture) {
+    const rows = commandPostureArray(asRecord(agentContextFromGuide(guide))?.command_posture);
+    return posture ? rows.filter((entry) => entry.posture === posture) : rows;
+}
+export function commandPostureMemoryIdsFromGuide(guide, posture) {
+    return Array.from(new Set(commandPostureFromGuide(guide, posture).map((entry) => entry.memory_id)));
+}
+export function mustNotMemoryIdsFromGuide(guide) {
+    return commandPostureMemoryIdsFromGuide(guide, "must_not");
+}
+export function shouldContinueMemoryIdsFromGuide(guide) {
+    return commandPostureMemoryIdsFromGuide(guide, "should_continue");
+}
+export function inspectFirstMemoryIdsFromGuide(guide) {
+    return commandPostureMemoryIdsFromGuide(guide, "inspect_first");
+}
+export function rehydrateFirstMemoryIdsFromGuide(guide) {
+    return commandPostureMemoryIdsFromGuide(guide, "rehydrate_first");
+}
+export function optionalContextMemoryIdsFromGuide(guide) {
+    return commandPostureMemoryIdsFromGuide(guide, "optional_context");
+}
 export function feedbackFromGuide(input) {
     const guide = asRecord(input.guide);
     const guideTraceId = guide?.guide_trace_id;