@aionis/sdk 0.1.2 → 0.1.7

package/README.md

@@ -8,10 +8,15 @@ npm install @aionis/sdk
 
 ```ts
 import {
-  agentPromptFromGuide,
+  compileExecutionAgentContext,
+  commandPostureFromGuide,
   createAionisClient,
   feedbackFromGuide,
+  memoryAdmissionDatasetJsonlFromGuide,
+  memoryAdmissionRecordFromGuide,
   measureInputFromGuideLoop,
+  mustNotMemoryIdsFromGuide,
+  shouldContinueMemoryIdsFromGuide,
   snapshotInputFromGuideLoop,
 } from "@aionis/sdk";
 
@@ -29,7 +34,20 @@ const guide = await aionis.guide({
   include_packets: true,
 });
 
-const agentPrompt = agentPromptFromGuide(guide);
+const context = compileExecutionAgentContext({
+  guide,
+  task: "Continue the task.",
+  budget_profile: "balanced",
+});
+const agentPrompt = context.agent_prompt;
+const commandPosture = commandPostureFromGuide(guide);
+const mustNotMemoryIds = mustNotMemoryIdsFromGuide(guide);
+const shouldContinueMemoryIds = shouldContinueMemoryIdsFromGuide(guide);
+const admissionRecord = memoryAdmissionRecordFromGuide(guide);
+const admissionDatasetJsonl = memoryAdmissionDatasetJsonlFromGuide(guide, {
+  run_id: "run-001",
+  task_signature: "first-integration",
+});
 
 const feedback = await aionis.feedback(feedbackFromGuide({
   guide,
@@ -59,7 +77,31 @@ await aionis.snapshot(snapshotInputFromGuideLoop({
 ```
 
 Only pass `agentPrompt` or selected `agent_context` fields to your Agent. Keep
-packets, traces, receipts, raw slots, and operator snapshots in host logs.
+packets, traces, receipts, admission records, raw slots, and operator snapshots
+in host logs.
+Use `commandPostureFromGuide()` when the host wants structured execution
+instructions: `must_not` blocks failed or stale branches, `should_continue`
+biases the Agent toward active state or accepted procedure, `inspect_first`
+keeps candidate history out of direct action, and `rehydrate_first` asks the
+host to recover raw payload before exact use.
+
+For token-sensitive Agent calls, request compact prompt rendering:
+
+```ts
+const compactGuide = await aionis.guide({
+  query_text: "Continue the task without repeating failed work.",
+  consumer_agent_id: "agent-1",
+  context_mode: "compact_agent",
+});
+
+const compactPrompt = compileExecutionAgentContext({
+  guide: compactGuide,
+  budget_profile: "compact",
+}).agent_prompt;
+```
+
+`context_mode: "compact_agent"` keeps SDK guide defaults on the governed
+full-power path while shortening only `agent_context.prompt_text`.
 
 ## Execution Memory Helpers
 
@@ -84,8 +126,23 @@ const guide = await aionis.execution.guideForRole({
   run_id: "run-001",
   task_signature: "checkout-migration",
   query_text: "Continue from the current verified execution path.",
+  context_mode: "compact_agent",
 });
 
+const context = compileExecutionAgentContext({
+  guide,
+  task: {
+    task_signature: "checkout-migration",
+    query_text: "Continue from the current verified execution path.",
+  },
+  repo_state: {
+    existing_files: ["src/checkout.ts"],
+  },
+  budget_profile: "balanced",
+});
+
+// Your host runs the Agent with context.agent_prompt.
+
 const feedback = await aionis.execution.feedbackFromOutcome({
   agent_id: "reviewer-1",
   run_id: "run-001",
@@ -97,3 +154,119 @@ const feedback = await aionis.execution.feedbackFromOutcome({
   used_memory_ids: guide.agent_context.use_now_memory_ids.slice(0, 1),
 });
 ```
+
+`compileExecutionAgentContext` is the recommended product path for coding and
+multi-agent hosts. It converts the governed Runtime `guide` into a contract
+prompt plus structured adapter state:
+
+- active route targets and pending artifacts
+- reference-only and blocked direction targets
+- `use_now`, `inspect_before_use`, `do_not_use`, and `rehydrate` memory IDs
+- a compact Memory Use Receipt for audit and feedback attribution
+- a Memory Admission Record for per-memory admission dataset rows
+- warnings when a host-observed active target is missing
+
+This helper does not mutate Runtime state and does not expose raw packets to the
+Agent. If an active target is missing, the rendered contract tells the Agent to
+treat the target as pending work instead of falling back to a blocked or
+reference-only path that happens to exist.
+
+For a host loop, the most common posture helpers are:
+
+```ts
+const mustNot = mustNotMemoryIdsFromGuide(guide);
+const shouldContinue = shouldContinueMemoryIdsFromGuide(guide);
+const posture = commandPostureFromGuide(guide);
+const route = routeContractFromGuide(guide);
+const evidence = evidenceSourcesFromGuide(guide);
+const blocked = blockedRoutesFromGuide(guide);
+```
+
+These helpers read only `agent_context`. They do not expose `memory_packet`,
+`guide_packet`, traces, or operator-only evidence to the Agent.
+`routeContractFromGuide` exposes the structured execution contract:
+`active_targets` are the continuation route, `pending_artifacts` describe
+missing-active-target handling, `evidence_sources` are reference-only evidence,
+and `blocked_routes` are counter-evidence only.
+
+`memoryAdmissionRecordFromGuide(guide)` is the host/operator surface for the
+read-only admission ledger. It records candidate memory IDs, admission actions,
+prompt exposure, and feedback attribution without changing Runtime authority or
+adding content to the Agent prompt.
+
+`memoryAdmissionDatasetJsonlFromGuide(guide)` exports that ledger as JSONL rows
+for host logs or a data lake. It keeps raw prompt text, raw memory payloads, and
+embeddings out of the export while preserving enough admission/outcome fields to
+audit decisions or train a future admission policy offline.
+
+## Govern External Memory
+
+Use `governMemory()` when your host already has candidates from Mem0, Zep,
+Pinecone, pgvector, markdown, logs, or another memory backend, but still wants
+Aionis to decide which memory may direct the Agent.
+
+```ts
+const result = await aionis.governMemory({
+  query_text: "Continue the checkout migration without reusing failed branches.",
+  mode: "firewall",
+  include_records: true,
+  candidates: [
+    {
+      external_memory_id: "mem0:current-route",
+      source_backend: "mem0",
+      text: "Current accepted target is packages/api/src/checkout.ts.",
+      authority: {
+        source_trust: "trusted",
+        scope: "project",
+        evidence_requirement: "none",
+      },
+      lifecycle_hint: "current",
+    },
+    {
+      external_memory_id: "zep:failed-route",
+      source_backend: "zep",
+      text: "The legacy route failed verifier checks.",
+      authority: {
+        source_trust: "trusted",
+        scope: "project",
+        evidence_requirement: "none",
+      },
+      lifecycle_hint: "failed",
+    },
+  ],
+});
+
+const prompt = result.agent_context.prompt_text;
+const firewall = result.memory_firewall;
+```
+
+`mode: "firewall"` blocks failed, stale, contested, suppressed, archived, or
+policy-blocked external memory from direct action. Unknown or untrusted memory
+stays `inspect_before_use`; raw evidence pointers stay `rehydrate`.
+
+## Replay Agent Decisions
+
+Use `flightRecorder()` after a run to inspect what memory the Agent was allowed
+to see at decision time.
+
+```ts
+const replay = await aionis.flightRecorder({
+  run_id: "run-001",
+  guide_trace_id: guide.guide_trace_id,
+  product_trace: {
+    before_guide: previousGuide,
+    after_guide: guide,
+  },
+  feedback_result: {
+    run_id: "run-001",
+    outcome: "positive",
+    used_memory_ids: guide.agent_context.use_now_memory_ids.slice(0, 1),
+  },
+});
+
+console.log(replay.agent_flight_recorder.agent_view.use_now_memory_ids);
+```
+
+The report excludes `agent_context.prompt_text` and raw memory payloads. Keep it
+in host/operator logs for incident replay, support debugging, and memory-quality
+review.

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export type AionisJsonObject = Record<string, unknown>;
 export type AionisGuideMode = "standard" | "full_power";
+export type AionisGuideContextMode = AionisGuideMode | "compact_agent";
 export type AionisFeedbackOutcome = "positive" | "negative" | "neutral";
 export type AionisFeedbackUsedSurface = "use_now" | "inspect_before_use" | "do_not_use" | "explicit_host_assertion";
 export type AionisFeedbackStatus = "passed" | "failed" | "not_run" | "unknown";
@@ -13,6 +14,332 @@ export type AionisRememberTier = "hot" | "warm" | "cold" | "archive";
 export type AionisExecutionAgentRole = "agent" | "planner" | "worker" | "verifier" | "reviewer";
 export type AionisExecutionOutcomeStatus = "succeeded" | "failed" | "blocked" | "interrupted" | "unknown";
 export type AionisHandoffKind = "patch_handoff" | "review_handoff" | "task_handoff";
+export type AionisCommandPostureKind = "must_not" | "should_continue" | "inspect_first" | "rehydrate_first" | "optional_context";
+export type AionisCommandPostureSurface = "current" | "procedure" | "use_now" | "inspect_before_use" | "do_not_use" | "rehydrate" | "context";
+export type AionisCommandPosture = {
+    posture: AionisCommandPostureKind;
+    surface: AionisCommandPostureSurface;
+    memory_id: string;
+    instruction: string;
+    reason: string;
+    target_files: string[];
+};
+export type AionisRouteContractSource = "target_files" | "should_continue" | "inspect_first" | "must_not";
+export type AionisRouteContractTarget = {
+    target: string;
+    source_memory_id?: string;
+    source: AionisRouteContractSource;
+    reason?: string;
+};
+export type AionisRouteContractActiveTarget = AionisRouteContractTarget & {
+    artifact_status: "unknown" | "may_be_absent";
+    missing_policy: "restore_or_create_if_task_consistent_or_rehydrate";
+};
+export type AionisRouteContractMissingActiveAction = "create" | "restore" | "rehydrate" | "report_conflict";
+export type AionisRouteContractPendingArtifact = AionisRouteContractTarget & {
+    status: "unknown_until_host_observation";
+    when: "if_active_target_is_missing";
+    allowed_actions: AionisRouteContractMissingActiveAction[];
+    preferred_action_order: AionisRouteContractMissingActiveAction[];
+    terminal_inspect_allowed: false;
+};
+export type AionisRouteContractEvidenceSource = AionisRouteContractTarget & {
+    evidence_use: "reference_only";
+    direction_policy: "must_not_be_primary_route";
+};
+export type AionisRouteContractBlockedRoute = AionisRouteContractTarget & {
+    direction_policy: "blocked_route";
+    evidence_use: "counter_evidence_only";
+};
+export type AionisRouteContractActionPolicy = {
+    missing_active_target_preferred_order: AionisRouteContractMissingActiveAction[];
+    terminal_inspect_allowed: false;
+    reference_fallback_requires: "explicit_raw_evidence_or_operator_confirmation";
+};
+export type AionisRouteContract = {
+    active_targets: AionisRouteContractActiveTarget[];
+    pending_artifacts: AionisRouteContractPendingArtifact[];
+    reference_only_targets: AionisRouteContractTarget[];
+    blocked_direction_targets: AionisRouteContractTarget[];
+    evidence_sources: AionisRouteContractEvidenceSource[];
+    blocked_routes: AionisRouteContractBlockedRoute[];
+    conflict_policy: "do_not_treat_missing_active_target_as_superseded";
+    fallback_policy: "do_not_promote_reference_or_blocked_targets";
+    action_policy: AionisRouteContractActionPolicy;
+};
+export type AionisRehydrateHint = {
+    memory_id: string;
+    reason?: string;
+    required: boolean;
+};
+export type AionisMemoryDecisionSummary = {
+    memory_id: string;
+    agent_surface: "use_now" | "inspect_before_use" | "do_not_use" | "rehydrate" | "not_agent_facing";
+    decision_kind: "used" | "downgraded" | "blocked" | "rehydrate" | "not_agent_facing";
+    actionable: boolean;
+    reason_codes: string[];
+};
+export type AionisMemoryUseReceipt = {
+    contract_version: "aionis_memory_use_receipt_v1";
+    intended_use: "memory_use_audit";
+    agent_prompt_included: false;
+    runtime_mutation: false;
+    guide_trace_id: string | null;
+    history_used: boolean;
+    actionable_history_used: boolean;
+    prompt_char_count: number;
+    exposed_memory_ids: string[];
+    use_now_memory_ids: string[];
+    inspect_before_use_memory_ids: string[];
+    do_not_use_memory_ids: string[];
+    rehydrate_memory_ids: string[];
+    attributed_memory_ids: string[];
+    unattributed_recalled_memory_ids: string[];
+    read_only_signal_memory_ids: string[];
+    decision_summaries: AionisMemoryDecisionSummary[];
+    risk_flags: string[];
+    summary: string;
+};
+export type AionisMemoryAdmissionRecordEntry = {
+    memory_id: string;
+    title: string | null;
+    memory_origin?: "aionis" | "external";
+    source_backend?: string;
+    domain: "general" | "execution";
+    memory_type: "fact" | "preference" | "project_context" | "procedure" | "event" | "evidence" | "rule" | "execution_memory" | "unknown";
+    lifecycle_state: "active" | "candidate" | "contested" | "suppressed" | "demoted" | "archived" | "rehydration_candidate" | "unknown";
+    authority: "none" | "advisory" | "trusted" | "blocked";
+    admission_action: "use_now" | "inspect_before_use" | "do_not_use" | "rehydrate" | "not_agent_facing";
+    decision_kind: "used" | "downgraded" | "blocked" | "rehydrate" | "not_agent_facing";
+    actionable: boolean;
+    prompt_included: boolean;
+    agent_used: boolean;
+    feedback_outcome: AionisFeedbackOutcome | null;
+    attribution_strength: "none" | "observed_feedback_only" | "positive_attribution" | "weak_below_threshold" | "repeated_weak_threshold_met" | "strong_signal_threshold_met" | null;
+    reason_codes: string[];
+    evidence_ids: string[];
+};
+export type AionisMemoryAdmissionRecord = {
+    contract_version: "aionis_memory_admission_record_v1";
+    intended_use: "memory_admission_audit_dataset";
+    source: "memory_decision_trace" | "external_candidate_admission";
+    agent_prompt_included: false;
+    runtime_mutation: false;
+    tenant_id?: string;
+    scope?: string;
+    guide_trace_id: string | null;
+    prompt_char_count: number;
+    history_used: boolean;
+    actionable_history_used: boolean;
+    candidate_memory_count: number;
+    prompt_included_memory_count: number;
+    agent_used_memory_count: number;
+    entries: AionisMemoryAdmissionRecordEntry[];
+    summary: string;
+};
+export type AionisExternalMemoryAuthority = {
+    source_trust?: "trusted" | "known" | "untrusted" | "unknown";
+    scope?: "user" | "project" | "team" | "org" | "global" | "unknown";
+    evidence_requirement?: "none" | "inspect_before_use" | "rehydrate_before_use" | "blocked";
+};
+export type AionisExternalMemoryLifecycleHint = "current" | "procedure" | "failed" | "stale" | "contested" | "suppressed" | "archived" | "unknown";
+export type AionisExternalMemoryCandidate = {
+    external_memory_id: string;
+    source_backend: string;
+    text: string;
+    metadata?: AionisJsonObject;
+    authority?: AionisExternalMemoryAuthority;
+    lifecycle_hint?: AionisExternalMemoryLifecycleHint;
+    evidence_refs?: string[];
+};
+export type AionisMemoryAdmissionGatewayMode = "standard" | "strict" | "firewall";
+export type AionisMemoryAdmissionRequest = AionisJsonObject & {
+    query_text: string;
+    run_id?: string;
+    mode?: AionisMemoryAdmissionGatewayMode;
+    context_mode?: "standard" | "compact_agent";
+    candidates: AionisExternalMemoryCandidate[];
+    include_records?: boolean;
+};
+export type AionisMemoryFirewallSummary = {
+    contract_version: "aionis_memory_firewall_summary_v1";
+    intended_use: "memory_firewall_audit";
+    mode: "firewall";
+    candidate_count: number;
+    direct_use_count: number;
+    inspect_count: number;
+    blocked_count: number;
+    rehydrate_count: number;
+    unsafe_candidate_count: number;
+    unsafe_direct_use_count: number;
+    runtime_mutation: false;
+    agent_prompt_included: false;
+    risk_flags: string[];
+    claims: Array<{
+        claim: string;
+        status: "pass" | "warn" | "fail";
+        evidence: string;
+    }>;
+    summary: string;
+};
+export type AionisMemoryAdmissionGatewayResponse = AionisJsonObject & {
+    contract_version: "aionis_memory_admission_gateway_result_v1";
+    tenant_id: string;
+    scope: string;
+    run_id: string | null;
+    mode: AionisMemoryAdmissionGatewayMode;
+    agent_context: AionisJsonObject;
+    memory_use_receipt: AionisMemoryUseReceipt;
+    memory_admission_records?: AionisMemoryAdmissionRecord;
+    memory_firewall?: AionisMemoryFirewallSummary;
+    admission_summary: AionisJsonObject;
+    source_map: AionisJsonObject;
+};
+export type AionisAgentFlightRecorderReport = AionisJsonObject & {
+    contract_version: "aionis_agent_flight_recorder_report_v1";
+    intended_use: "incident_replay_audit";
+    agent_prompt_included: false;
+    runtime_mutation: false;
+    guide_trace_id: string | null;
+    run_id: string | null;
+    decision_time: string;
+    agent_view: AionisJsonObject & {
+        prompt_text_included: false;
+        exposed_memory_ids: string[];
+        use_now_memory_ids: string[];
+        inspect_before_use_memory_ids: string[];
+        do_not_use_memory_ids: string[];
+        rehydrate_memory_ids: string[];
+    };
+    blocked_or_suppressed: AionisJsonObject[];
+    attribution: AionisJsonObject & {
+        present: boolean;
+        outcome: AionisFeedbackOutcome | null;
+        used_memory_ids: string[];
+        attributed_memory_ids: string[];
+        unattributed_memory_ids: string[];
+        supported_memory_ids: string[];
+        contradicted_memory_ids: string[];
+    };
+    replay_sources: AionisJsonObject;
+    claims: AionisJsonObject[];
+    source_map: AionisJsonObject;
+    summary: string;
+};
+export type AionisAgentFlightRecorderRequest = AionisJsonObject & {
+    guide_trace_id?: string;
+    run_id?: string;
+    product_trace?: AionisJsonObject;
+    agent_context?: AionisJsonObject;
+    memory_decision_trace?: AionisJsonObject;
+    memory_use_receipt?: AionisJsonObject;
+    memory_admission_record?: AionisJsonObject;
+    operator_snapshot?: AionisJsonObject;
+    feedback_result?: AionisJsonObject;
+    decision_time?: string;
+};
+export type AionisAgentFlightRecorderResponse = AionisJsonObject & {
+    contract_version: "aionis_agent_flight_recorder_result_v1";
+    tenant_id: string;
+    scope: string;
+    agent_flight_recorder: AionisAgentFlightRecorderReport;
+    source_map: AionisJsonObject;
+};
+export type AionisMemoryAdmissionDatasetOutcomeLabel = "positive_use" | "negative_use" | "neutral_use" | "unused_exposed" | "blocked_or_suppressed" | "rehydrate_requested" | "not_agent_facing" | "unknown";
+export type AionisMemoryAdmissionDatasetRow = {
+    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: string | null;
+    scope: string | null;
+    guide_trace_id: string | null;
+    run_id: string | null;
+    task_id: string | null;
+    task_signature: string | null;
+    row_index: number;
+    memory_id: string;
+    title: string | null;
+    memory_origin: AionisMemoryAdmissionRecordEntry["memory_origin"];
+    source_backend: string | null;
+    domain: AionisMemoryAdmissionRecordEntry["domain"];
+    memory_type: AionisMemoryAdmissionRecordEntry["memory_type"];
+    lifecycle_state: AionisMemoryAdmissionRecordEntry["lifecycle_state"];
+    authority: AionisMemoryAdmissionRecordEntry["authority"];
+    admission_action: AionisMemoryAdmissionRecordEntry["admission_action"];
+    decision_kind: AionisMemoryAdmissionRecordEntry["decision_kind"];
+    actionable: boolean;
+    prompt_included: boolean;
+    agent_used: boolean;
+    feedback_outcome: AionisFeedbackOutcome | null;
+    attribution_strength: AionisMemoryAdmissionRecordEntry["attribution_strength"];
+    outcome_label: AionisMemoryAdmissionDatasetOutcomeLabel;
+    reason_codes: string[];
+    evidence_ids: string[];
+    prompt_char_count: number;
+    history_used: boolean;
+    actionable_history_used: boolean;
+};
+export type AionisMemoryAdmissionDatasetExportOptions = {
+    run_id?: string | null;
+    task_id?: string | null;
+    task_signature?: string | null;
+};
+export type AionisExecutionContextBudgetProfile = "compact" | "balanced" | "high_recall";
+export type AionisExecutionFilePresence = {
+    target: string;
+    exists: boolean;
+    reason?: string;
+};
+export type AionisExecutionRepoState = {
+    existing_files?: string[];
+    missing_files?: string[];
+    files?: AionisExecutionFilePresence[];
+};
+export type AionisExecutionContextTask = {
+    task_id?: string;
+    run_id?: string;
+    task_signature?: string;
+    query_text?: string;
+    goal?: string;
+};
+export type AionisExecutionAgentContextCompileInput = {
+    guide: unknown;
+    task?: string | AionisExecutionContextTask;
+    repo_state?: AionisExecutionRepoState;
+    budget_profile?: AionisExecutionContextBudgetProfile;
+    max_prompt_chars?: number;
+    include_base_prompt?: boolean;
+    additional_instructions?: string[];
+};
+export type AionisExecutionContextWarning = {
+    code: "missing_active_target" | "blocked_route_present" | "reference_only_target_present" | "rehydrate_recommended";
+    message: string;
+    targets?: string[];
+    memory_ids?: string[];
+};
+export type AionisCompiledExecutionAgentContext = {
+    contract_version: "aionis_execution_agent_context_v1";
+    budget_profile: AionisExecutionContextBudgetProfile;
+    agent_prompt: string;
+    base_prompt: string;
+    prompt_char_count: number;
+    route_contract: AionisRouteContract | null;
+    command_posture: AionisCommandPosture[];
+    memory_use_receipt: AionisMemoryUseReceipt;
+    memory_admission_record: AionisMemoryAdmissionRecord;
+    rehydrate_requests: AionisRehydrateHint[];
+    use_now_memory_ids: string[];
+    inspect_before_use_memory_ids: string[];
+    do_not_use_memory_ids: string[];
+    active_targets: string[];
+    missing_active_targets: string[];
+    pending_artifacts: string[];
+    reference_only_targets: string[];
+    blocked_direction_targets: string[];
+    execution_warnings: AionisExecutionContextWarning[];
+};
 export type AionisClientOptions = {
     baseUrl: string;
     apiKey?: string;
@@ -191,7 +518,7 @@ export type AionisExecutionGuideForRoleInput = AionisExecutionRunRef & AionisExe
     limit?: number;
     include_packets?: boolean;
     mode?: AionisGuideMode;
-    context_mode?: AionisGuideMode;
+    context_mode?: AionisGuideContextMode;
     context_char_budget?: number;
     context_token_budget?: number;
     context_compaction_profile?: "balanced" | "aggressive";
@@ -251,11 +578,13 @@ export declare class AionisClient {
     observe<T = unknown>(body: AionisJsonObject, options?: AionisRequestOptions): Promise<T>;
     remember<T = unknown>(body: AionisRememberRequest, options?: AionisRequestOptions): Promise<T>;
     guide<T = unknown>(body: AionisJsonObject, options?: AionisGuideRequestOptions): Promise<T>;
+    governMemory<T = AionisMemoryAdmissionGatewayResponse>(body: AionisMemoryAdmissionRequest, options?: AionisRequestOptions): Promise<T>;
     forget<T = unknown>(body: AionisJsonObject, options?: AionisRequestOptions): Promise<T>;
     feedback<T = unknown>(body: AionisFeedbackRequest, options?: AionisRequestOptions): Promise<T>;
     rehydrate<T = unknown>(body: AionisRehydrateRequest, options?: AionisRequestOptions): Promise<T>;
     measure<T = unknown>(body: AionisJsonObject, options?: AionisRequestOptions): Promise<T>;
     operatorSnapshot<T = unknown>(body: AionisJsonObject, options?: AionisRequestOptions): Promise<T>;
+    flightRecorder<T = AionisAgentFlightRecorderResponse>(body: AionisAgentFlightRecorderRequest, options?: AionisRequestOptions): Promise<T>;
     snapshot<T = unknown>(body: AionisJsonObject, options?: AionisRequestOptions): Promise<T>;
     health<T = unknown>(): Promise<T>;
     private post;
@@ -265,6 +594,7 @@ export declare class AionisClient {
 export declare class AionisExecutionClient {
     private readonly client;
     constructor(client: AionisClient);
+    compileAgentContext(input: AionisExecutionAgentContextCompileInput): AionisCompiledExecutionAgentContext;
     observeStep<T = unknown>(input: AionisExecutionStepInput, options?: AionisRequestOptions): Promise<T>;
     handoff<T = unknown>(input: AionisExecutionHandoffInput, options?: AionisRequestOptions): Promise<T>;
     guideForRole<T = unknown>(input: AionisExecutionGuideForRoleInput, options?: AionisGuideRequestOptions): Promise<T>;
@@ -276,7 +606,33 @@ export declare class AionisExecutionClient {
 export declare function createAionisClient(options: AionisClientOptions): AionisClient;
 export declare function agentContextFromGuide<T = AionisJsonObject>(guide: unknown): T;
 export declare function agentPromptFromGuide(guide: unknown): string;
+export declare function rehydrateHintsFromGuide(guide: unknown): AionisRehydrateHint[];
+export declare function memoryUseReceiptFromGuide(guide: unknown): AionisMemoryUseReceipt;
+export declare function memoryAdmissionRecordFromGuide(guide: unknown): AionisMemoryAdmissionRecord;
+export declare function memoryAdmissionDatasetRowsFromRecord(record: AionisMemoryAdmissionRecord, options?: AionisMemoryAdmissionDatasetExportOptions): AionisMemoryAdmissionDatasetRow[];
+export declare function memoryAdmissionDatasetRowsFromRecords(records: AionisMemoryAdmissionRecord[], options?: AionisMemoryAdmissionDatasetExportOptions): AionisMemoryAdmissionDatasetRow[];
+export declare function memoryAdmissionDatasetRowsFromGuide(guide: unknown, options?: AionisMemoryAdmissionDatasetExportOptions): AionisMemoryAdmissionDatasetRow[];
+export declare function memoryAdmissionDatasetJsonlFromRows(rows: AionisMemoryAdmissionDatasetRow[]): string;
+export declare function memoryAdmissionDatasetJsonlFromRecord(record: AionisMemoryAdmissionRecord, options?: AionisMemoryAdmissionDatasetExportOptions): string;
+export declare function memoryAdmissionDatasetJsonlFromRecords(records: AionisMemoryAdmissionRecord[], options?: AionisMemoryAdmissionDatasetExportOptions): string;
+export declare function memoryAdmissionDatasetJsonlFromGuide(guide: unknown, options?: AionisMemoryAdmissionDatasetExportOptions): string;
 export declare function memoryIdsFromGuide(guide: unknown): string[];
+export declare function routeContractFromGuide(guide: unknown): AionisRouteContract | null;
+export declare function activeRouteTargetsFromGuide(guide: unknown): string[];
+export declare function pendingArtifactTargetsFromGuide(guide: unknown): string[];
+export declare function referenceOnlyRouteTargetsFromGuide(guide: unknown): string[];
+export declare function blockedDirectionRouteTargetsFromGuide(guide: unknown): string[];
+export declare function evidenceSourcesFromGuide(guide: unknown): AionisRouteContractEvidenceSource[];
+export declare function blockedRoutesFromGuide(guide: unknown): AionisRouteContractBlockedRoute[];
+export declare function compileExecutionAgentContext(input: AionisExecutionAgentContextCompileInput): AionisCompiledExecutionAgentContext;
+export declare function compileCodingAgentContext(input: AionisExecutionAgentContextCompileInput): AionisCompiledExecutionAgentContext;
+export declare function commandPostureFromGuide(guide: unknown, posture?: AionisCommandPostureKind): AionisCommandPosture[];
+export declare function commandPostureMemoryIdsFromGuide(guide: unknown, posture?: AionisCommandPostureKind): string[];
+export declare function mustNotMemoryIdsFromGuide(guide: unknown): string[];
+export declare function shouldContinueMemoryIdsFromGuide(guide: unknown): string[];
+export declare function inspectFirstMemoryIdsFromGuide(guide: unknown): string[];
+export declare function rehydrateFirstMemoryIdsFromGuide(guide: unknown): string[];
+export declare function optionalContextMemoryIdsFromGuide(guide: unknown): string[];
 export declare function feedbackFromGuide(input: AionisFeedbackFromGuideInput): AionisFeedbackRequest;
 export declare function measureInputFromGuideLoop(input: AionisMeasureFromGuideLoopInput): AionisJsonObject;
 export declare function snapshotInputFromGuideLoop(input: AionisSnapshotFromGuideLoopInput): AionisJsonObject;