@aionis/sdk 0.1.2 → 0.1.7

package/dist/index.js

@@ -41,6 +41,361 @@ 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 admissionRecordFromGuideTrace(guide) {
+    const guideRecord = asRecord(guide);
+    const candidates = [
+        asRecord(asRecord(guideRecord?.memory_decision_trace)?.admission_record),
+        asRecord(guideRecord?.memory_admission_record),
+        asRecord(asRecord(guideRecord?.agent_context)?.memory_admission_record),
+    ];
+    const record = candidates.find((entry) => entry?.contract_version === "aionis_memory_admission_record_v1");
+    return record ? record : 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";
@@ -282,6 +637,9 @@ export class AionisClient {
     async guide(body, options) {
         return this.post("/v1/guide", this.guideBody(body, options), options);
     }
+    async governMemory(body, options) {
+        return this.post("/v1/memory/govern", body, options);
+    }
     async forget(body, options) {
         return this.post("/v1/forget", body, options);
     }
@@ -297,6 +655,9 @@ export class AionisClient {
     async operatorSnapshot(body, options) {
         return this.post("/v1/operator/snapshot", body, options);
     }
+    async flightRecorder(body, options) {
+        return this.post("/v1/audit/flight-recorder", body, options);
+    }
     async snapshot(body, options) {
         return this.operatorSnapshot(body, options);
     }
@@ -326,9 +687,18 @@ export class AionisClient {
     }
     guideBody(body, options) {
         const compactBody = stripUndefined(body);
-        if (compactBody.mode !== undefined || compactBody.context_mode !== undefined)
-            return compactBody;
         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 compactBody;
         return {
@@ -350,6 +720,9 @@ export class AionisExecutionClient {
     constructor(client) {
         this.client = client;
     }
+    compileAgentContext(input) {
+        return compileExecutionAgentContext(input);
+    }
     async observeStep(input, options) {
         return this.client.observe({
             ...executionObserveBase(input),
@@ -500,6 +873,126 @@ export function agentPromptFromGuide(guide) {
     }
     return promptText;
 }
+export function rehydrateHintsFromGuide(guide) {
+    return rehydrateRequestsFromGuide(guide);
+}
+export function memoryUseReceiptFromGuide(guide) {
+    return receiptFromGuideTrace(guide) ?? generatedMemoryUseReceipt(guide);
+}
+export function memoryAdmissionRecordFromGuide(guide) {
+    const record = admissionRecordFromGuideTrace(guide);
+    if (record)
+        return record;
+    const receipt = memoryUseReceiptFromGuide(guide);
+    const entries = receipt.decision_summaries.map((summary) => ({
+        memory_id: summary.memory_id,
+        title: null,
+        domain: "execution",
+        memory_type: "unknown",
+        lifecycle_state: "unknown",
+        authority: "none",
+        admission_action: summary.agent_surface,
+        decision_kind: summary.decision_kind,
+        actionable: summary.actionable,
+        prompt_included: summary.agent_surface !== "not_agent_facing",
+        agent_used: receipt.attributed_memory_ids.includes(summary.memory_id),
+        feedback_outcome: null,
+        attribution_strength: null,
+        reason_codes: summary.reason_codes,
+        evidence_ids: [],
+    }));
+    return {
+        contract_version: "aionis_memory_admission_record_v1",
+        intended_use: "memory_admission_audit_dataset",
+        source: "memory_decision_trace",
+        agent_prompt_included: false,
+        runtime_mutation: false,
+        guide_trace_id: receipt.guide_trace_id,
+        prompt_char_count: receipt.prompt_char_count,
+        history_used: receipt.history_used,
+        actionable_history_used: receipt.actionable_history_used,
+        candidate_memory_count: entries.length,
+        prompt_included_memory_count: entries.filter((entry) => entry.prompt_included).length,
+        agent_used_memory_count: entries.filter((entry) => entry.agent_used).length,
+        entries,
+        summary: `Aionis generated ${entries.length} compact admission records from memory use receipt surfaces; full decision details require Runtime memory_decision_trace.`,
+    };
+}
+function admissionDatasetOutcomeLabel(entry) {
+    if (entry.agent_used && entry.feedback_outcome === "positive")
+        return "positive_use";
+    if (entry.agent_used && entry.feedback_outcome === "negative")
+        return "negative_use";
+    if (entry.agent_used && entry.feedback_outcome === "neutral")
+        return "neutral_use";
+    if (entry.admission_action === "do_not_use")
+        return "blocked_or_suppressed";
+    if (entry.admission_action === "rehydrate")
+        return "rehydrate_requested";
+    if (entry.admission_action === "not_agent_facing")
+        return "not_agent_facing";
+    if (entry.prompt_included && !entry.agent_used)
+        return "unused_exposed";
+    return "unknown";
+}
+function admissionDatasetString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+export function memoryAdmissionDatasetRowsFromRecord(record, options = {}) {
+    return record.entries.map((entry, index) => ({
+        contract_version: "aionis_memory_admission_dataset_row_v1",
+        intended_use: "memory_admission_policy_training_or_audit",
+        source: "memory_admission_record",
+        agent_prompt_included: false,
+        runtime_mutation: false,
+        tenant_id: admissionDatasetString(record.tenant_id),
+        scope: admissionDatasetString(record.scope),
+        guide_trace_id: admissionDatasetString(record.guide_trace_id),
+        run_id: admissionDatasetString(options.run_id),
+        task_id: admissionDatasetString(options.task_id),
+        task_signature: admissionDatasetString(options.task_signature),
+        row_index: index,
+        memory_id: entry.memory_id,
+        title: entry.title,
+        memory_origin: entry.memory_origin ?? "aionis",
+        source_backend: admissionDatasetString(entry.source_backend ?? null),
+        domain: entry.domain,
+        memory_type: entry.memory_type,
+        lifecycle_state: entry.lifecycle_state,
+        authority: entry.authority,
+        admission_action: entry.admission_action,
+        decision_kind: entry.decision_kind,
+        actionable: entry.actionable,
+        prompt_included: entry.prompt_included,
+        agent_used: entry.agent_used,
+        feedback_outcome: entry.feedback_outcome,
+        attribution_strength: entry.attribution_strength,
+        outcome_label: admissionDatasetOutcomeLabel(entry),
+        reason_codes: [...entry.reason_codes],
+        evidence_ids: [...entry.evidence_ids],
+        prompt_char_count: record.prompt_char_count,
+        history_used: record.history_used,
+        actionable_history_used: record.actionable_history_used,
+    }));
+}
+export function memoryAdmissionDatasetRowsFromRecords(records, options = {}) {
+    return records.flatMap((record) => memoryAdmissionDatasetRowsFromRecord(record, options));
+}
+export function memoryAdmissionDatasetRowsFromGuide(guide, options = {}) {
+    return memoryAdmissionDatasetRowsFromRecord(memoryAdmissionRecordFromGuide(guide), options);
+}
+export function memoryAdmissionDatasetJsonlFromRows(rows) {
+    return rows.length > 0 ? `${rows.map((row) => JSON.stringify(row)).join("\n")}\n` : "";
+}
+export function memoryAdmissionDatasetJsonlFromRecord(record, options = {}) {
+    return memoryAdmissionDatasetJsonlFromRows(memoryAdmissionDatasetRowsFromRecord(record, options));
+}
+export function memoryAdmissionDatasetJsonlFromRecords(records, options = {}) {
+    return memoryAdmissionDatasetJsonlFromRows(memoryAdmissionDatasetRowsFromRecords(records, options));
+}
+export function memoryAdmissionDatasetJsonlFromGuide(guide, options = {}) {
+    return memoryAdmissionDatasetJsonlFromRows(memoryAdmissionDatasetRowsFromGuide(guide, options));
+}
 export function memoryIdsFromGuide(guide) {
     const context = asRecord(agentContextFromGuide(guide));
     const ids = [
@@ -508,9 +1001,196 @@ 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 admissionRecord = memoryAdmissionRecordFromGuide(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,
+        memory_admission_record: admissionRecord,
+        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;