From fdeb9561bcb807f26b615c7e13fc906946e7954f Mon Sep 17 00:00:00 2001
From: Rin <shinohara-rin@users.noreply.github.com>
Date: Wed, 1 Apr 2026 23:33:59 +0800
Subject: [PATCH] feat(minecraft,stage-*): airi integration, isolated-vm plus
 misc updates (#1371)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(minecraft): contextflow integration

Add AiriBridge to cognitive engine to enable communication with Airi system. Expose `notifyAiri` and `updateAiriContext` functions in JS planner runtime globals for sending notifications and context updates from agent code.

* refactor(minecraft): remove redundant destinations field from airi-bridge

Remove hardcoded `destinations: ['minecraft']` from spark:command, spark:notify, and context:update events as the destination is already implied by the bridge context.

* feat(minecraft): complete AIRI context flow integration

Wire up bidirectional AIRI ↔ Minecraft communication via dedicated
signal channels instead of reusing signal:chat_message.

- Add airi_command and airi_context to PerceptionSignalType
- Route spark:command intents: action/plan/proposal/reroute emit
  signal:airi_command; context intent emits signal:airi_context
- Add inbound context:update listener so AIRI can push context to
  the Minecraft agent
- airi_context signals are injected into conversation history directly
  without triggering a full cognitive cycle
- airi_command events reset the no-action budget (like player chat)
- enterContext/exitContext auto-emit context:update back to AIRI for
  task lifecycle visibility
- Add sendEmit() helper for queued/working/done progress reporting

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(minecraft): report bot startup state to AIRI

Send initial context update to AIRI when brain comes online, including
bot username, server address, position, health, game mode, and list of
other online players. Tagged with 'startup' and bot username for
filtering.

* feat(minecraft): manage bot config through airi

* feat(stage-ui): add minecraft service shell

* fix(stage-ui): use applied minecraft config for chat context

* fix(minecraft): fall back on invalid env port

* fix(minecraft): support quoted env values

* fix(minecraft): ignore empty env overrides

* fix(stage-ui): keep minecraft draft during apply

* fix(stage-ui): simplify minecraft heartbeat label

* feat(stage-ui): simplify minecraft settings shell

* fix(minecraft): use registry heartbeat for stage liveness

* chore(minecraft): remove annoying detector decision logging

* fix(minecraft): limit context flow to bot pushes

* fix(minecraft): use workspace server sdk

* fix(stage-ui): replay registry snapshots for late listeners

* chore(minecraft): add todo for explicit stage deregistration

* feat: improve context flow observability

* fix(stage-ui): remove redundant header and callout from settings and context flow pages

* feat(stage-ui): enhance context flow prompt projection UI with readiness indicator

* docs(stage-ui): clarify context flow prompt projection terminology

* fix(stage-ui): add test for clone-safe context snapshots with nested fields

* todo

* fix(minecraft): avoid blocking startup on airi connection

* Remove LLM timeouts from the Minecraft brain

* Remove context boundary system from Minecraft brain

* feat(minecraft): use isolated-vm for JS planner sandbox

* refactor(minecraft): harden planner sandbox defaults

* Remove LLM attempt timeout guard

* [autofix.ci] apply automated fixes

* Fix server runtime shutdown signal handling

* Remove misleading Minecraft integration toggle

* contextflow destination to stage-*

* chore(deps): updated

* Add settings layout route for web devtools

* chore: default to expand context panels

* fix(server-*): should export more types, and for module:announced should ignore self

* refactor(minecraft): better context orchestration, handle module announce, context sync, and more

* feat(stage-ui): not spark command ready

* [autofix.ci] apply automated fixes

* clean up

* refactor: use :class arrays per AGENTS.md styling guidelines

* cleanup bloated tests

* rm more tests

* use errorMessageFrom

* hardcode to reduce bloat

* update setup instructions

* timeout for brain

* remove more bloat

* fix

---------

Co-authored-by-agent: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by-agent: Codex
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Neko Ayaka <neko@ayaka.moe>
---
 apps/stage-web/src/pages/devtools/index.vue   |   13 +
 packages/i18n/src/locales/en/settings.yaml    |   32 +-
 packages/plugin-protocol/src/types/events.ts  |    2 +-
 packages/server-runtime/src/bin/run.ts        |    6 +-
 .../stage-layouts/src/layouts/settings.vue    |   10 +-
 .../context-flow-active-contexts.vue          |  125 ++
 .../components/context-flow-lifecycle.vue     |  134 ++
 .../context-flow-prompt-projection.vue        |  122 ++
 .../components/context-flow-runtime.vue       |  107 ++
 .../src/pages/devtools/context-flow/index.vue |   77 +-
 .../settings/modules/gaming-minecraft.vue     |   71 +-
 .../components/modules/GamingMinecraft.vue    |  127 +-
 .../src/composables/use-modules-list.ts       |    2 +
 packages/stage-ui/src/stores/chat.ts          |   87 +-
 .../src/stores/chat/context-prompt.ts         |   30 +
 .../stores/chat/context-providers/index.ts    |    1 +
 .../chat/context-providers/minecraft.ts       |   39 +
 .../stage-ui/src/stores/chat/context-store.ts |   76 +-
 .../stores/devtools/context-observability.ts  |  122 ++
 packages/stage-ui/src/stores/llm.ts           |  109 +-
 .../src/stores/mods/api/channel-server.ts     |  105 +-
 .../src/stores/mods/api/context-bridge.ts     |  125 +-
 .../src/stores/modules/gaming-minecraft.ts    |  236 +++-
 packages/stage-ui/src/types/chat.ts           |    2 +-
 packages/stage-ui/src/utils/relative-time.ts  |    9 +
 pnpm-lock.yaml                                |   14 +
 pnpm-workspace.yaml                           |    4 +-
 services/minecraft/README.md                  |   67 +-
 services/minecraft/package.json               |    7 +-
 services/minecraft/src/airi/airi-bridge.ts    |  226 +++
 .../src/airi/minecraft-context-service.ts     |  169 +++
 .../src/airi/start-background-client.ts       |   58 +
 .../src/cognitive/conscious/brain.test.ts     |   23 +-
 .../src/cognitive/conscious/brain.ts          |  339 +----
 .../cognitive/conscious/context-summary.ts    |  182 ---
 .../src/cognitive/conscious/history-query.ts  |   63 +-
 .../conscious/js-planner-sandbox-protocol.ts  |  152 ++
 .../conscious/js-planner-sandbox-runner.ts    |  196 +++
 .../cognitive/conscious/js-planner-worker.ts  |  291 ++++
 .../cognitive/conscious/js-planner.test.ts    |   58 +
 .../src/cognitive/conscious/js-planner.ts     | 1236 +++++++++++++----
 .../conscious/prompts/brain-prompt.md         |  110 +-
 .../conscious/repl-code-normalizer.ts         |    2 +-
 services/minecraft/src/cognitive/container.ts |   28 +-
 services/minecraft/src/cognitive/index.ts     |   16 +-
 .../src/cognitive/perception/rules/engine.ts  |    9 +-
 .../src/cognitive/perception/types/signals.ts |    2 +
 .../src/composables/runtime-config.ts         |  164 +++
 services/minecraft/src/debug/types.ts         |   22 -
 services/minecraft/src/debug/web/app.js       |   70 +-
 services/minecraft/src/main.ts                |  165 ++-
 .../minecraft/src/minecraft-bot-runtime.ts    |   85 ++
 52 files changed, 4314 insertions(+), 1213 deletions(-)
 create mode 100644 apps/stage-web/src/pages/devtools/index.vue
 create mode 100644 packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-active-contexts.vue
 create mode 100644 packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-lifecycle.vue
 create mode 100644 packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-prompt-projection.vue
 create mode 100644 packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-runtime.vue
 create mode 100644 packages/stage-ui/src/stores/chat/context-prompt.ts
 create mode 100644 packages/stage-ui/src/stores/chat/context-providers/minecraft.ts
 create mode 100644 packages/stage-ui/src/stores/devtools/context-observability.ts
 create mode 100644 packages/stage-ui/src/utils/relative-time.ts
 create mode 100644 services/minecraft/src/airi/airi-bridge.ts
 create mode 100644 services/minecraft/src/airi/minecraft-context-service.ts
 create mode 100644 services/minecraft/src/airi/start-background-client.ts
 delete mode 100644 services/minecraft/src/cognitive/conscious/context-summary.ts
 create mode 100644 services/minecraft/src/cognitive/conscious/js-planner-sandbox-protocol.ts
 create mode 100644 services/minecraft/src/cognitive/conscious/js-planner-sandbox-runner.ts
 create mode 100644 services/minecraft/src/cognitive/conscious/js-planner-worker.ts
 create mode 100644 services/minecraft/src/composables/runtime-config.ts
 create mode 100644 services/minecraft/src/minecraft-bot-runtime.ts

diff --git a/apps/stage-web/src/pages/devtools/index.vue b/apps/stage-web/src/pages/devtools/index.vue
new file mode 100644
index 000000000..0b749bbf7
--- /dev/null
+++ b/apps/stage-web/src/pages/devtools/index.vue
@@ -0,0 +1,13 @@
+<script setup lang="ts">
+import { RouterView } from 'vue-router'
+</script>
+
+<template>
+  <RouterView />
+</template>
+
+<route lang="yaml">
+meta:
+  layout: settings
+  titleKey: tamagotchi.settings.devtools.title
+</route>
diff --git a/packages/i18n/src/locales/en/settings.yaml b/packages/i18n/src/locales/en/settings.yaml
index e1e7612f4..c9a563dc4 100644
--- a/packages/i18n/src/locales/en/settings.yaml
+++ b/packages/i18n/src/locales/en/settings.yaml
@@ -391,16 +391,30 @@ pages:
       description: Playing Minecraft!
       title: Minecraft
       enable: Enable Minecraft Integration
-      enable-description: Allow AIRI to interact with Minecraft game
-      server-address: Server Address
-      server-address-description: The IP address or hostname of the Minecraft server
-      server-address-placeholder: Enter server address (e.g., localhost or play.example.com)
-      server-port: Server Port
-      server-port-description: The port number of the Minecraft server (default 25565)
-      username: Username
-      username-description: Your username in the Minecraft server
-      username-placeholder: Enter your Minecraft username
+      enable-description: Include Minecraft self-knowledge in Stage chat turns and keep passive runtime visibility enabled.
       configured: Minecraft is properly configured!
+      read-only:
+        title: Read-only shell
+        description: Stage currently exposes Minecraft as a passive shell. Runtime status and traffic are visible here, but service configuration stays in the Minecraft service files.
+      setup:
+        title: Setup
+        description: You can find the instructions for setting up the bot in the following file
+      runtime:
+        title: Observed runtime
+        connection: Connection
+        latest-context: Latest bot context
+        waiting: Waiting for a fresh bot-originated context push.
+        unknown: Unknown
+      debug:
+        title: Minecraft traffic
+        empty: No Minecraft traffic observed yet.
+        source: 'Source: {source}'
+      status:
+        service-online: Service online
+        service-offline: Service offline
+        no-runtime-context: 'No bot context observed yet'
+        last-context-seconds: 'Last bot context: {seconds}s ago'
+        last-context-stale: 'Last bot context: Stale'
     hearing:
       description: Configure how speech recognition works
       title: Hearing
diff --git a/packages/plugin-protocol/src/types/events.ts b/packages/plugin-protocol/src/types/events.ts
index 20e6cf85b..b150981ce 100644
--- a/packages/plugin-protocol/src/types/events.ts
+++ b/packages/plugin-protocol/src/types/events.ts
@@ -471,7 +471,7 @@ interface InputSource {
 interface OutputSource {
   'gen-ai:chat': {
     message: UserMessage
-    contexts: Record<string, ContextUpdate<Record<string, any>, string | CommonContentPart[]>[]>
+    contexts: Record<string, ContextUpdate<Record<string, any>, unknown>[]>
     composedMessage: Array<Message>
     input?: InputEventEnvelope
   }
diff --git a/packages/server-runtime/src/bin/run.ts b/packages/server-runtime/src/bin/run.ts
index 3cde056ec..1d4d04a6d 100644
--- a/packages/server-runtime/src/bin/run.ts
+++ b/packages/server-runtime/src/bin/run.ts
@@ -1,6 +1,6 @@
 #!/usr/bin/env tsx
 
-import { env, exit, on } from 'node:process'
+import process, { env, exit } from 'node:process'
 
 import { createServer } from '../server'
 
@@ -18,7 +18,7 @@ async function shutdown() {
   exit(0)
 }
 
-on('SIGINT', shutdown)
-on('SIGTERM', shutdown)
+process.on('SIGINT', shutdown)
+process.on('SIGTERM', shutdown)
 
 server.start()
diff --git a/packages/stage-layouts/src/layouts/settings.vue b/packages/stage-layouts/src/layouts/settings.vue
index cbbb18f67..d8264c2f6 100644
--- a/packages/stage-layouts/src/layouts/settings.vue
+++ b/packages/stage-layouts/src/layouts/settings.vue
@@ -78,14 +78,12 @@ onMounted(() => updateThemeColor())
       paddingRight: 'env(safe-area-inset-right, 0px)',
       paddingLeft: 'env(safe-area-inset-left, 0px)',
     }"
-    h-full w-full
+    :class="['h-full w-full', 'flex flex-col']"
   >
     <!-- Header -->
     <div
       v-if="!isStageTamagotchi()"
-      class="px-0 py-1 hidden sm:block md:px-3 md:py-3"
-      w-full gap-2
-      bg="$bg-color"
+      :class="['px-0 py-1 hidden sm:block', 'md:px-3 md:py-3', 'w-full gap-2', 'bg-$bg-color']"
     >
       <HeaderLink />
     </div>
@@ -94,7 +92,7 @@ onMounted(() => updateThemeColor())
       :class="[
         'px-3 py-0 2xl:max-w-screen-2xl md:py-0 xl:px-4',
         isStageTamagotchi() ? 'sm:max-h-[calc(100%)] max-h-[calc(100%)]' : 'sm:max-h-[calc(100%-56px)] max-h-[calc(100%-40px)]',
-        'flex flex-col mx-auto h-full min-h-0',
+        'mx-auto flex min-h-0 w-full flex-1 flex-col',
       ]"
     >
       <PageHeader
@@ -102,7 +100,7 @@ onMounted(() => updateThemeColor())
         :subtitle="routeHeaderMetadata?.subtitle"
         :disable-back-button="isStageTamagotchi() && route.path === '/settings'"
       />
-      <div id="settings-scroll-container" relative min-h-0 flex-1 overflow-y-auto scrollbar-none>
+      <div id="settings-scroll-container" :class="['relative', 'min-h-0', 'flex-1', 'overflow-y-auto', 'scrollbar-none']">
         <RouterView />
       </div>
     </div>
diff --git a/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-active-contexts.vue b/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-active-contexts.vue
new file mode 100644
index 000000000..e7bc8ec83
--- /dev/null
+++ b/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-active-contexts.vue
@@ -0,0 +1,125 @@
+<script setup lang="ts">
+import type { ContextBucketSnapshot } from '@proj-airi/stage-ui/stores/chat/context-store'
+
+import { Section } from '@proj-airi/stage-ui/components'
+import { computed } from 'vue'
+
+const props = defineProps<{
+  buckets: ContextBucketSnapshot[]
+  filterText: string
+  now: number
+}>()
+
+const filteredBuckets = computed(() => {
+  const query = props.filterText.trim().toLowerCase()
+  if (!query)
+    return props.buckets
+
+  return props.buckets.filter((bucket) => {
+    const haystack = [
+      bucket.sourceKey,
+      ...bucket.messages.map(message => [
+        message.text,
+        message.contextId,
+        message.id,
+        message.lane,
+        message.strategy,
+      ].filter(Boolean).join(' ')),
+    ].join(' ').toLowerCase()
+
+    return haystack.includes(query)
+  })
+})
+
+function formatAge(timestamp?: number) {
+  if (!timestamp)
+    return 'n/a'
+
+  const ageMs = Math.max(0, props.now - timestamp)
+  if (ageMs < 1000)
+    return 'now'
+  if (ageMs < 60_000)
+    return `${Math.floor(ageMs / 1000)}s ago`
+  return `${Math.floor(ageMs / 60_000)}m ago`
+}
+
+function isAged(timestamp?: number) {
+  if (!timestamp)
+    return false
+  return props.now - timestamp >= 60_000
+}
+</script>
+
+<template>
+  <Section
+    title="Active Context State"
+    icon="i-solar:database-bold-duotone"
+    inner-class="gap-3"
+    :expand="true"
+  >
+    <div :class="['text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+      {{ filteredBuckets.length }} source bucket(s) currently retained in `chat-context`.
+    </div>
+
+    <div v-if="!filteredBuckets.length" :class="['text-sm', 'text-neutral-500', 'dark:text-neutral-400']">
+      No retained contexts match the current filter.
+    </div>
+
+    <div v-else :class="['grid', 'gap-3']">
+      <div
+        v-for="bucket in filteredBuckets"
+        :key="bucket.sourceKey"
+        :class="[
+          'rounded-xl',
+          'border',
+          'border-neutral-200/70',
+          'bg-white/80',
+          'p-4',
+          'dark:border-neutral-800/80',
+          'dark:bg-neutral-950/60',
+        ]"
+      >
+        <div :class="['flex', 'flex-wrap', 'items-center', 'justify-between', 'gap-3']">
+          <div :class="['flex', 'flex-wrap', 'items-center', 'gap-2']">
+            <span :class="['rounded-full', 'border', 'border-neutral-300/70', 'bg-neutral-100/80', 'px-2', 'py-0.5', 'font-mono', 'text-xs', 'text-neutral-700', 'dark:border-neutral-700', 'dark:bg-neutral-900/80', 'dark:text-neutral-200']">
+              {{ bucket.sourceKey }}
+            </span>
+            <span :class="['text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+              {{ bucket.entryCount }} entr{{ bucket.entryCount === 1 ? 'y' : 'ies' }}
+            </span>
+          </div>
+          <span
+            :class="[
+              'text-xs',
+              isAged(bucket.latestCreatedAt)
+                ? 'text-orange-600 dark:text-orange-300'
+                : 'text-neutral-500 dark:text-neutral-400',
+            ]"
+          >
+            Latest {{ formatAge(bucket.latestCreatedAt) }}
+          </span>
+        </div>
+
+        <div :class="['mt-3', 'grid', 'gap-2']">
+          <div
+            v-for="message in bucket.messages"
+            :key="message.id"
+            :class="[
+              'rounded-lg',
+              'bg-neutral-50/90',
+              'p-3',
+              'dark:bg-neutral-900/70',
+            ]"
+          >
+            <div :class="['flex', 'flex-wrap', 'items-center', 'gap-2', 'text-[11px]', 'uppercase', 'tracking-[0.06em]', 'text-neutral-400', 'dark:text-neutral-500']">
+              <span>{{ message.strategy }}</span>
+              <span v-if="message.lane">{{ message.lane }}</span>
+              <span>{{ message.contextId }}</span>
+            </div>
+            <pre :class="['mt-2', 'whitespace-pre-wrap', 'break-words', 'text-xs', 'font-mono', 'text-neutral-800', 'dark:text-neutral-100']">{{ message.text }}</pre>
+          </div>
+        </div>
+      </div>
+    </div>
+  </Section>
+</template>
diff --git a/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-lifecycle.vue b/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-lifecycle.vue
new file mode 100644
index 000000000..15a0d88a1
--- /dev/null
+++ b/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-lifecycle.vue
@@ -0,0 +1,134 @@
+<script setup lang="ts">
+import type { ContextLifecycleRecord } from '@proj-airi/stage-ui/stores/devtools/context-observability'
+
+import { Section } from '@proj-airi/stage-ui/components'
+import { computed } from 'vue'
+
+const props = defineProps<{
+  records: ContextLifecycleRecord[]
+  filterText: string
+}>()
+
+const filteredRecords = computed(() => {
+  const query = props.filterText.trim().toLowerCase()
+  if (!query)
+    return props.records
+
+  return props.records.filter((record) => {
+    const haystack = [
+      record.phase,
+      record.channel,
+      record.sourceKey,
+      record.sessionId,
+      record.strategy,
+      record.lane,
+      record.contextId,
+      record.eventId,
+      record.mutation,
+      record.textPreview,
+      record.sourceLabel,
+      (() => {
+        try {
+          return JSON.stringify(record.details)
+        }
+        catch {
+          return ''
+        }
+      })(),
+    ].filter(Boolean).join(' ').toLowerCase()
+
+    return haystack.includes(query)
+  })
+})
+
+function phaseBadgeClass(phase: ContextLifecycleRecord['phase']) {
+  switch (phase) {
+    case 'server-received':
+      return ['bg-orange-500/15', 'text-orange-600', 'dark:text-orange-300']
+    case 'broadcast-received':
+    case 'broadcast-posted':
+      return ['bg-violet-500/15', 'text-violet-600', 'dark:text-violet-300']
+    case 'before-compose':
+    case 'prompt-context-built':
+    case 'after-compose':
+      return ['bg-lime-500/15', 'text-lime-600', 'dark:text-lime-300']
+    default:
+      return ['bg-sky-500/15', 'text-sky-600', 'dark:text-sky-300']
+  }
+}
+</script>
+
+<template>
+  <Section
+    title="Context Lifecycle"
+    icon="i-solar:history-bold-duotone"
+    inner-class="gap-3"
+    :expand="false"
+  >
+    <div :class="['text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+      {{ filteredRecords.length }} lifecycle record(s).
+    </div>
+
+    <div v-if="!filteredRecords.length" :class="['text-sm', 'text-neutral-500', 'dark:text-neutral-400']">
+      No lifecycle record matches the current filter.
+    </div>
+
+    <div v-else :class="['grid', 'gap-3']">
+      <div
+        v-for="record in filteredRecords"
+        :key="record.id"
+        :class="[
+          'rounded-xl',
+          'border',
+          'border-neutral-200/70',
+          'bg-white/80',
+          'p-4',
+          'dark:border-neutral-800/80',
+          'dark:bg-neutral-950/60',
+        ]"
+      >
+        <div :class="['flex', 'flex-wrap', 'items-center', 'justify-between', 'gap-2']">
+          <div :class="['flex', 'flex-wrap', 'items-center', 'gap-2']">
+            <span :class="['rounded-full', 'px-2', 'py-0.5', 'text-xs', ...phaseBadgeClass(record.phase)]">
+              {{ record.phase }}
+            </span>
+            <span :class="['rounded-full', 'bg-neutral-400/15', 'px-2', 'py-0.5', 'text-xs', 'text-neutral-600', 'dark:text-neutral-300']">
+              {{ record.channel }}
+            </span>
+            <span v-if="record.sourceKey" :class="['font-mono', 'text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+              {{ record.sourceKey }}
+            </span>
+          </div>
+          <span :class="['text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+            {{ new Date(record.timestamp).toLocaleTimeString() }}
+          </span>
+        </div>
+
+        <div :class="['mt-2', 'grid', 'gap-1', 'text-xs', 'text-neutral-600', 'dark:text-neutral-300']">
+          <div v-if="record.textPreview">
+            {{ record.textPreview }}
+          </div>
+          <div v-if="record.contextId">
+            contextId={{ record.contextId }}
+          </div>
+          <div v-if="record.mutation">
+            mutation={{ record.mutation }}
+          </div>
+          <div v-if="record.sessionId">
+            session={{ record.sessionId }}
+          </div>
+          <div v-if="record.sourceLabel">
+            source={{ record.sourceLabel }}
+          </div>
+        </div>
+
+        <details :class="['mt-3']">
+          <summary :class="['cursor-pointer', 'text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+            Details
+          </summary>
+          <pre :class="['mt-2', 'max-h-72', 'overflow-auto', 'rounded-lg', 'bg-neutral-900/90', 'p-3', 'text-xs', 'text-neutral-100']">{{ JSON.stringify(record, null, 2) }}</pre>
+        </details>
+      </div>
+    </div>
+  </Section>
+</template>
diff --git a/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-prompt-projection.vue b/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-prompt-projection.vue
new file mode 100644
index 000000000..bc4beaba5
--- /dev/null
+++ b/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-prompt-projection.vue
@@ -0,0 +1,122 @@
+<script setup lang="ts">
+import type { PromptProjectionSnapshot } from '@proj-airi/stage-ui/stores/devtools/context-observability'
+
+import { Section } from '@proj-airi/stage-ui/components'
+
+defineProps<{
+  currentPromptText: string
+  currentSourceCount: number
+  lastProjection?: PromptProjectionSnapshot
+}>()
+</script>
+
+<template>
+  <Section
+    title="Next Prompt Projection"
+    icon="i-solar:document-text-bold-duotone"
+    inner-class="gap-3"
+    :expand="true"
+  >
+    <div
+      :class="[
+        'rounded-xl',
+        'border',
+        currentPromptText
+          ? 'border-emerald-200/80 bg-emerald-50/80 dark:border-emerald-900/80 dark:bg-emerald-950/30'
+          : 'border-neutral-200/70 bg-white/70 dark:border-neutral-800/80 dark:bg-neutral-950/40',
+        'p-4',
+      ]"
+    >
+      <div :class="['text-xs', 'font-medium', 'uppercase', 'tracking-[0.08em]', currentPromptText ? 'text-emerald-600 dark:text-emerald-400' : 'text-neutral-400 dark:text-neutral-500']">
+        Prompt Readiness
+      </div>
+      <div v-if="currentPromptText" :class="['mt-2', 'text-sm', 'text-neutral-700', 'dark:text-neutral-200']">
+        {{ currentSourceCount }} retained source bucket{{ currentSourceCount === 1 ? '' : 's' }} are ready for the next compose in this runtime.
+        `Last Actual Compose` stays empty until a real send starts.
+      </div>
+      <div v-else :class="['mt-2', 'text-sm', 'text-neutral-500', 'dark:text-neutral-400']">
+        No retained contexts are ready to inject right now.
+      </div>
+    </div>
+
+    <div :class="['grid', 'gap-3', 'xl:grid-cols-2']">
+      <div
+        :class="[
+          'rounded-xl',
+          'border',
+          'border-neutral-200/70',
+          'bg-white/80',
+          'p-4',
+          'dark:border-neutral-800/80',
+          'dark:bg-neutral-950/60',
+        ]"
+      >
+        <div :class="['text-xs', 'font-medium', 'uppercase', 'tracking-[0.08em]', 'text-neutral-400', 'dark:text-neutral-500']">
+          Current Derived Prompt Block
+        </div>
+        <div :class="['mt-2', 'text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+          Built directly from the current `chat-context` snapshot. This does not require a compose to have started yet.
+        </div>
+        <pre
+          v-if="currentPromptText"
+          :class="['mt-3', 'max-h-80', 'overflow-auto', 'whitespace-pre-wrap', 'break-words', 'rounded-lg', 'bg-neutral-900/90', 'p-3', 'text-xs', 'font-mono', 'text-neutral-100']"
+        >{{ currentPromptText }}</pre>
+        <div v-else :class="['mt-3', 'text-sm', 'text-neutral-500', 'dark:text-neutral-400']">
+          No retained contexts to inject right now.
+        </div>
+      </div>
+
+      <div
+        :class="[
+          'rounded-xl',
+          'border',
+          'border-neutral-200/70',
+          'bg-white/80',
+          'p-4',
+          'dark:border-neutral-800/80',
+          'dark:bg-neutral-950/60',
+        ]"
+      >
+        <div :class="['flex', 'flex-wrap', 'items-center', 'justify-between', 'gap-2']">
+          <div :class="['text-xs', 'font-medium', 'uppercase', 'tracking-[0.08em]', 'text-neutral-400', 'dark:text-neutral-500']">
+            Last Actual Compose
+          </div>
+          <span v-if="lastProjection" :class="['text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+            {{ new Date(lastProjection.capturedAt).toLocaleTimeString() }} · {{ lastProjection.sessionId }}
+          </span>
+        </div>
+        <div :class="['mt-2', 'text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+          Captured only after the chat orchestrator begins a real compose/send flow.
+        </div>
+
+        <template v-if="lastProjection">
+          <div :class="['mt-3', 'text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+            Message: {{ lastProjection.message }}
+          </div>
+          <pre
+            v-if="lastProjection.promptText"
+            :class="['mt-3', 'max-h-80', 'overflow-auto', 'whitespace-pre-wrap', 'break-words', 'rounded-lg', 'bg-neutral-900/90', 'p-3', 'text-xs', 'font-mono', 'text-neutral-100']"
+          >{{ lastProjection.promptText }}</pre>
+          <div v-else :class="['mt-3', 'text-sm', 'text-neutral-500', 'dark:text-neutral-400']">
+            The last compose had no injected context block.
+          </div>
+
+          <details :class="['mt-3']">
+            <summary :class="['cursor-pointer', 'text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+              Details
+            </summary>
+            <pre :class="['mt-2', 'max-h-72', 'overflow-auto', 'rounded-lg', 'bg-neutral-900/90', 'p-3', 'text-xs', 'text-neutral-100']">{{ JSON.stringify(lastProjection, null, 2) }}</pre>
+          </details>
+        </template>
+
+        <div v-else-if="currentPromptText" :class="['mt-3', 'text-sm', 'text-neutral-500', 'dark:text-neutral-400']">
+          Retained context is ready, but no real compose has started in this runtime yet.
+        </div>
+
+        <div v-else :class="['mt-3', 'text-sm', 'text-neutral-500', 'dark:text-neutral-400']">
+          No compose snapshot recorded yet, and there is no retained context ready to inject.
+        </div>
+      </div>
+    </div>
+  </Section>
+</template>
diff --git a/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-runtime.vue b/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-runtime.vue
new file mode 100644
index 000000000..2b0430897
--- /dev/null
+++ b/packages/stage-pages/src/pages/devtools/context-flow/components/context-flow-runtime.vue
@@ -0,0 +1,107 @@
+<script setup lang="ts">
+import type { QueuedSendSnapshot } from '@proj-airi/stage-ui/stores/chat'
+
+import { Section } from '@proj-airi/stage-ui/components'
+
+defineProps<{
+  connected: boolean
+  pendingSendCount: number
+  pendingQueuedSendCount: number
+  pendingQueuedSends: QueuedSendSnapshot[]
+  activeSessionId: string
+  lastBroadcastPostedAt?: number
+  lastBroadcastReceivedAt?: number
+  now: number
+}>()
+
+function formatAge(now: number, timestamp?: number) {
+  if (!timestamp)
+    return 'never'
+
+  const ageMs = Math.max(0, now - timestamp)
+  if (ageMs < 1000)
+    return 'now'
+  if (ageMs < 60_000)
+    return `${Math.floor(ageMs / 1000)}s ago`
+  return `${Math.floor(ageMs / 60_000)}m ago`
+}
+</script>
+
+<template>
+  <Section
+    title="Runtime Coordination"
+    icon="i-solar:radar-2-bold-duotone"
+    inner-class="gap-3"
+    :expand="false"
+  >
+    <div :class="['grid', 'gap-3', 'sm:grid-cols-2', 'xl:grid-cols-4']">
+      <div :class="['rounded-xl', 'bg-white/80', 'p-4', 'dark:bg-neutral-950/60']">
+        <div :class="['text-[11px]', 'uppercase', 'tracking-[0.08em]', 'text-neutral-400', 'dark:text-neutral-500']">
+          WebSocket
+        </div>
+        <div :class="['mt-2', connected ? 'text-emerald-600 dark:text-emerald-300' : 'text-rose-600 dark:text-rose-300', 'text-sm', 'font-semibold']">
+          {{ connected ? 'connected' : 'disconnected' }}
+        </div>
+      </div>
+      <div :class="['rounded-xl', 'bg-white/80', 'p-4', 'dark:bg-neutral-950/60']">
+        <div :class="['text-[11px]', 'uppercase', 'tracking-[0.08em]', 'text-neutral-400', 'dark:text-neutral-500']">
+          Unsent Buffer
+        </div>
+        <div :class="['mt-2', 'text-sm', 'font-semibold', 'text-neutral-800', 'dark:text-neutral-100']">
+          {{ pendingSendCount }}
+        </div>
+      </div>
+      <div :class="['rounded-xl', 'bg-white/80', 'p-4', 'dark:bg-neutral-950/60']">
+        <div :class="['text-[11px]', 'uppercase', 'tracking-[0.08em]', 'text-neutral-400', 'dark:text-neutral-500']">
+          Queued Sends
+        </div>
+        <div :class="['mt-2', 'text-sm', 'font-semibold', 'text-neutral-800', 'dark:text-neutral-100']">
+          {{ pendingQueuedSendCount }}
+        </div>
+      </div>
+      <div :class="['rounded-xl', 'bg-white/80', 'p-4', 'dark:bg-neutral-950/60']">
+        <div :class="['text-[11px]', 'uppercase', 'tracking-[0.08em]', 'text-neutral-400', 'dark:text-neutral-500']">
+          Active Session
+        </div>
+        <div :class="['mt-2', 'truncate', 'font-mono', 'text-sm', 'text-neutral-800', 'dark:text-neutral-100']">
+          {{ activeSessionId }}
+        </div>
+      </div>
+    </div>
+
+    <div :class="['grid', 'gap-3', 'xl:grid-cols-2']">
+      <div :class="['rounded-xl', 'bg-white/80', 'p-4', 'dark:bg-neutral-950/60']">
+        <div :class="['text-[11px]', 'uppercase', 'tracking-[0.08em]', 'text-neutral-400', 'dark:text-neutral-500']">
+          Broadcast Activity
+        </div>
+        <div :class="['mt-2', 'grid', 'gap-2', 'text-sm', 'text-neutral-700', 'dark:text-neutral-200']">
+          <div>Posted: {{ formatAge(now, lastBroadcastPostedAt) }}</div>
+          <div>Received: {{ formatAge(now, lastBroadcastReceivedAt) }}</div>
+        </div>
+      </div>
+
+      <div :class="['rounded-xl', 'bg-white/80', 'p-4', 'dark:bg-neutral-950/60']">
+        <div :class="['text-[11px]', 'uppercase', 'tracking-[0.08em]', 'text-neutral-400', 'dark:text-neutral-500']">
+          Pending Queue Snapshot
+        </div>
+        <div v-if="pendingQueuedSends.length" :class="['mt-2', 'grid', 'gap-2']">
+          <div
+            v-for="queued in pendingQueuedSends"
+            :key="`${queued.sessionId}-${queued.generation}-${queued.messagePreview}`"
+            :class="['rounded-lg', 'bg-neutral-50/90', 'p-3', 'dark:bg-neutral-900/70']"
+          >
+            <div :class="['font-mono', 'text-xs', 'text-neutral-500', 'dark:text-neutral-400']">
+              {{ queued.sessionId }} · gen {{ queued.generation }} · {{ queued.inputType ?? 'manual' }}
+            </div>
+            <div :class="['mt-1', 'text-xs', 'text-neutral-800', 'dark:text-neutral-100']">
+              {{ queued.messagePreview || '(empty)' }}
+            </div>
+          </div>
+        </div>
+        <div v-else :class="['mt-2', 'text-sm', 'text-neutral-500', 'dark:text-neutral-400']">
+          No queued sends.
+        </div>
+      </div>
+    </div>
+  </Section>
+</template>
diff --git a/packages/stage-pages/src/pages/devtools/context-flow/index.vue b/packages/stage-pages/src/pages/devtools/context-flow/index.vue
index 7e7ef3928..86c60f118 100644
--- a/packages/stage-pages/src/pages/devtools/context-flow/index.vue
+++ b/packages/stage-pages/src/pages/devtools/context-flow/index.vue
@@ -6,19 +6,28 @@ import type { FlowDirection, FlowEntry, SparkNotifyEntryState } from './context-
 
 import { errorMessageFrom } from '@moeru/std'
 import { ContextUpdateStrategy } from '@proj-airi/server-sdk'
+import { Section } from '@proj-airi/stage-ui/components'
 import { useCharacterOrchestratorStore, useCharacterStore } from '@proj-airi/stage-ui/stores/character'
 import { useChatOrchestratorStore } from '@proj-airi/stage-ui/stores/chat'
 import { CHAT_STREAM_CHANNEL_NAME, CONTEXT_CHANNEL_NAME } from '@proj-airi/stage-ui/stores/chat/constants'
+import { formatContextPromptText } from '@proj-airi/stage-ui/stores/chat/context-prompt'
+import { useChatContextStore } from '@proj-airi/stage-ui/stores/chat/context-store'
+import { useChatSessionStore } from '@proj-airi/stage-ui/stores/chat/session-store'
+import { useContextObservabilityStore } from '@proj-airi/stage-ui/stores/devtools/context-observability'
 import { useModsServerChannelStore } from '@proj-airi/stage-ui/stores/mods/api/channel-server'
 import { getEventSourceKey } from '@proj-airi/stage-ui/utils'
-import { Callout } from '@proj-airi/ui'
 import { useBroadcastChannel } from '@vueuse/core'
 import { nanoid } from 'nanoid'
+import { storeToRefs } from 'pinia'
 import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
 import { toast } from 'vue-sonner'
 
 import ContextFlowActions from './components/context-flow-actions.vue'
+import ContextFlowActiveContexts from './components/context-flow-active-contexts.vue'
 import ContextFlowFilters from './components/context-flow-filters.vue'
+import ContextFlowLifecycle from './components/context-flow-lifecycle.vue'
+import ContextFlowPromptProjection from './components/context-flow-prompt-projection.vue'
+import ContextFlowRuntime from './components/context-flow-runtime.vue'
 import ContextFlowStream from './components/context-flow-stream.vue'
 
 import { useContextFlowFormatters } from './composables/use-context-flow-formatters'
@@ -33,9 +42,15 @@ const {
 } = useContextFlowFormatters()
 
 const chatStore = useChatOrchestratorStore()
+const chatContextStore = useChatContextStore()
+const chatSessionStore = useChatSessionStore()
 const characterStore = useCharacterStore()
 const characterOrchestratorStore = useCharacterOrchestratorStore()
+const contextObservabilityStore = useContextObservabilityStore()
 const serverChannelStore = useModsServerChannelStore()
+const { activeSessionId } = storeToRefs(chatSessionStore)
+const { connected, pendingSendCount } = storeToRefs(serverChannelStore)
+const { lastPromptProjection, lastBroadcastPostedAt, lastBroadcastReceivedAt } = storeToRefs(contextObservabilityStore)
 
 const entries = ref<FlowEntry[]>([])
 const showIncoming = ref(true)
@@ -64,6 +79,8 @@ const testSparkNotifyPayload = ref(JSON.stringify({
 const directionFilter = ref<DirectionFilter>('all')
 
 const sparkNotifyStates = ref<Map<string, SparkNotifyEntryState>>(new Map())
+const now = ref(Date.now())
+let nowTimer: ReturnType<typeof setInterval> | null = null
 
 const maxEntriesValue = computed(() => {
   const parsed = Number.parseInt(maxEntries.value, 10)
@@ -96,6 +113,10 @@ const filteredEntries = computed(() => {
   return filtered.slice().reverse()
 })
 
+const activeContextBuckets = computed(() => chatContextStore.getContextBucketsSnapshot())
+const currentPromptText = computed(() => formatContextPromptText(chatContextStore.getContextsSnapshot()))
+const pendingQueuedSends = computed(() => chatStore.getPendingQueuedSendSnapshot())
+
 function normalizePayload(payload: unknown) {
   try {
     return JSON.parse(JSON.stringify(payload)) as unknown
@@ -205,6 +226,7 @@ function pushEntry(entry: Omit<FlowEntry, 'id' | 'timestamp' | 'searchText'>) {
 
 function clearEntries() {
   entries.value = []
+  contextObservabilityStore.clearHistory()
 }
 
 function sendTestContextUpdate() {
@@ -327,6 +349,10 @@ const { data: incomingStreamEvent } = useBroadcastChannel<ChatStreamEvent, ChatS
 const cleanupFns: Array<() => void> = []
 
 onMounted(() => {
+  nowTimer = setInterval(() => {
+    now.value = Date.now()
+  }, 1000)
+
   cleanupFns.push(serverChannelStore.onContextUpdate((event) => {
     pushEntry({
       direction: 'incoming',
@@ -537,16 +563,16 @@ watch(maxEntriesValue, () => {
 onUnmounted(() => {
   for (const cleanup of cleanupFns)
     cleanup()
+
+  if (nowTimer) {
+    clearInterval(nowTimer)
+    nowTimer = null
+  }
 })
 </script>
 
 <template>
   <div :class="['flex', 'flex-col', 'gap-6']">
-    <Callout label="Context Flow">
-      Inspect incoming context updates (server + broadcast) and outgoing chat hooks in real time. Use this to verify
-      how plugin context (e.g. VSCode coding context) travels into the chat pipeline and out to server events.
-    </Callout>
-
     <div :class="['grid', 'gap-6', 'lg:grid-cols-[360px_1fr]']">
       <ContextFlowFilters
         v-model:direction-filter="directionFilter"
@@ -573,11 +599,42 @@ onUnmounted(() => {
           @send-spark-notify="sendTestSparkNotify"
         />
 
-        <ContextFlowStream
-          v-model:filter-text="filterText"
-          :entries="filteredEntries"
-          :get-spark-notify-state="getSparkNotifyEntryState"
+        <ContextFlowRuntime
+          :connected="connected"
+          :pending-send-count="pendingSendCount"
+          :pending-queued-send-count="chatStore.pendingQueuedSendCount"
+          :pending-queued-sends="pendingQueuedSends"
+          :active-session-id="activeSessionId"
+          :last-broadcast-posted-at="lastBroadcastPostedAt"
+          :last-broadcast-received-at="lastBroadcastReceivedAt"
+          :now="now"
         />
+
+        <div :class="['grid', 'gap-2', 'xl:grid-cols-2']">
+          <ContextFlowActiveContexts
+            :buckets="activeContextBuckets"
+            :filter-text="filterText"
+            :now="now"
+          />
+          <ContextFlowPromptProjection
+            :current-prompt-text="currentPromptText"
+            :current-source-count="activeContextBuckets.length"
+            :last-projection="lastPromptProjection"
+          />
+        </div>
+
+        <ContextFlowLifecycle
+          :records="contextObservabilityStore.history"
+          :filter-text="filterText"
+        />
+
+        <Section title="Raw Event Stream" icon="i-solar:inbox-line-bold-duotone" inner-class="gap-3" :expand="true">
+          <ContextFlowStream
+            v-model:filter-text="filterText"
+            :entries="filteredEntries"
+            :get-spark-notify-state="getSparkNotifyEntryState"
+          />
+        </Section>
       </div>
     </div>
   </div>
diff --git a/packages/stage-pages/src/pages/settings/modules/gaming-minecraft.vue b/packages/stage-pages/src/pages/settings/modules/gaming-minecraft.vue
index 28e22b5e1..5e7b6080a 100644
--- a/packages/stage-pages/src/pages/settings/modules/gaming-minecraft.vue
+++ b/packages/stage-pages/src/pages/settings/modules/gaming-minecraft.vue
@@ -1,78 +1,9 @@
 <script setup lang="ts">
 import { GamingMinecraft } from '@proj-airi/stage-ui/components'
-import { Callout } from '@proj-airi/ui'
 </script>
 
 <template>
-  <div space-y-4>
-    <!-- Warning Callout -->
-    <Callout theme="orange">
-      <template #label>
-        <div flex items-center gap-1 font-normal>
-          <div i-solar:danger-circle-bold-duotone text-lg />
-          <div text-base>
-            Integration Unavailable
-          </div>
-        </div>
-      </template>
-      <div text-base>
-        Minecraft bot integration is currently broken and will be fixed in the near future.
-      </div>
-    </Callout>
-
-    <!-- Instructions Section -->
-    <div bg="neutral-50 dark:neutral-900/50" rounded-lg p-4 border="~ neutral-200 dark:neutral-800">
-      <h3 text="base font-semibold mb-3 neutral-800 dark:neutral-200">
-        Experiment with the WIP Bot
-      </h3>
-
-      <ol list="decimal pl-4 space-y-2" text="sm neutral-600 dark:neutral-300">
-        <li>
-          <div>
-            <span font="medium neutral-700 dark:neutral-200">Checkout the AIRI repo</span>
-            <code text="xs neutral-500 dark:neutral-400" block>git clone https://github.com/moeru-ai/airi</code>
-          </div>
-        </li>
-        <li>
-          <div>
-            <span font="medium neutral-700 dark:neutral-200">Navigate to services/minecraft</span>
-            <code text="xs neutral-500 dark:neutral-400" block>cd services/minecraft</code>
-          </div>
-        </li>
-        <li>
-          <div>
-            <span font="medium neutral-700 dark:neutral-200">Install dependencies</span>
-            <code text="xs neutral-500 dark:neutral-400" block>pnpm install</code>
-          </div>
-        </li>
-        <li>
-          <div>
-            <span font="medium neutral-700 dark:neutral-200">Setup environment</span>
-            <code text="xs neutral-500 dark:neutral-400" block>cp .env .env.local</code>
-            <div text="xs neutral-500 dark:neutral-400" mt-1>
-              Fill in the required values in .env.local
-            </div>
-          </div>
-        </li>
-        <li>
-          <div>
-            <span font="medium neutral-700 dark:neutral-200">Run the bot</span>
-            <code text="xs neutral-500 dark:neutral-400" block>pnpm dev</code>
-          </div>
-        </li>
-      </ol>
-
-      <div bg="neutral-100 dark:neutral-800/50" mt-4 rounded p-3 text="xs neutral-500 dark:neutral-400">
-        <div flex items-start gap-2>
-          <div i-solar:info-circle-bold-duotone mt-0.5 flex-shrink-0 />
-          <div>
-            <strong>Please note:</strong> The bot is still in development and may not work as expected. We're actively working on improving it.
-          </div>
-        </div>
-      </div>
-    </div>
-    <GamingMinecraft />
-  </div>
+  <GamingMinecraft />
 </template>
 
 <route lang="yaml">
diff --git a/packages/stage-ui/src/components/modules/GamingMinecraft.vue b/packages/stage-ui/src/components/modules/GamingMinecraft.vue
index 1179d5206..183efb78c 100644
--- a/packages/stage-ui/src/components/modules/GamingMinecraft.vue
+++ b/packages/stage-ui/src/components/modules/GamingMinecraft.vue
@@ -1,14 +1,131 @@
 <script setup lang="ts">
-import GamingModuleSettings from './GamingModuleSettings.vue'
+import { Callout } from '@proj-airi/ui'
+import { storeToRefs } from 'pinia'
+import { computed, onMounted } from 'vue'
+import { useI18n } from 'vue-i18n'
 
 import { useMinecraftStore } from '../../stores/modules/gaming-minecraft'
 
 const minecraftStore = useMinecraftStore()
+const { t } = useI18n()
+
+const {
+  serviceConnected,
+  latestRuntimeContextText,
+  lastRuntimeContextAt,
+  runtimeContextAgeMs,
+  trafficEntries,
+} = storeToRefs(minecraftStore)
+
+const statusTheme = computed(() => serviceConnected.value ? 'lime' : 'orange')
+
+const statusLabel = computed(() => {
+  return serviceConnected.value
+    ? t('settings.pages.modules.gaming-minecraft.status.service-online')
+    : t('settings.pages.modules.gaming-minecraft.status.service-offline')
+})
+
+const lastRuntimeUpdate = computed(() => {
+  if (!lastRuntimeContextAt.value)
+    return t('settings.pages.modules.gaming-minecraft.status.no-runtime-context')
+
+  const seconds = Math.floor(runtimeContextAgeMs.value / 1000)
+  if (seconds > 60)
+    return t('settings.pages.modules.gaming-minecraft.status.last-context-stale')
+
+  return t('settings.pages.modules.gaming-minecraft.status.last-context-seconds', { seconds })
+})
+
+function formatTrafficTime(timestamp: number) {
+  return new Intl.DateTimeFormat(undefined, {
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  }).format(timestamp)
+}
+
+function formatTrafficPayload(payload: unknown) {
+  return JSON.stringify(payload, null, 2)
+}
+
+onMounted(() => {
+  minecraftStore.initialize()
+})
 </script>
 
 <template>
-  <GamingModuleSettings
-    :store="minecraftStore"
-    i18n-key-prefix="settings.pages.modules.gaming-minecraft"
-  />
+  <div :class="['flex flex-col gap-6']">
+    <Callout :theme="statusTheme" :label="statusLabel">
+      <div :class="['flex flex-col gap-2 text-sm']">
+        <div>
+          {{ lastRuntimeUpdate }}
+        </div>
+      </div>
+    </Callout>
+
+    <div :class="['rounded-2xl border border-neutral-200 bg-neutral-50/80 p-4 dark:border-neutral-800 dark:bg-neutral-900/50']">
+      <div :class="['mb-3 text-sm font-medium text-neutral-900 dark:text-neutral-100']">
+        {{ t('settings.pages.modules.gaming-minecraft.setup.title') }}
+      </div>
+      <div :class="['flex flex-col gap-2 text-sm text-neutral-600 dark:text-neutral-300']">
+        <p>{{ t('settings.pages.modules.gaming-minecraft.setup.description') }}</p>
+        <code :class="['w-fit rounded-md bg-neutral-950/90 px-2 py-1 text-xs text-neutral-100']">services/minecraft/README.md</code>
+      </div>
+    </div>
+
+    <div :class="['rounded-2xl border border-neutral-200 bg-neutral-50/80 p-4 dark:border-neutral-800 dark:bg-neutral-900/50']">
+      <div :class="['mb-3 text-sm font-medium text-neutral-900 dark:text-neutral-100']">
+        {{ t('settings.pages.modules.gaming-minecraft.runtime.title') }}
+      </div>
+      <div :class="['grid gap-3 text-sm text-neutral-600 dark:text-neutral-300']">
+        <div>
+          <div :class="['text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-400']">
+            {{ t('settings.pages.modules.gaming-minecraft.runtime.connection') }}
+          </div>
+          <div>{{ statusLabel }}</div>
+        </div>
+        <div>
+          <div :class="['text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-400']">
+            {{ t('settings.pages.modules.gaming-minecraft.runtime.latest-context') }}
+          </div>
+          <pre
+            :class="[
+              'mt-2 whitespace-pre-wrap rounded-lg bg-neutral-950/90 p-3 text-xs text-neutral-100',
+            ]"
+          >{{ latestRuntimeContextText || t('settings.pages.modules.gaming-minecraft.runtime.waiting') }}</pre>
+        </div>
+      </div>
+    </div>
+
+    <div :class="['rounded-2xl border border-neutral-200 bg-neutral-50/80 p-4 dark:border-neutral-800 dark:bg-neutral-900/50']">
+      <div :class="['mb-3 text-sm font-medium text-neutral-900 dark:text-neutral-100']">
+        {{ t('settings.pages.modules.gaming-minecraft.debug.title') }}
+      </div>
+      <div
+        v-if="trafficEntries.length === 0"
+        :class="['text-sm text-neutral-500 dark:text-neutral-400']"
+      >
+        {{ t('settings.pages.modules.gaming-minecraft.debug.empty') }}
+      </div>
+      <div v-else :class="['flex flex-col gap-3']">
+        <div
+          v-for="entry in [...trafficEntries].reverse()"
+          :key="entry.id"
+          :class="['rounded-xl border border-neutral-200 bg-white/80 p-3 dark:border-neutral-800 dark:bg-black/20']"
+        >
+          <div :class="['flex flex-wrap items-center justify-between gap-2 text-xs text-neutral-500 dark:text-neutral-400']">
+            <span>{{ entry.type }}</span>
+            <span>{{ formatTrafficTime(entry.receivedAt) }}</span>
+          </div>
+          <div :class="['mt-2 text-sm font-medium text-neutral-900 dark:text-neutral-100']">
+            {{ entry.summary }}
+          </div>
+          <div :class="['mt-1 text-xs text-neutral-500 dark:text-neutral-400']">
+            {{ t('settings.pages.modules.gaming-minecraft.debug.source', { source: entry.source }) }}
+          </div>
+          <pre :class="['mt-3 overflow-x-auto rounded-lg bg-neutral-950/90 p-3 text-xs text-neutral-100']">{{ formatTrafficPayload(entry.payload) }}</pre>
+        </div>
+      </div>
+    </div>
+  </div>
 </template>
diff --git a/packages/stage-ui/src/composables/use-modules-list.ts b/packages/stage-ui/src/composables/use-modules-list.ts
index 169f8be46..2bccdc974 100644
--- a/packages/stage-ui/src/composables/use-modules-list.ts
+++ b/packages/stage-ui/src/composables/use-modules-list.ts
@@ -41,6 +41,8 @@ export function useModulesList() {
   const factorioStore = useFactorioStore()
   const beatSyncState = ref<BeatSyncDetectorState>()
 
+  minecraftStore.initialize()
+
   const modulesList = computed<Module[]>(() => [
     {
       id: 'consciousness',
diff --git a/packages/stage-ui/src/stores/chat.ts b/packages/stage-ui/src/stores/chat.ts
index 97d27c44c..3e7b20445 100644
--- a/packages/stage-ui/src/stores/chat.ts
+++ b/packages/stage-ui/src/stores/chat.ts
@@ -13,11 +13,13 @@ import { ref, toRaw } from 'vue'
 import { useAnalytics } from '../composables'
 import { useLlmmarkerParser } from '../composables/llm-marker-parser'
 import { categorizeResponse, createStreamingCategorizer } from '../composables/response-categoriser'
-import { createDatetimeContext } from './chat/context-providers'
+import { buildContextPromptMessage } from './chat/context-prompt'
+import { createDatetimeContext, createMinecraftContext } from './chat/context-providers'
 import { useChatContextStore } from './chat/context-store'
 import { createChatHooks } from './chat/hooks'
 import { useChatSessionStore } from './chat/session-store'
 import { useChatStreamStore } from './chat/stream-store'
+import { useContextObservabilityStore } from './devtools/context-observability'
 import { useLLM } from './llm'
 import { useConsciousnessStore } from './modules/consciousness'
 
@@ -49,6 +51,15 @@ interface QueuedSend {
   }
 }
 
+export interface QueuedSendSnapshot {
+  sessionId: string
+  generation: number
+  cancelled: boolean
+  messagePreview: string
+  hasAttachments: boolean
+  inputType?: WebSocketEventInputs['type']
+}
+
 export const useChatOrchestratorStore = defineStore('chat-orchestrator', () => {
   const llmStore = useLLM()
   const consciousnessStore = useConsciousnessStore()
@@ -58,11 +69,13 @@ export const useChatOrchestratorStore = defineStore('chat-orchestrator', () => {
   const chatSession = useChatSessionStore()
   const chatStream = useChatStreamStore()
   const chatContext = useChatContextStore()
+  const contextObservability = useContextObservabilityStore()
   const { activeSessionId } = storeToRefs(chatSession)
   const { streamingMessage } = storeToRefs(chatStream)
 
   const sending = ref(false)
   const pendingQueuedSends = ref<QueuedSend[]>([])
+  const pendingQueuedSendCount = ref(0)
   const hooks = createChatHooks()
 
   const sendQueue = createQueue<QueuedSend>({
@@ -91,10 +104,12 @@ export const useChatOrchestratorStore = defineStore('chat-orchestrator', () => {
 
   sendQueue.on('enqueue', (queuedSend) => {
     pendingQueuedSends.value = [...pendingQueuedSends.value, queuedSend]
+    pendingQueuedSendCount.value = pendingQueuedSends.value.length
   })
 
   sendQueue.on('dequeue', (queuedSend) => {
     pendingQueuedSends.value = pendingQueuedSends.value.filter(item => item !== queuedSend)
+    pendingQueuedSendCount.value = pendingQueuedSends.value.length
   })
 
   async function performSend(
@@ -110,14 +125,29 @@ export const useChatOrchestratorStore = defineStore('chat-orchestrator', () => {
 
     // Inject current datetime context before composing the message
     chatContext.ingestContextMessage(createDatetimeContext())
+    const minecraftContext = createMinecraftContext()
+    if (minecraftContext)
+      chatContext.ingestContextMessage(minecraftContext)
 
     const sendingCreatedAt = Date.now()
+    // TODO: Expire or prune stale runtime contexts from disconnected services before composing.
+    // The Minecraft page already times out service liveness locally, but the shared chat context
+    // snapshot can still retain the last runtime context:update until we add cross-store expiry.
     const streamingMessageContext: ChatStreamEventContext = {
       message: { role: 'user', content: sendingMessage, createdAt: sendingCreatedAt, id: nanoid() },
       contexts: chatContext.getContextsSnapshot(),
       composedMessage: [],
       input: options.input,
     }
+    contextObservability.recordLifecycle({
+      phase: 'before-compose',
+      channel: 'chat',
+      sessionId,
+      textPreview: sendingMessage,
+      details: {
+        contexts: streamingMessageContext.contexts,
+      },
+    })
 
     const isStaleGeneration = () => chatSession.getSessionGeneration(sessionId) !== generation
     const shouldAbort = () => isStaleGeneration()
@@ -262,28 +292,45 @@ export const useChatOrchestratorStore = defineStore('chat-orchestrator', () => {
       })
 
       const contextsSnapshot = chatContext.getContextsSnapshot()
-      if (Object.keys(contextsSnapshot).length > 0) {
+      const contextPromptMessage = buildContextPromptMessage(contextsSnapshot)
+      if (contextPromptMessage) {
         const system = newMessages.slice(0, 1)
         const afterSystem = newMessages.slice(1, newMessages.length)
 
         newMessages = [
           ...system,
-          {
-            role: 'user',
-            content: [
-              {
-                type: 'text',
-                text: ''
-                  + 'These are the contextual information retrieved or on-demand updated from other modules, you may use them as context for chat, or reference of the next action, tool call, etc.:\n'
-                  + `${Object.entries(contextsSnapshot).map(([key, value]) => `Module ${key}: ${JSON.stringify(value)}`).join('\n')}\n`,
-              },
-            ],
-          },
+          contextPromptMessage,
           ...afterSystem,
         ]
+
+        contextObservability.recordLifecycle({
+          phase: 'prompt-context-built',
+          channel: 'chat',
+          sessionId,
+          details: {
+            contexts: contextsSnapshot,
+            promptMessage: contextPromptMessage,
+          },
+        })
       }
 
       streamingMessageContext.composedMessage = newMessages as Message[]
+      contextObservability.capturePromptProjection({
+        sessionId,
+        message: sendingMessage,
+        contexts: contextsSnapshot,
+        promptMessage: contextPromptMessage,
+        composedMessage: newMessages as Message[],
+      })
+      contextObservability.recordLifecycle({
+        phase: 'after-compose',
+        channel: 'chat',
+        sessionId,
+        textPreview: sendingMessage,
+        details: {
+          composedMessage: newMessages,
+        },
+      })
 
       await hooks.emitAfterMessageComposedHooks(sendingMessage, streamingMessageContext)
       await hooks.emitBeforeSendHooks(sendingMessage, streamingMessageContext)
@@ -408,14 +455,28 @@ export const useChatOrchestratorStore = defineStore('chat-orchestrator', () => {
     pendingQueuedSends.value = sessionId
       ? pendingQueuedSends.value.filter(item => item.sessionId !== sessionId)
       : []
+    pendingQueuedSendCount.value = pendingQueuedSends.value.length
+  }
+
+  function getPendingQueuedSendSnapshot() {
+    return pendingQueuedSends.value.map(queued => ({
+      sessionId: queued.sessionId,
+      generation: queued.generation,
+      cancelled: !!queued.cancelled,
+      messagePreview: queued.sendingMessage.slice(0, 120),
+      hasAttachments: !!queued.options.attachments?.length,
+      inputType: queued.options.input?.type,
+    } satisfies QueuedSendSnapshot))
   }
 
   return {
     sending,
+    pendingQueuedSendCount,
 
     ingest,
     ingestOnFork,
     cancelPendingSends,
+    getPendingQueuedSendSnapshot,
 
     clearHooks: hooks.clearHooks,
 
diff --git a/packages/stage-ui/src/stores/chat/context-prompt.ts b/packages/stage-ui/src/stores/chat/context-prompt.ts
new file mode 100644
index 000000000..81a9a66e6
--- /dev/null
+++ b/packages/stage-ui/src/stores/chat/context-prompt.ts
@@ -0,0 +1,30 @@
+import type { UserMessage } from '@xsai/shared-chat'
+
+import type { ContextMessage } from '../../types/chat'
+
+export type ContextSnapshot = Record<string, ContextMessage[]>
+
+export function formatContextPromptText(contextsSnapshot: ContextSnapshot) {
+  if (Object.keys(contextsSnapshot).length === 0)
+    return ''
+
+  return ''
+    + 'These are the contextual information retrieved or on-demand updated from other modules, you may use them as context for chat, or reference of the next action, tool call, etc.:\n'
+    + `${Object.entries(contextsSnapshot).map(([key, value]) => `Module ${key}: ${JSON.stringify(value)}`).join('\n')}\n`
+}
+
+export function buildContextPromptMessage(contextsSnapshot: ContextSnapshot): UserMessage | null {
+  const promptText = formatContextPromptText(contextsSnapshot)
+  if (!promptText)
+    return null
+
+  return {
+    role: 'user',
+    content: [
+      {
+        type: 'text',
+        text: promptText,
+      },
+    ],
+  }
+}
diff --git a/packages/stage-ui/src/stores/chat/context-providers/index.ts b/packages/stage-ui/src/stores/chat/context-providers/index.ts
index a4221dc1f..0dfa151d3 100644
--- a/packages/stage-ui/src/stores/chat/context-providers/index.ts
+++ b/packages/stage-ui/src/stores/chat/context-providers/index.ts
@@ -1 +1,2 @@
 export { createDatetimeContext } from './datetime'
+export { createMinecraftContext } from './minecraft'
diff --git a/packages/stage-ui/src/stores/chat/context-providers/minecraft.ts b/packages/stage-ui/src/stores/chat/context-providers/minecraft.ts
new file mode 100644
index 000000000..102c70a77
--- /dev/null
+++ b/packages/stage-ui/src/stores/chat/context-providers/minecraft.ts
@@ -0,0 +1,39 @@
+import type { ContextMessage } from '../../../types/chat'
+
+import { ContextUpdateStrategy } from '@proj-airi/server-sdk'
+import { nanoid } from 'nanoid'
+
+import { useMinecraftStore } from '../../modules/gaming-minecraft'
+
+const MINECRAFT_CONTEXT_ID = 'system:minecraft-integration'
+
+export function createMinecraftContext(): ContextMessage | null {
+  const minecraftStore = useMinecraftStore()
+  minecraftStore.initialize()
+
+  if (!minecraftStore.configured)
+    return null
+
+  const serviceStatus = minecraftStore.serviceConnected ? 'online' : 'offline'
+  const runtimeContextText = minecraftStore.latestRuntimeContextText.trim()
+
+  return {
+    id: nanoid(),
+    contextId: MINECRAFT_CONTEXT_ID,
+    strategy: ContextUpdateStrategy.ReplaceSelf,
+    text: [
+      'Minecraft integration is active because AIRI has observed a Minecraft service.',
+      'AIRI can oversee a connected Minecraft bot through AIRI server events.',
+      'Minecraft can send status and context upward, and AIRI can send high-level guidance back down.',
+      'Minecraft context updates are side context for the next turn and do not automatically trigger a new LLM response.',
+      `Minecraft service is currently ${serviceStatus}.`,
+      runtimeContextText
+        ? `Latest Minecraft bot context: ${runtimeContextText}`
+        : 'No live Minecraft bot context has been pushed yet.',
+      serviceStatus === 'online'
+        ? 'The Minecraft service is online, but AIRI should still rely on live bot context before assuming the bot can act.'
+        : 'Do not assume the Minecraft bot can act right now unless fresh bot context confirms it.',
+    ].join(' '),
+    createdAt: Date.now(),
+  }
+}
diff --git a/packages/stage-ui/src/stores/chat/context-store.ts b/packages/stage-ui/src/stores/chat/context-store.ts
index 1fd8b6fee..7a1e9e6b6 100644
--- a/packages/stage-ui/src/stores/chat/context-store.ts
+++ b/packages/stage-ui/src/stores/chat/context-store.ts
@@ -6,6 +6,19 @@ import { ref, toRaw } from 'vue'
 
 import { getEventSourceKey } from '../../utils/event-source'
 
+export interface ContextBucketSnapshot {
+  sourceKey: string
+  entryCount: number
+  latestCreatedAt?: number
+  messages: ContextMessage[]
+}
+
+export interface ContextIngestResult {
+  sourceKey: string
+  mutation: 'replace' | 'append'
+  entryCount: number
+}
+
 export interface ContextHistoryEntry extends ContextMessage {
   sourceKey: string
 }
@@ -16,26 +29,61 @@ export const useChatContextStore = defineStore('chat-context', () => {
   const activeContexts = ref<Record<string, ContextMessage[]>>({})
   const contextHistory = ref<ContextHistoryEntry[]>([])
 
+  function cloneMessage(message: ContextMessage): ContextMessage {
+    const rawMessage = toRaw(message)
+
+    try {
+      return structuredClone(rawMessage)
+    }
+    catch {
+      return JSON.parse(JSON.stringify(rawMessage)) as ContextMessage
+    }
+  }
+
+  function cloneSnapshot() {
+    return Object.fromEntries(
+      Object.entries(activeContexts.value).map(([sourceKey, messages]) => [
+        sourceKey,
+        messages.map(cloneMessage),
+      ]),
+    )
+  }
+
   function ingestContextMessage(envelope: ContextMessage) {
-    const sourceKey = getEventSourceKey(envelope)
+    const normalizedEnvelope = cloneMessage(envelope)
+    const sourceKey = getEventSourceKey(normalizedEnvelope)
+    let result: ContextIngestResult | undefined
+
     if (!activeContexts.value[sourceKey]) {
       activeContexts.value[sourceKey] = []
     }
 
-    if (envelope.strategy === ContextUpdateStrategy.ReplaceSelf) {
-      activeContexts.value[sourceKey] = [envelope]
+    if (normalizedEnvelope.strategy === ContextUpdateStrategy.ReplaceSelf) {
+      activeContexts.value[sourceKey] = [normalizedEnvelope]
+      result = {
+        sourceKey,
+        mutation: 'replace',
+        entryCount: activeContexts.value[sourceKey].length,
+      } satisfies ContextIngestResult
     }
-    else if (envelope.strategy === ContextUpdateStrategy.AppendSelf) {
-      activeContexts.value[sourceKey].push(envelope)
+    else if (normalizedEnvelope.strategy === ContextUpdateStrategy.AppendSelf) {
+      activeContexts.value[sourceKey].push(normalizedEnvelope)
+      result = {
+        sourceKey,
+        mutation: 'append',
+        entryCount: activeContexts.value[sourceKey].length,
+      } satisfies ContextIngestResult
     }
 
     contextHistory.value = [
       ...contextHistory.value,
       {
-        ...envelope,
+        ...normalizedEnvelope,
         sourceKey,
       },
     ].slice(-CONTEXT_HISTORY_LIMIT)
+
+    return result
   }
 
   function resetContexts() {
@@ -44,13 +92,27 @@ export const useChatContextStore = defineStore('chat-context', () => {
   }
 
   function getContextsSnapshot() {
-    return toRaw(activeContexts.value)
+    return cloneSnapshot()
+  }
+
+  function getContextBucketsSnapshot() {
+    return Object.entries(activeContexts.value).map(([sourceKey, messages]) => ({
+      sourceKey,
+      entryCount: messages.length,
+      latestCreatedAt: messages.reduce<number | undefined>((latest, message) => {
+        if (!latest)
+          return message.createdAt
+        return Math.max(latest, message.createdAt)
+      }, undefined),
+      messages: messages.map(cloneMessage),
+    } satisfies ContextBucketSnapshot))
   }
 
   return {
     ingestContextMessage,
     resetContexts,
     getContextsSnapshot,
+    getContextBucketsSnapshot,
     activeContexts,
     contextHistory,
   }
diff --git a/packages/stage-ui/src/stores/devtools/context-observability.ts b/packages/stage-ui/src/stores/devtools/context-observability.ts
new file mode 100644
index 000000000..a17486eca
--- /dev/null
+++ b/packages/stage-ui/src/stores/devtools/context-observability.ts
@@ -0,0 +1,122 @@
+import type { ContextUpdateStrategy } from '@proj-airi/server-sdk'
+import type { Message } from '@xsai/shared-chat'
+
+import type { ContextMessage } from '../../types/chat'
+
+import { nanoid } from 'nanoid'
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+
+import { formatContextPromptText } from '../chat/context-prompt'
+
+export type ContextLifecyclePhase
+  = | 'server-received'
+    | 'input-context-update'
+    | 'broadcast-posted'
+    | 'broadcast-received'
+    | 'store-ingested'
+    | 'before-compose'
+    | 'prompt-context-built'
+    | 'after-compose'
+
+export interface ContextLifecycleRecord {
+  id: string
+  timestamp: number
+  phase: ContextLifecyclePhase
+  channel: 'server' | 'broadcast' | 'chat' | 'input'
+  sourceKey?: string
+  sessionId?: string
+  strategy?: ContextUpdateStrategy
+  lane?: string
+  contextId?: string
+  eventId?: string
+  mutation?: 'replace' | 'append'
+  textPreview?: string
+  sourceLabel?: string
+  details?: unknown
+}
+
+export interface PromptProjectionSnapshot {
+  capturedAt: number
+  sessionId: string
+  message: string
+  contexts: Record<string, ContextMessage[]>
+  promptText: string
+  promptMessage?: Message
+  composedMessage?: Message[]
+}
+
+const DEFAULT_MAX_HISTORY = 200
+
+function truncateText(value: string, limit = 220) {
+  if (value.length <= limit)
+    return value
+  return `${value.slice(0, limit)}...`
+}
+
+function cloneValue<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T
+}
+
+export const useContextObservabilityStore = defineStore('devtools:context-observability', () => {
+  const history = ref<ContextLifecycleRecord[]>([])
+  const maxHistory = ref(DEFAULT_MAX_HISTORY)
+  const lastPromptProjection = ref<PromptProjectionSnapshot>()
+  const lastBroadcastPostedAt = ref<number>()
+  const lastBroadcastReceivedAt = ref<number>()
+
+  function recordLifecycle(record: Omit<ContextLifecycleRecord, 'id' | 'timestamp' | 'textPreview'> & { textPreview?: string }) {
+    const nextRecord: ContextLifecycleRecord = {
+      id: nanoid(),
+      timestamp: Date.now(),
+      ...record,
+      textPreview: record.textPreview ? truncateText(record.textPreview) : undefined,
+      details: record.details === undefined ? undefined : cloneValue(record.details),
+    }
+
+    history.value.unshift(nextRecord)
+    if (history.value.length > maxHistory.value) {
+      history.value.splice(maxHistory.value)
+    }
+
+    if (record.phase === 'broadcast-posted')
+      lastBroadcastPostedAt.value = nextRecord.timestamp
+    if (record.phase === 'broadcast-received')
+      lastBroadcastReceivedAt.value = nextRecord.timestamp
+
+    return nextRecord
+  }
+
+  function capturePromptProjection(payload: {
+    sessionId: string
+    message: string
+    contexts: Record<string, ContextMessage[]>
+    promptMessage?: Message | null
+    composedMessage?: Message[]
+  }) {
+    lastPromptProjection.value = {
+      capturedAt: Date.now(),
+      sessionId: payload.sessionId,
+      message: payload.message,
+      contexts: cloneValue(payload.contexts),
+      promptText: formatContextPromptText(payload.contexts),
+      promptMessage: payload.promptMessage ? cloneValue(payload.promptMessage) : undefined,
+      composedMessage: payload.composedMessage ? cloneValue(payload.composedMessage) : undefined,
+    }
+  }
+
+  function clearHistory() {
+    history.value = []
+  }
+
+  return {
+    history,
+    maxHistory,
+    lastPromptProjection,
+    lastBroadcastPostedAt,
+    lastBroadcastReceivedAt,
+    recordLifecycle,
+    capturePromptProjection,
+    clearHistory,
+  }
+})
diff --git a/packages/stage-ui/src/stores/llm.ts b/packages/stage-ui/src/stores/llm.ts
index b70696670..e3e2af43a 100644
--- a/packages/stage-ui/src/stores/llm.ts
+++ b/packages/stage-ui/src/stores/llm.ts
@@ -1,12 +1,18 @@
+import type { WebSocketEvents } from '@proj-airi/server-sdk'
 import type { ChatProvider } from '@xsai-ext/providers/utils'
 import type { CommonContentPart, CompletionToolCall, Message, Tool } from '@xsai/shared-chat'
 
+import { ContextUpdateStrategy } from '@proj-airi/server-sdk'
 import { listModels } from '@xsai/model'
 import { streamText } from '@xsai/stream-text'
+import { tool } from '@xsai/tool'
+import { nanoid } from 'nanoid'
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
+import { z } from 'zod/v4'
 
 import { debug, mcp } from '../tools'
+import { useModsServerChannelStore } from './mods/api/channel-server'
 
 export type StreamEvent
   = | { type: 'text-delta', text: string }
@@ -52,7 +58,51 @@ function streamOptionsToolsCompatibilityOk(model: string, chatProvider: ChatProv
   return options?.toolsCompatibility?.get(key) !== false
 }
 
-async function streamFrom(model: string, chatProvider: ChatProvider, messages: Message[], options?: StreamOptions) {
+const sparkCommandGuidanceOptionSchema = z.object({
+  label: z.string().describe('Short label for the option.'),
+  steps: z.array(z.string()).min(1).describe('Step-by-step actions the target should follow.'),
+  rationale: z.string().optional().describe('Why this option makes sense.'),
+  possibleOutcome: z.array(z.string()).optional().describe('Expected outcomes if this option is followed.'),
+  risk: z.enum(['high', 'medium', 'low', 'none']).optional().describe('Risk level of this option.'),
+  fallback: z.array(z.string()).optional().describe('Fallback steps if the main plan fails.'),
+  triggers: z.array(z.string()).optional().describe('Conditions that should trigger this option.'),
+}).strict()
+
+const sparkCommandContextSchema = z.object({
+  lane: z.string().optional().describe('Logical context lane, for example "game" or "memory".'),
+  ideas: z.array(z.string()).optional().describe('Loose ideas to attach to the target context.'),
+  hints: z.array(z.string()).optional().describe('Hints to attach to the target context.'),
+  strategy: z.nativeEnum(ContextUpdateStrategy).describe('How the target should merge this context update.'),
+  text: z.string().describe('Primary text of the context update.'),
+  destinations: z.union([
+    z.array(z.string()),
+    z.object({
+      all: z.literal(true),
+    }).strict(),
+    z.object({
+      include: z.array(z.string()).optional(),
+      exclude: z.array(z.string()).optional(),
+    }).strict(),
+  ]).optional().describe('Optional routing for the attached context update.'),
+  metadata: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()])).optional().describe('JSON-like metadata for the context update.'),
+}).strict()
+
+const sparkCommandToolSchema = z.object({
+  destinations: z.array(z.string()).min(1).describe('One or more target module or agent IDs for this command.'),
+  interrupt: z.union([z.literal('force'), z.literal('soft'), z.literal(false)]).optional().describe('Whether the command should preempt current work.'),
+  priority: z.enum(['critical', 'high', 'normal', 'low']).optional().describe('Priority of the command.'),
+  intent: z.enum(['plan', 'proposal', 'action', 'pause', 'resume', 'reroute', 'context']).optional().describe('Intent of the command.'),
+  ack: z.string().optional().describe('Short acknowledgement or instruction summary for the receiver.'),
+  parentEventId: z.string().optional().describe('Optional parent event ID when this command is a response to another event.'),
+  guidance: z.object({
+    type: z.enum(['proposal', 'instruction', 'memory-recall']),
+    persona: z.record(z.string(), z.enum(['very-high', 'high', 'medium', 'low', 'very-low'])).optional().describe('Persona traits that shape the target behavior.'),
+    options: z.array(sparkCommandGuidanceOptionSchema).min(1).describe('Concrete execution options for the target.'),
+  }).strict().optional().describe('Structured guidance for how the target should interpret and execute the command.'),
+  contexts: z.array(sparkCommandContextSchema).optional().describe('Optional context updates to attach to the command.'),
+}).strict()
+
+async function streamFrom(model: string, chatProvider: ChatProvider, messages: Message[], sendSparkCommand: (command: WebSocketEvents['spark:command']) => void, options?: StreamOptions) {
   const chatConfig = chatProvider.chat(model)
   const sanitized = sanitizeMessages(messages as unknown[])
 
@@ -69,6 +119,40 @@ async function streamFrom(model: string, chatProvider: ChatProvider, messages: M
         ...await mcp(),
         ...await debug(),
         ...await resolveTools(),
+        await tool({
+          name: 'call_spark_command',
+          description: 'Send a spark:command to one or more frontend-connected modules or sub-agents.',
+          parameters: sparkCommandToolSchema,
+          execute: async (payload) => {
+            const command = {
+              id: nanoid(),
+              eventId: nanoid(),
+              parentEventId: payload.parentEventId,
+              commandId: nanoid(),
+              interrupt: payload.interrupt ?? false,
+              priority: payload.priority ?? 'normal',
+              intent: payload.intent ?? 'action',
+              ack: payload.ack,
+              guidance: payload.guidance,
+              contexts: payload.contexts?.map(context => ({
+                id: nanoid(),
+                contextId: nanoid(),
+                lane: context.lane,
+                ideas: context.ideas,
+                hints: context.hints,
+                strategy: context.strategy,
+                text: context.text,
+                destinations: context.destinations,
+                metadata: context.metadata,
+              })),
+              destinations: payload.destinations,
+            } satisfies WebSocketEvents['spark:command']
+
+            sendSparkCommand(command)
+
+            return `spark:command sent (${command.commandId}) to ${command.destinations.join(', ')}`
+          },
+        }),
       ]
     : undefined
 
@@ -152,6 +236,7 @@ export function isToolRelatedError(err: unknown): boolean {
 
 export const useLLM = defineStore('llm', () => {
   const toolsCompatibility = ref<Map<string, boolean>>(new Map())
+  const modsServerChannelStore = useModsServerChannelStore()
 
   function modelKey(model: string, chatProvider: ChatProvider): string {
     return `${chatProvider.chat(model).baseURL}-${model}`
@@ -160,7 +245,27 @@ export const useLLM = defineStore('llm', () => {
   async function stream(model: string, chatProvider: ChatProvider, messages: Message[], options?: StreamOptions) {
     const key = modelKey(model, chatProvider)
     try {
-      await streamFrom(model, chatProvider, messages, { ...options, toolsCompatibility: toolsCompatibility.value })
+      await streamFrom(
+        model,
+        chatProvider,
+        messages,
+        // TODO(@nekomeowww,@shinohara-rin): we should not register the command callback on every stream anyway...
+        (command) => {
+          // TODO(@nekomeowww): instruct the LLM to understand what destination is.
+          // Currently without skill like prompt injection, many issues occur.
+          // destination mostly are wrong or hallucinated, we need to find a way to make it more reliable.
+          //
+          // For now, since destinations as array will always broadcast to all connected modules/agents, we can set it to
+          // empty array to avoid wrong routing.
+          command.destinations = []
+
+          modsServerChannelStore.send({
+            type: 'spark:command',
+            data: command,
+          })
+        },
+        { ...options, toolsCompatibility: toolsCompatibility.value },
+      )
     }
     catch (err) {
       if (isToolRelatedError(err)) {
diff --git a/packages/stage-ui/src/stores/mods/api/channel-server.ts b/packages/stage-ui/src/stores/mods/api/channel-server.ts
index ff47531d8..a0ead318a 100644
--- a/packages/stage-ui/src/stores/mods/api/channel-server.ts
+++ b/packages/stage-ui/src/stores/mods/api/channel-server.ts
@@ -6,29 +6,49 @@ import { isStageTamagotchi, isStageWeb } from '@proj-airi/stage-shared'
 import { useLocalStorage } from '@vueuse/core'
 import { nanoid } from 'nanoid'
 import { defineStore } from 'pinia'
-import { ref, watch } from 'vue'
+import { computed, ref, watch } from 'vue'
 
 import { useWebSocketInspectorStore } from '../../devtools/websocket-inspector'
 
+interface ChannelListenerEntry {
+  type: keyof WebSocketEvents
+  callback: (event: WebSocketBaseEvent<any, any>) => void | Promise<void>
+  boundClient?: Client
+}
+
+const REPLAYABLE_EVENT_TYPES = new Set<keyof WebSocketEvents>([
+  'module:announced',
+  'module:de-announced',
+  'registry:modules:health:healthy',
+  'registry:modules:health:unhealthy',
+  'registry:modules:sync',
+])
+
 export const useModsServerChannelStore = defineStore('mods:channels:proj-airi:server', () => {
   const connected = ref(false)
   const client = ref<Client>()
   const initializing = ref<Promise<void> | null>(null)
   const pendingSend = ref<Array<WebSocketEvent>>([])
-  const listenersInitialized = ref(false)
-  const listenerDisposers = ref<Array<() => void>>([])
+  const pendingSendCount = computed(() => pendingSend.value.length)
 
   const defaultWebSocketUrl = import.meta.env.VITE_AIRI_WS_URL || 'ws://localhost:6121/ws'
   const websocketUrl = useLocalStorage('settings/connection/websocket-url', defaultWebSocketUrl)
+  const registeredListeners: ChannelListenerEntry[] = []
+  const replayableEvents = new Map<keyof WebSocketEvents, WebSocketBaseEvent<any, any>>()
 
   const basePossibleEvents: Array<keyof WebSocketEvents> = [
     'context:update',
     'error',
     'module:announce',
+    'module:announced',
     'module:configure',
+    'module:de-announced',
     'module:consumer:register',
     'module:consumer:unregister',
     'module:authenticated',
+    'registry:modules:health:healthy',
+    'registry:modules:health:unhealthy',
+    'registry:modules:sync',
     'spark:notify',
     'spark:emit',
     'spark:command',
@@ -58,6 +78,9 @@ export const useModsServerChannelStore = defineStore('mods:channels:proj-airi:se
         token: options?.token,
         possibleEvents,
         onAnyMessage: (event) => {
+          if (REPLAYABLE_EVENT_TYPES.has(event.type as keyof WebSocketEvents))
+            replayableEvents.set(event.type as keyof WebSocketEvents, event as WebSocketBaseEvent<any, any>)
+
           useWebSocketInspectorStore().add('incoming', event)
         },
         onAnySend: (event) => {
@@ -67,6 +90,7 @@ export const useModsServerChannelStore = defineStore('mods:channels:proj-airi:se
           connected.value = false
           initializing.value = null
           clearListeners()
+          replayableEvents.clear()
 
           console.warn('WebSocket server connection error:', error)
         },
@@ -74,6 +98,7 @@ export const useModsServerChannelStore = defineStore('mods:channels:proj-airi:se
           connected.value = false
           initializing.value = null
           clearListeners()
+          replayableEvents.clear()
 
           console.warn('WebSocket server connection closed')
         },
@@ -105,23 +130,54 @@ export const useModsServerChannelStore = defineStore('mods:channels:proj-airi:se
   }
 
   function clearListeners() {
-    for (const disposer of listenerDisposers.value) {
-      try {
-        disposer()
-      }
-      catch (error) {
-        console.warn('Failed to dispose channel listener:', error)
+    for (const listener of registeredListeners) {
+      if (listener.boundClient) {
+        listener.boundClient.offEvent(listener.type, listener.callback as any)
+        listener.boundClient = undefined
       }
     }
-    listenerDisposers.value = []
-    listenersInitialized.value = false
   }
 
   function initializeListeners() {
     if (!client.value)
-      // No-op for now; keep placeholder for future shared listeners.
-      // eslint-disable-next-line no-useless-return
       return
+
+    for (const listener of registeredListeners) {
+      if (listener.boundClient === client.value)
+        continue
+
+      listener.boundClient?.offEvent(listener.type, listener.callback as any)
+      client.value.onEvent(listener.type, listener.callback as any)
+      listener.boundClient = client.value
+    }
+  }
+
+  function registerListener<E extends keyof WebSocketEvents>(
+    type: E,
+    callback: (event: WebSocketBaseEvent<E, WebSocketEvents[E]>) => void | Promise<void>,
+  ) {
+    if (!client.value && !initializing.value)
+      void initialize()
+
+    const entry: ChannelListenerEntry = {
+      type,
+      callback: callback as any,
+    }
+    registeredListeners.push(entry)
+    initializeListeners()
+
+    const replayableEvent = replayableEvents.get(type)
+    if (replayableEvent)
+      void Promise.resolve(callback(replayableEvent as WebSocketBaseEvent<E, WebSocketEvents[E]>))
+
+    return () => {
+      const index = registeredListeners.indexOf(entry)
+      if (index >= 0)
+        registeredListeners.splice(index, 1)
+
+      entry.boundClient?.offEvent(type, callback as any)
+      entry.boundClient = undefined
+    }
   }
 
   function send<C = undefined>(data: WebSocketEventOptionalSource<C>) {
@@ -146,29 +202,15 @@ export const useModsServerChannelStore = defineStore('mods:channels:proj-airi:se
     }
   }
 
-  function onContextUpdate(callback: (event: WebSocketBaseEvent<'context:update', ContextUpdate<Record<string, unknown>, string | CommonContentPart[]>>) => void | Promise<void>) {
-    if (!client.value && !initializing.value)
-      void initialize()
-
-    client.value?.onEvent('context:update', callback as any)
-
-    return () => {
-      client.value?.offEvent('context:update', callback as any)
-    }
+  function onContextUpdate(callback: (event: WebSocketBaseEvent<'context:update', ContextUpdate>) => void | Promise<void>) {
+    return registerListener('context:update', callback)
   }
 
   function onEvent<E extends keyof WebSocketEvents>(
     type: E,
     callback: (event: WebSocketBaseEvent<E, WebSocketEvents[E]>) => void | Promise<void>,
   ) {
-    if (!client.value && !initializing.value)
-      void initialize()
-
-    client.value?.onEvent(type, callback as any)
-
-    return () => {
-      client.value?.offEvent(type, callback as any)
-    }
+    return registerListener(type, callback)
   }
 
   function sendContextUpdate(message: InputContextUpdate) {
@@ -182,6 +224,7 @@ export const useModsServerChannelStore = defineStore('mods:channels:proj-airi:se
   function dispose() {
     flush()
     clearListeners()
+    replayableEvents.clear()
 
     if (client.value) {
       client.value.close()
@@ -203,6 +246,7 @@ export const useModsServerChannelStore = defineStore('mods:channels:proj-airi:se
 
   return {
     connected,
+    pendingSendCount,
     ensureConnected,
 
     initialize,
@@ -210,6 +254,7 @@ export const useModsServerChannelStore = defineStore('mods:channels:proj-airi:se
     sendContextUpdate,
     onContextUpdate,
     onEvent,
+    getPendingSendSnapshot: () => [...pendingSend.value],
     dispose,
   }
 })
diff --git a/packages/stage-ui/src/stores/mods/api/context-bridge.ts b/packages/stage-ui/src/stores/mods/api/context-bridge.ts
index 93609c2da..08b4753df 100644
--- a/packages/stage-ui/src/stores/mods/api/context-bridge.ts
+++ b/packages/stage-ui/src/stores/mods/api/context-bridge.ts
@@ -10,11 +10,13 @@ import { nanoid } from 'nanoid'
 import { defineStore, storeToRefs } from 'pinia'
 import { ref, toRaw, watch } from 'vue'
 
+import { getEventSourceKey } from '../../../utils/event-source'
 import { useChatOrchestratorStore } from '../../chat'
 import { CHAT_STREAM_CHANNEL_NAME, CONTEXT_CHANNEL_NAME } from '../../chat/constants'
 import { useChatContextStore } from '../../chat/context-store'
 import { useChatSessionStore } from '../../chat/session-store'
 import { useChatStreamStore } from '../../chat/stream-store'
+import { useContextObservabilityStore } from '../../devtools/context-observability'
 import { useConsciousnessStore } from '../../modules/consciousness'
 import { useProvidersStore } from '../../providers'
 import { useModsServerChannelStore } from './channel-server'
@@ -46,6 +48,7 @@ export const useContextBridgeStore = defineStore('mods:api:context-bridge', () =
   const chatStream = useChatStreamStore()
   const chatContext = useChatContextStore()
   const serverChannelStore = useModsServerChannelStore()
+  const contextObservability = useContextObservabilityStore()
   const consciousnessStore = useConsciousnessStore()
   const providersStore = useProvidersStore()
   const { activeProvider, activeModel } = storeToRefs(consciousnessStore)
@@ -76,19 +79,93 @@ export const useContextBridgeStore = defineStore('mods:api:context-bridge', () =
       let isProcessingRemoteStream = false
 
       const { stop } = watch(incomingContext, (event) => {
-        if (event)
-          chatContext.ingestContextMessage(event)
+        if (!event)
+          return
+
+        contextObservability.recordLifecycle({
+          phase: 'broadcast-received',
+          channel: 'broadcast',
+          sourceKey: getEventSourceKey(event),
+          strategy: event.strategy,
+          lane: event.lane,
+          contextId: event.contextId,
+          eventId: event.id,
+          textPreview: event.text,
+          sourceLabel: event.metadata?.source?.plugin?.id ?? event.metadata?.source?.id,
+          details: event,
+        })
+        const result = chatContext.ingestContextMessage(event)
+        if (result) {
+          contextObservability.recordLifecycle({
+            phase: 'store-ingested',
+            channel: 'broadcast',
+            sourceKey: result.sourceKey,
+            strategy: event.strategy,
+            lane: event.lane,
+            contextId: event.contextId,
+            eventId: event.id,
+            mutation: result.mutation,
+            textPreview: event.text,
+            sourceLabel: event.metadata?.source?.plugin?.id ?? event.metadata?.source?.id,
+            details: {
+              entryCount: result.entryCount,
+              event,
+            },
+          })
+        }
       })
       disposeHookFns.value.push(stop)
 
       disposeHookFns.value.push(serverChannelStore.onContextUpdate((event) => {
+        contextObservability.recordLifecycle({
+          phase: 'server-received',
+          channel: 'server',
+          sourceKey: getEventSourceKey(event),
+          strategy: event.data.strategy,
+          lane: event.data.lane,
+          contextId: event.data.contextId,
+          eventId: event.data.id,
+          textPreview: event.data.text,
+          sourceLabel: event.metadata?.source?.plugin?.id ?? event.metadata?.source?.id ?? event.source,
+          details: event,
+        })
         const contextMessage: ContextMessage = {
           ...event.data,
           metadata: event.metadata,
           createdAt: Date.now(),
         }
-        chatContext.ingestContextMessage(contextMessage)
+        const result = chatContext.ingestContextMessage(contextMessage)
+        if (result) {
+          contextObservability.recordLifecycle({
+            phase: 'store-ingested',
+            channel: 'server',
+            sourceKey: result.sourceKey,
+            strategy: contextMessage.strategy,
+            lane: contextMessage.lane,
+            contextId: contextMessage.contextId,
+            eventId: contextMessage.id,
+            mutation: result.mutation,
+            textPreview: contextMessage.text,
+            sourceLabel: event.metadata?.source?.plugin?.id ?? event.metadata?.source?.id ?? event.source,
+            details: {
+              entryCount: result.entryCount,
+              event,
+            },
+          })
+        }
         broadcastContext(toRaw(contextMessage))
+        contextObservability.recordLifecycle({
+          phase: 'broadcast-posted',
+          channel: 'broadcast',
+          sourceKey: getEventSourceKey(contextMessage),
+          strategy: contextMessage.strategy,
+          lane: contextMessage.lane,
+          contextId: contextMessage.contextId,
+          eventId: contextMessage.id,
+          textPreview: contextMessage.text,
+          sourceLabel: event.metadata?.source?.plugin?.id ?? event.metadata?.source?.id ?? event.source,
+          details: contextMessage,
+        })
       }))
 
       disposeHookFns.value.push(serverChannelStore.onEvent('input:text', async (event) => {
@@ -112,11 +189,45 @@ export const useContextBridgeStore = defineStore('mods:api:context-bridge', () =
         if (normalizedContextUpdates?.length) {
           const createdAt = Date.now()
           for (const update of normalizedContextUpdates) {
-            chatContext.ingestContextMessage({
+            contextObservability.recordLifecycle({
+              phase: 'input-context-update',
+              channel: 'input',
+              strategy: update.strategy,
+              lane: update.lane,
+              contextId: update.contextId,
+              eventId: update.id,
+              textPreview: update.text,
+              sourceLabel: event.metadata?.source?.plugin?.id ?? event.metadata?.source?.id ?? event.source,
+              details: {
+                inputType: event.type,
+                update,
+              },
+            })
+            const contextMessage = {
               ...update,
               metadata: event.metadata,
               createdAt,
-            })
+            }
+            const result = chatContext.ingestContextMessage(contextMessage)
+            if (result) {
+              contextObservability.recordLifecycle({
+                phase: 'store-ingested',
+                channel: 'input',
+                sourceKey: result.sourceKey,
+                strategy: contextMessage.strategy,
+                lane: contextMessage.lane,
+                contextId: contextMessage.contextId,
+                eventId: contextMessage.id,
+                mutation: result.mutation,
+                textPreview: contextMessage.text,
+                sourceLabel: event.metadata?.source?.plugin?.id ?? event.metadata?.source?.id ?? event.source,
+                details: {
+                  entryCount: result.entryCount,
+                  inputType: event.type,
+                  update: contextMessage,
+                },
+              })
+            }
           }
         }
 
@@ -244,7 +355,7 @@ export const useContextBridgeStore = defineStore('mods:api:context-bridge', () =
               'gen-ai:chat': {
                 message: context.message as UserMessage,
                 composedMessage: context.composedMessage,
-                contexts: context.contexts,
+                contexts: context.contexts as any,
                 input: context.input,
               },
             },
@@ -271,7 +382,7 @@ export const useContextBridgeStore = defineStore('mods:api:context-bridge', () =
               'gen-ai:chat': {
                 message: context.message as UserMessage,
                 composedMessage: context.composedMessage,
-                contexts: context.contexts,
+                contexts: context.contexts as any,
                 input: context.input,
               },
             },
diff --git a/packages/stage-ui/src/stores/modules/gaming-minecraft.ts b/packages/stage-ui/src/stores/modules/gaming-minecraft.ts
index c0839e718..6fa5a7a5b 100644
--- a/packages/stage-ui/src/stores/modules/gaming-minecraft.ts
+++ b/packages/stage-ui/src/stores/modules/gaming-minecraft.ts
@@ -1,3 +1,235 @@
-import { createGamingModuleStore } from './gaming-module-factory'
+import type { WebSocketBaseEvent, WebSocketEvents } from '@proj-airi/server-sdk'
 
-export const useMinecraftStore = createGamingModuleStore('minecraft', 25565)
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+
+import { useModsServerChannelStore } from '../mods/api/channel-server'
+
+export interface MinecraftTrafficEntry {
+  id: string
+  type: 'context:update' | 'spark:command'
+  summary: string
+  source: string
+  receivedAt: number
+  payload: unknown
+}
+
+const RUNTIME_CONTEXT_TICK_MS = 1_000
+const MAX_TRAFFIC_ENTRIES = 50
+const MINECRAFT_SERVICE_NAME = 'minecraft-bot'
+
+function getEventSourceLabel(event: { metadata?: { source?: { plugin?: { id?: string }, id?: string } } }) {
+  return event.metadata?.source?.plugin?.id
+    ?? event.metadata?.source?.id
+    ?? 'unknown'
+}
+
+function isMinecraftSource(event: { metadata?: { source?: { plugin?: { id?: string }, id?: string } } }) {
+  const sourcePluginId = event.metadata?.source?.plugin?.id
+  const sourceId = event.metadata?.source?.id
+
+  return sourcePluginId === MINECRAFT_SERVICE_NAME || sourceId === MINECRAFT_SERVICE_NAME
+}
+
+function summarizeContextUpdate(event: WebSocketBaseEvent<'context:update', WebSocketEvents['context:update']>) {
+  const lane = event.data.lane ?? 'general'
+  const text = typeof event.data.text === 'string' ? event.data.text.trim() : ''
+  const preview = text ? `: ${text.slice(0, 120)}` : ''
+  return `${lane}${preview}`
+}
+
+function summarizeSparkCommand(event: WebSocketBaseEvent<'spark:command', WebSocketEvents['spark:command']>) {
+  const destinations = Array.isArray(event.data.destinations) && event.data.destinations.length > 0
+    ? event.data.destinations.join(', ')
+    : 'broadcast'
+
+  return `${event.data.intent} -> ${destinations}`
+}
+
+function isMinecraftModuleIdentity(value: { name?: string, identity?: { plugin?: { id?: string } } }) {
+  return value.name === MINECRAFT_SERVICE_NAME || value.identity?.plugin?.id === MINECRAFT_SERVICE_NAME
+}
+
+export const useMinecraftStore = defineStore('minecraft', () => {
+  const serverChannelStore = useModsServerChannelStore()
+
+  const latestRuntimeContextText = ref('')
+  const lastRuntimeContextAt = ref(0)
+  const trafficEntries = ref<MinecraftTrafficEntry[]>([])
+  const initialized = ref(false)
+  const now = ref(Date.now())
+  const servicePresent = ref(false)
+  const serviceHealthy = ref(false)
+
+  let disposeContextUpdate: (() => void) | null = null
+  let disposeSparkCommand: (() => void) | null = null
+  let disposeRegistrySync: (() => void) | null = null
+  let disposeRegistryHealthy: (() => void) | null = null
+  let disposeRegistryUnhealthy: (() => void) | null = null
+  let disposeModuleDeAnnounced: (() => void) | null = null
+  let runtimeTickTimer: ReturnType<typeof setInterval> | null = null
+  let trafficSequence = 0
+
+  const serviceConnected = computed(() => servicePresent.value && serviceHealthy.value)
+  const hasObservedRuntime = computed(() => {
+    return servicePresent.value || lastRuntimeContextAt.value > 0
+  })
+  const runtimeContextAgeMs = computed(() => {
+    if (!lastRuntimeContextAt.value)
+      return 0
+
+    return Math.max(0, now.value - lastRuntimeContextAt.value)
+  })
+  const configured = computed(() => hasObservedRuntime.value)
+
+  function pushTrafficEntry(entry: Omit<MinecraftTrafficEntry, 'id'>) {
+    trafficSequence += 1
+    trafficEntries.value.push({
+      id: String(trafficSequence),
+      ...entry,
+    })
+
+    if (trafficEntries.value.length > MAX_TRAFFIC_ENTRIES) {
+      trafficEntries.value.splice(0, trafficEntries.value.length - MAX_TRAFFIC_ENTRIES)
+    }
+  }
+
+  function handleRuntimeContextUpdate(event: WebSocketBaseEvent<'context:update', WebSocketEvents['context:update']>) {
+    if (!isMinecraftSource(event))
+      return
+
+    if (event.data.lane === 'minecraft:status')
+      return
+
+    latestRuntimeContextText.value = event.data.text ?? ''
+    lastRuntimeContextAt.value = Date.now()
+
+    pushTrafficEntry({
+      type: 'context:update',
+      summary: summarizeContextUpdate(event),
+      source: getEventSourceLabel(event),
+      receivedAt: Date.now(),
+      payload: event.data,
+    })
+  }
+
+  function handleRegistrySync(event: WebSocketBaseEvent<'registry:modules:sync', WebSocketEvents['registry:modules:sync']>) {
+    const moduleEntry = event.data.modules.find(isMinecraftModuleIdentity)
+    const wasPresent = servicePresent.value
+    servicePresent.value = !!moduleEntry
+
+    if (!moduleEntry) {
+      serviceHealthy.value = false
+      return
+    }
+
+    if (!wasPresent)
+      serviceHealthy.value = true
+  }
+
+  function handleRegistryHealthy(event: WebSocketBaseEvent<'registry:modules:health:healthy', WebSocketEvents['registry:modules:health:healthy']>) {
+    if (!isMinecraftModuleIdentity(event.data))
+      return
+
+    servicePresent.value = true
+    serviceHealthy.value = true
+  }
+
+  function handleRegistryUnhealthy(event: WebSocketBaseEvent<'registry:modules:health:unhealthy', WebSocketEvents['registry:modules:health:unhealthy']>) {
+    if (!isMinecraftModuleIdentity(event.data))
+      return
+
+    servicePresent.value = true
+    serviceHealthy.value = false
+  }
+
+  function handleModuleDeAnnounced(event: WebSocketBaseEvent<'module:de-announced', WebSocketEvents['module:de-announced']>) {
+    if (!isMinecraftModuleIdentity(event.data))
+      return
+
+    servicePresent.value = false
+    serviceHealthy.value = false
+  }
+
+  function handleSparkCommand(event: WebSocketBaseEvent<'spark:command', WebSocketEvents['spark:command']>) {
+    const destinations = Array.isArray(event.data.destinations) ? event.data.destinations : []
+    const isMinecraftTraffic = destinations.includes(MINECRAFT_SERVICE_NAME)
+
+    if (!isMinecraftTraffic)
+      return
+
+    pushTrafficEntry({
+      type: 'spark:command',
+      summary: summarizeSparkCommand(event),
+      source: getEventSourceLabel(event),
+      receivedAt: Date.now(),
+      payload: event.data,
+    })
+  }
+
+  function initialize() {
+    if (initialized.value)
+      return
+
+    initialized.value = true
+    disposeContextUpdate = serverChannelStore.onContextUpdate(handleRuntimeContextUpdate as any)
+    disposeSparkCommand = serverChannelStore.onEvent('spark:command', handleSparkCommand as any)
+    disposeRegistrySync = serverChannelStore.onEvent('registry:modules:sync', handleRegistrySync as any)
+    disposeRegistryHealthy = serverChannelStore.onEvent('registry:modules:health:healthy', handleRegistryHealthy as any)
+    disposeRegistryUnhealthy = serverChannelStore.onEvent('registry:modules:health:unhealthy', handleRegistryUnhealthy as any)
+    disposeModuleDeAnnounced = serverChannelStore.onEvent('module:de-announced', handleModuleDeAnnounced as any)
+    runtimeTickTimer = setInterval(() => {
+      now.value = Date.now()
+    }, RUNTIME_CONTEXT_TICK_MS)
+  }
+
+  function dispose() {
+    disposeContextUpdate?.()
+    disposeSparkCommand?.()
+    disposeRegistrySync?.()
+    disposeRegistryHealthy?.()
+    disposeRegistryUnhealthy?.()
+    disposeModuleDeAnnounced?.()
+    disposeContextUpdate = null
+    disposeSparkCommand = null
+    disposeRegistrySync = null
+    disposeRegistryHealthy = null
+    disposeRegistryUnhealthy = null
+    disposeModuleDeAnnounced = null
+
+    if (runtimeTickTimer) {
+      clearInterval(runtimeTickTimer)
+      runtimeTickTimer = null
+    }
+
+    initialized.value = false
+  }
+
+  function clearRuntimeState() {
+    latestRuntimeContextText.value = ''
+    lastRuntimeContextAt.value = 0
+    servicePresent.value = false
+    serviceHealthy.value = false
+    trafficEntries.value = []
+    trafficSequence = 0
+  }
+
+  function resetState() {
+    clearRuntimeState()
+  }
+
+  return {
+    latestRuntimeContextText,
+    lastRuntimeContextAt,
+    trafficEntries,
+    configured,
+    serviceConnected,
+    runtimeContextAgeMs,
+
+    initialize,
+    dispose,
+    resetState,
+
+    _handleRuntimeContextUpdate: handleRuntimeContextUpdate,
+  }
+})
diff --git a/packages/stage-ui/src/types/chat.ts b/packages/stage-ui/src/types/chat.ts
index 6d44958c5..f753eebaf 100644
--- a/packages/stage-ui/src/types/chat.ts
+++ b/packages/stage-ui/src/types/chat.ts
@@ -38,7 +38,7 @@ export interface ErrorMessage {
   content: string
 }
 
-export interface ContextMessage extends ContextUpdate<Record<string, unknown>, string | CommonContentPart[]> {
+export interface ContextMessage extends ContextUpdate<Record<string, unknown>, unknown> {
   metadata?: {
     source: MetadataEventSource
   }
diff --git a/packages/stage-ui/src/utils/relative-time.ts b/packages/stage-ui/src/utils/relative-time.ts
new file mode 100644
index 000000000..5ae237eef
--- /dev/null
+++ b/packages/stage-ui/src/utils/relative-time.ts
@@ -0,0 +1,9 @@
+export function formatRelativeTime(timestamp: number, now: number) {
+  const diffMs = Math.max(0, now - timestamp)
+  const diffSeconds = Math.floor(diffMs / 1000)
+
+  if (diffSeconds < 60)
+    return `${diffSeconds} ${diffSeconds === 1 ? 'second' : 'seconds'} ago`
+
+  return 'Stale'
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index d4e0b35ba..7f29dac3f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -198,6 +198,9 @@ catalogs:
     is-network-error:
       specifier: ^1.3.1
       version: 1.3.1
+    isolated-vm:
+      specifier: ^6.1.2
+      version: 6.1.2
     knip:
       specifier: ^6.0.4
       version: 6.0.4
@@ -3425,6 +3428,9 @@ importers:
       eventemitter3:
         specifier: ^5.0.4
         version: 5.0.4
+      isolated-vm:
+        specifier: 'catalog:'
+        version: 6.1.2
       minecraft-data:
         specifier: 3.102.3
         version: 3.102.3
@@ -13219,6 +13225,10 @@ packages:
     resolution: {integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==}
     engines: {node: '>=0.10.0'}
 
+  isolated-vm@6.1.2:
+    resolution: {integrity: sha512-GGfsHqtlZiiurZaxB/3kY7LLAXR3sgzDul0fom4cSyBjx6ZbjpTrFWiH3z/nUfLJGJ8PIq9LQmQFiAxu24+I7A==}
+    engines: {node: '>=22.0.0'}
+
   isomorphic-fetch@3.0.0:
     resolution: {integrity: sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA==}
 
@@ -27837,6 +27847,10 @@ snapshots:
 
   isobject@3.0.1: {}
 
+  isolated-vm@6.1.2:
+    dependencies:
+      node-gyp-build: 4.8.4
+
   isomorphic-fetch@3.0.0(encoding@0.1.13):
     dependencies:
       node-fetch: 2.7.0(encoding@0.1.13)
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index b73747f05..e2945580e 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -19,7 +19,6 @@ overrides:
   safer-buffer: npm:@nolyfill/safer-buffer@^1.0.44
   side-channel: npm:@nolyfill/side-channel@^1.0.44
   string.prototype.matchall: npm:@nolyfill/string.prototype.matchall@^1.0.44
-
 patchedDependencies:
   '@mediapipe/tasks-vision': patches/@mediapipe__tasks-vision.patch
   mineflayer-pathfinder: patches/mineflayer-pathfinder.patch
@@ -91,6 +90,7 @@ catalog:
   idb-keyval: ^6.2.2
   injeca: ^0.1.8
   is-network-error: ^1.3.1
+  isolated-vm: ^6.1.2
   knip: ^6.0.4
   mkcert: ^3.2.0
   nano-staged: ^0.9.0
@@ -145,6 +145,7 @@ onlyBuiltDependencies:
   - es5-ext
   - esbuild
   - ffmpeg-static
+  - isolated-vm
   - less
   - msw
   - onnxruntime-node
@@ -153,6 +154,7 @@ onlyBuiltDependencies:
   - spawn-sync
   - utf-8-validate
   - vue-demi
+
 packageExtensions:
   '@formkit/auto-animate':
     peerDependencies:
diff --git a/services/minecraft/README.md b/services/minecraft/README.md
index dd464231a..076aed9ad 100644
--- a/services/minecraft/README.md
+++ b/services/minecraft/README.md
@@ -1,8 +1,52 @@
-# WIP
+# AIRI Minecraft Service
 
-**Caution: Documentation below may be out of date.**
+This workspace runs AIRI's dedicated Minecraft bot. It connects a Mineflayer runtime to a Minecraft server, loads the cognitive stack in `src/cognitive`, and bridges status, context, and command traffic back to AIRI so the Stage settings shell can observe the service.
 
-## 🧠 Cognitive Architecture
+## Deprecation Notice
+
+This service is on a deprecation path. The current Mineflayer-based bot is expected to be replaced by a Fabric mod based runtime, which will become the primary Minecraft integration surface going forward.
+
+Use this service for current local development and maintenance, but avoid building new long-term features around the Mineflayer runtime unless they are also part of the migration plan.
+
+## Safety Notice
+
+Do not connect this bot to public servers you do not trust.
+
+The runtime can execute JavaScript-generated action plans to control the bot. Those scripts run in an isolated environment, but they still drive a real local process with access to your Minecraft session, local network reachability, and other machine-side resources. A malicious or hostile server can still cause unwanted actions, or damage to your system.
+
+Treat this service as a local-development and trusted-server tool only.
+
+## Setup
+
+1. Install workspace dependencies from the repo root:
+
+   ```bash
+   pnpm i
+   ```
+
+2. Copy the template:
+
+   ```bash
+   cp services/minecraft/.env services/minecraft/.env.local
+   ```
+
+3. Edit `services/minecraft/.env.local`.
+
+4. Start the service:
+
+   ```bash
+   pnpm -F @proj-airi/minecraft-bot dev
+   ```
+
+   Or, from `services/minecraft/`:
+
+   ```bash
+   pnpm dev
+   ```
+
+5. The bot should automatically connect to both AIRI and the Minecraft server.
+
+## Cognitive Architecture
 
 AIRI's Minecraft agent is built on a **four-layered cognitive architecture** inspired by cognitive science, enabling reactive, conscious, and physically grounded behaviors.
 
@@ -99,7 +143,7 @@ The action layer is responsible for the actual execution of tasks in the world.
 - **Action Registry** (`action-registry.ts`): Validates params and dispatches tool calls.
 - **Tool Catalog** (`llm-actions.ts`): Action/tool definitions and schemas bound to mineflayer skills.
 
-### 🔄 Event Flow Example
+### Event Flow Example
 
 **Scenario: "Build a house"**
 ```txt
@@ -117,10 +161,11 @@ Player: "build a house"
 [Conscious] Brain confirms completion: "House is ready!"
 ```
 
-### 📁 Project Structure
+### Project Structure
 
 ```txt
 src/
+├── airi/                      # AIRI bridge, module shell, status publishing
 ├── cognitive/                  # 🧠 Perception → Reflex → Conscious → Action
 │   ├── perception/            # Event definitions + rule evaluation
 │   │   ├── events/
@@ -153,17 +198,21 @@ src/
 │   ├── container.ts           # Dependency injection wiring
 │   ├── index.ts               # Cognitive system entrypoint
 │   └── types.ts               # Shared cognitive types
+├── composables/
+│   ├── config.ts              # Environment schema + defaults
+│   ├── runtime-config.ts      # Persisted local runtime config
+│   └── bot.ts
+├── debug/                     # Debug dashboard, MCP REPL, viewer integration
 ├── libs/
 │   └── mineflayer/           # Mineflayer bot wrapper/adapters
 ├── skills/                   # Atomic bot capabilities
-├── composables/              # Reusable functions (config, etc.)
 ├── plugins/                  # Mineflayer/bot plugins
-├── debug/                    # Debug web dashboard + MCP bridge
 ├── utils/                    # Helpers
+├── minecraft-bot-runtime.ts  # Bot lifecycle wrapper for reconnect/reconfigure
 └── main.ts                   # Bot entrypoint
 ```
 
-### 🎯 Design Principles
+### Design Principles
 
 1. **Separation of Concerns**: Each layer has a distinct responsibility
 2. **Event-Driven**: Loose coupling via centralized event system
@@ -171,7 +220,7 @@ src/
 4. **Extensibility**: Easy to add new reflexes or conscious behaviors
 5. **Cognitive Realism**: Mimics human-like perception → reaction → deliberation
 
-### 🚧 Future Enhancements
+### Future Enhancements
 
 - **Perception Layer**:
   - ⏱️ Temporal context window (remember recent events)
diff --git a/services/minecraft/package.json b/services/minecraft/package.json
index e2167d88e..dec166115 100644
--- a/services/minecraft/package.json
+++ b/services/minecraft/package.json
@@ -4,12 +4,12 @@
   "private": true,
   "description": "An intelligent Minecraft bot powered by LLM. AIRI can understand natural language commands, interact with the world, and assist players in various tasks.",
   "scripts": {
-    "dev": "tsx --env-file=.env --env-file-if-exists=.env.local src/main.ts",
-    "start": "tsx --env-file=.env --env-file-if-exists=.env.local src/main.ts",
+    "dev": "NODE_OPTIONS=--no-node-snapshot tsx --env-file=.env --env-file-if-exists=.env.local src/main.ts",
+    "start": "NODE_OPTIONS=--no-node-snapshot tsx --env-file=.env --env-file-if-exists=.env.local src/main.ts",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "typecheck": "tsc --noEmit",
-    "test": "vitest"
+    "test": "NODE_OPTIONS=--no-node-snapshot vitest"
   },
   "dependencies": {
     "@guiiai/logg": "catalog:",
@@ -24,6 +24,7 @@
     "crossws": "catalog:",
     "es-toolkit": "^1.45.1",
     "eventemitter3": "^5.0.4",
+    "isolated-vm": "catalog:",
     "minecraft-data": "3.102.3",
     "mineflayer": "^4.33.0",
     "mineflayer-armor-manager": "^2.0.1",
diff --git a/services/minecraft/src/airi/airi-bridge.ts b/services/minecraft/src/airi/airi-bridge.ts
new file mode 100644
index 000000000..e45274228
--- /dev/null
+++ b/services/minecraft/src/airi/airi-bridge.ts
@@ -0,0 +1,226 @@
+import type { Client, ContextUpdate, ModuleAnnouncedEvent } from '@proj-airi/server-sdk'
+
+import type { EventBus } from '../cognitive/event-bus'
+
+import { useLogg } from '@guiiai/logg'
+import { ContextUpdateStrategy } from '@proj-airi/server-sdk'
+import { nanoid } from 'nanoid'
+
+interface SparkCommandData {
+  commandId: string
+  intent: 'plan' | 'proposal' | 'action' | 'pause' | 'resume' | 'reroute' | 'context'
+  interrupt: 'force' | 'soft' | false
+  priority: 'critical' | 'high' | 'normal' | 'low'
+  guidance?: {
+    options?: Array<{ label: string, steps: string[] }>
+  }
+}
+
+export class AiriBridge {
+  private readonly logger = useLogg('airi-bridge').useGlobalConfig()
+  private commandHandler: ((event: { data: SparkCommandData }) => void) | null = null
+  private contextUpdateHandler: ((event: { data: ContextUpdate }) => void) | null = null
+  private moduleAnnouncedHandler: ((event: { data: ModuleAnnouncedEvent }) => void) | null = null
+  private readonly moduleAnnouncedListeners = new Set<(event: ModuleAnnouncedEvent) => void>()
+
+  constructor(
+    private readonly client: Client,
+    private readonly eventBus: EventBus,
+  ) {}
+
+  init(): void {
+    this.commandHandler = (event) => {
+      const cmd = event.data
+      this.logger.log('Received spark:command', { intent: cmd.intent, commandId: cmd.commandId })
+
+      // Acknowledge receipt
+      this.client.send({
+        type: 'spark:emit',
+        data: {
+          id: nanoid(),
+          eventId: cmd.commandId,
+          state: 'queued',
+          note: 'Command received',
+        },
+      } as Parameters<typeof this.client.send>[0])
+
+      // Route by intent
+      if (cmd.intent === 'context') {
+        this.handleContextIntent(cmd)
+      }
+      else {
+        this.handleActionIntent(cmd)
+      }
+    }
+
+    this.contextUpdateHandler = (event) => {
+      const ctx = event.data
+      this.logger.log('Received context:update', { lane: ctx.lane, preview: ctx.text.slice(0, 80) })
+
+      this.eventBus.emit({
+        type: 'signal:airi_context',
+        payload: Object.freeze({
+          type: 'airi_context' as const,
+          description: ctx.text,
+          sourceId: 'airi',
+          confidence: 1.0,
+          timestamp: Date.now(),
+          metadata: {
+            source: 'airi',
+            contextId: ctx.contextId,
+            lane: ctx.lane ?? 'general',
+            hints: ctx.hints ?? [],
+          },
+        }),
+        source: { component: 'airi', id: 'bridge' },
+      })
+    }
+
+    this.moduleAnnouncedHandler = (event) => {
+      const moduleAnnouncement = event.data
+      this.logger.log('Received module:announced', { name: moduleAnnouncement.name, pluginId: moduleAnnouncement.identity?.plugin?.id })
+      for (const listener of this.moduleAnnouncedListeners) {
+        listener(moduleAnnouncement)
+      }
+    }
+
+    this.client.onEvent('spark:command', this.commandHandler as Parameters<typeof this.client.onEvent<'spark:command'>>[1])
+    this.client.onEvent('context:update', this.contextUpdateHandler as Parameters<typeof this.client.onEvent<'context:update'>>[1])
+    this.client.onEvent('module:announced', this.moduleAnnouncedHandler as Parameters<typeof this.client.onEvent<'module:announced'>>[1])
+    this.logger.log('AiriBridge initialized, listening for spark:command, context:update, and module:announced')
+  }
+
+  destroy(): void {
+    if (this.commandHandler) {
+      this.client.offEvent('spark:command', this.commandHandler as Parameters<typeof this.client.offEvent<'spark:command'>>[1])
+      this.commandHandler = null
+    }
+    if (this.contextUpdateHandler) {
+      this.client.offEvent('context:update', this.contextUpdateHandler as Parameters<typeof this.client.offEvent<'context:update'>>[1])
+      this.contextUpdateHandler = null
+    }
+    if (this.moduleAnnouncedHandler) {
+      this.client.offEvent('module:announced', this.moduleAnnouncedHandler as Parameters<typeof this.client.offEvent<'module:announced'>>[1])
+      this.moduleAnnouncedHandler = null
+    }
+    this.moduleAnnouncedListeners.clear()
+    this.logger.log('AiriBridge destroyed')
+  }
+
+  sendNotify(headline: string, note?: string, urgency: 'immediate' | 'soon' | 'later' = 'soon'): void {
+    this.client.send({
+      type: 'spark:notify',
+      data: {
+        id: nanoid(),
+        eventId: nanoid(),
+        kind: 'ping',
+        urgency,
+        headline,
+        note,
+        destinations: ['proj-airi:stage-*'],
+      },
+    } as Parameters<typeof this.client.send>[0])
+    this.logger.log('Sent spark:notify', { headline, urgency })
+  }
+
+  sendContextUpdate(text: string, hints?: string[], lane?: string): void
+  sendContextUpdate(update: ContextUpdate): void
+  sendContextUpdate(textOrUpdate: string | Omit<ContextUpdate, 'strategy' | 'id' | 'contextId'> & { contextId?: string }, hints?: string[], lane = 'game'): void {
+    const update = typeof textOrUpdate === 'string'
+      ? {
+        text: textOrUpdate,
+        hints,
+        lane,
+        strategy: ContextUpdateStrategy.AppendSelf,
+      } satisfies Omit<ContextUpdate, 'id' | 'contextId'> & { contextId?: string }
+      : {
+          strategy: ContextUpdateStrategy.AppendSelf,
+          ...textOrUpdate,
+        }
+
+    const contextId = update.contextId ?? nanoid()
+    this.client.send({
+      type: 'context:update',
+      data: {
+        id: nanoid(),
+        contextId,
+        lane: update.lane,
+        text: update.text,
+        hints: update.hints,
+        strategy: update.strategy,
+        destinations: update.destinations,
+      },
+    } as Parameters<typeof this.client.send>[0])
+    this.logger.log('Sent context:update', { lane: update.lane, preview: update.text.slice(0, 80), contextId })
+  }
+
+  sendEmit(eventId: string, state: 'queued' | 'working' | 'done' | 'dropped', note?: string): void {
+    this.client.send({
+      type: 'spark:emit',
+      data: {
+        id: nanoid(),
+        eventId,
+        state,
+        note,
+      },
+    } as Parameters<typeof this.client.send>[0])
+    this.logger.log('Sent spark:emit', { eventId, state })
+  }
+
+  onModuleAnnounced(listener: (event: ModuleAnnouncedEvent) => void) {
+    this.moduleAnnouncedListeners.add(listener)
+
+    return () => {
+      this.moduleAnnouncedListeners.delete(listener)
+    }
+  }
+
+  private handleActionIntent(cmd: SparkCommandData): void {
+    const steps = cmd.guidance?.options?.[0]?.steps ?? []
+    const instructionText = steps.length > 0
+      ? steps.join('\n')
+      : `${cmd.intent} command received`
+
+    this.eventBus.emit({
+      type: 'signal:airi_command',
+      payload: Object.freeze({
+        type: 'airi_command' as const,
+        description: `[AIRI] Instruction: ${instructionText}`,
+        sourceId: 'airi',
+        confidence: 1.0,
+        timestamp: Date.now(),
+        metadata: {
+          source: 'airi',
+          commandId: cmd.commandId,
+          intent: cmd.intent,
+          interrupt: cmd.interrupt,
+          priority: cmd.priority,
+        },
+      }),
+      source: { component: 'airi', id: 'bridge' },
+    })
+  }
+
+  private handleContextIntent(cmd: SparkCommandData): void {
+    const steps = cmd.guidance?.options?.[0]?.steps ?? []
+    const contextText = steps.length > 0
+      ? steps.join('\n')
+      : 'Context update from AIRI'
+
+    this.eventBus.emit({
+      type: 'signal:airi_context',
+      payload: Object.freeze({
+        type: 'airi_context' as const,
+        description: contextText,
+        sourceId: 'airi',
+        confidence: 1.0,
+        timestamp: Date.now(),
+        metadata: {
+          source: 'airi',
+          commandId: cmd.commandId,
+        },
+      }),
+      source: { component: 'airi', id: 'bridge' },
+    })
+  }
+}
diff --git a/services/minecraft/src/airi/minecraft-context-service.ts b/services/minecraft/src/airi/minecraft-context-service.ts
new file mode 100644
index 000000000..69b6f13aa
--- /dev/null
+++ b/services/minecraft/src/airi/minecraft-context-service.ts
@@ -0,0 +1,169 @@
+import type { ContextUpdate, ModuleAnnouncedEvent } from '@proj-airi/server-sdk'
+
+import type { MineflayerWithAgents } from '../cognitive/types'
+import type { AiriBridge } from './airi-bridge'
+
+import { ContextUpdateStrategy } from '@proj-airi/server-sdk'
+import { nanoid } from 'nanoid'
+
+interface MinecraftStatusSnapshot {
+  botUsername: string
+  serverHost: string
+  serverPort: number
+  position: string
+  health: string
+  gameMode: string
+  otherPlayers: string[]
+}
+
+const STATUS_CONTEXT_ID = 'minecraft:status'
+const STATUS_LANE = 'minecraft:status'
+const STATUS_REFRESH_INTERVAL_MS = 5_000
+
+function toPositionString(bot: MineflayerWithAgents) {
+  const position = bot.bot.entity?.position
+  return position
+    ? `x: ${position.x.toFixed(1)}, y: ${position.y.toFixed(1)}, z: ${position.z.toFixed(1)}`
+    : 'unknown'
+}
+
+function buildStatusText(snapshot: MinecraftStatusSnapshot) {
+  return [
+    `Bot online: ${snapshot.botUsername}`,
+    `Server: ${snapshot.serverHost}:${snapshot.serverPort}`,
+    `Position: ${snapshot.position}`,
+    `Health: ${snapshot.health}/20, Mode: ${snapshot.gameMode}`,
+    `Other players online: ${snapshot.otherPlayers.length > 0 ? snapshot.otherPlayers.join(', ') : 'none'}`,
+  ].join('\n')
+}
+
+function collectFrontendDestinations(event: ModuleAnnouncedEvent) {
+  const pluginId = event.identity?.plugin?.id
+  const instanceId = event.identity?.id
+
+  if (!pluginId || !instanceId) {
+    return []
+  }
+
+  return [`instance:${instanceId}`]
+}
+
+export class MinecraftContextService {
+  private runtimeBot: MineflayerWithAgents | null = null
+  private currentSnapshot: MinecraftStatusSnapshot | null = null
+  private lastPublishedText = ''
+  private refreshTimer: ReturnType<typeof setInterval> | null = null
+  private unsubscribeModuleAnnounced: (() => void) | null = null
+  private readonly serverHost: string
+  private readonly serverPort: number
+
+  constructor(private readonly deps: {
+    airiBridge: Pick<AiriBridge, 'onModuleAnnounced' | 'sendContextUpdate'>
+    serverHost: string
+    serverPort: number
+    refreshIntervalMs?: number
+  }) {
+    this.serverHost = deps.serverHost
+    this.serverPort = deps.serverPort
+  }
+
+  init() {
+    if (this.unsubscribeModuleAnnounced) {
+      return
+    }
+
+    this.unsubscribeModuleAnnounced = this.deps.airiBridge.onModuleAnnounced((event) => {
+      const destinations = collectFrontendDestinations(event)
+      if (destinations.length === 0) {
+        return
+      }
+
+      this.publishStatus({ force: true, destinations })
+    })
+  }
+
+  bindBot(bot: MineflayerWithAgents) {
+    this.runtimeBot = bot
+    this.refreshStatusSnapshot()
+    this.publishStatus({ force: true })
+
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer)
+    }
+
+    this.refreshTimer = setInterval(() => {
+      this.publishStatus()
+    }, this.deps.refreshIntervalMs ?? STATUS_REFRESH_INTERVAL_MS)
+  }
+
+  unbindBot() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer)
+      this.refreshTimer = null
+    }
+
+    this.runtimeBot = null
+    this.currentSnapshot = null
+    this.lastPublishedText = ''
+  }
+
+  publishStatus(options: { force?: boolean, destinations?: string[] } = {}) {
+    const snapshot = this.refreshStatusSnapshot()
+    if (!snapshot) {
+      return
+    }
+
+    const text = buildStatusText(snapshot)
+    if (!options.force && text === this.lastPublishedText) {
+      return
+    }
+
+    const update: ContextUpdate = {
+      id: nanoid(),
+      contextId: STATUS_CONTEXT_ID,
+      lane: STATUS_LANE,
+      text,
+      hints: ['status', snapshot.botUsername],
+      strategy: ContextUpdateStrategy.ReplaceSelf,
+    }
+
+    if (options.destinations?.length) {
+      update.destinations = options.destinations
+    }
+
+    this.deps.airiBridge.sendContextUpdate(update)
+    this.lastPublishedText = text
+  }
+
+  getStatusSnapshot() {
+    return this.currentSnapshot ? { ...this.currentSnapshot, otherPlayers: [...this.currentSnapshot.otherPlayers] } : null
+  }
+
+  destroy() {
+    this.unbindBot()
+    this.unsubscribeModuleAnnounced?.()
+    this.unsubscribeModuleAnnounced = null
+  }
+
+  private refreshStatusSnapshot() {
+    if (!this.runtimeBot) {
+      return this.currentSnapshot
+    }
+
+    const otherPlayers = Object.keys(this.runtimeBot.bot.players ?? {})
+      .filter(name => name !== this.runtimeBot?.username)
+      .sort((left, right) => left.localeCompare(right))
+
+    this.currentSnapshot = {
+      botUsername: this.runtimeBot.username,
+      serverHost: this.serverHost,
+      serverPort: this.serverPort,
+      position: toPositionString(this.runtimeBot),
+      health: String(this.runtimeBot.bot.health ?? 20),
+      gameMode: this.runtimeBot.bot.game?.gameMode ?? 'unknown',
+      otherPlayers,
+    }
+
+    return this.currentSnapshot
+  }
+}
diff --git a/services/minecraft/src/airi/start-background-client.ts b/services/minecraft/src/airi/start-background-client.ts
new file mode 100644
index 000000000..6dccd39c7
--- /dev/null
+++ b/services/minecraft/src/airi/start-background-client.ts
@@ -0,0 +1,58 @@
+import { errorMessageFrom } from '@moeru/std'
+
+interface AiriClientLike {
+  connect: () => Promise<void>
+}
+
+interface LoggerLike {
+  log: (message: string) => void
+  warn: (message: string) => void
+  withFields: (fields: Record<string, unknown>) => LoggerLike
+}
+
+export function startAiriClientConnection(client: AiriClientLike, deps: {
+  logger: LoggerLike
+  url: string
+}) {
+  let unavailableReported = false
+
+  const reportUnavailable = (error: unknown) => {
+    if (unavailableReported)
+      return
+
+    unavailableReported = true
+    deps.logger.withFields({
+      url: deps.url,
+      error: errorMessageFrom(error) ?? 'Unknown error',
+    }).warn('AIRI server is unavailable; continuing startup without AIRI and retrying in background')
+  }
+
+  const reportDisconnected = () => {
+    deps.logger.withFields({
+      url: deps.url,
+    }).warn('AIRI server connection closed; retrying in background')
+  }
+
+  void client.connect()
+    .then(() => {
+      deps.logger.withFields({
+        url: deps.url,
+      }).log(
+        unavailableReported
+          ? 'Connected to AIRI server after background retry'
+          : 'Connected to AIRI server',
+      )
+      unavailableReported = false
+    })
+    .catch((error) => {
+      deps.logger.withFields({
+        url: deps.url,
+        error: errorMessageFrom(error) ?? 'Unknown error',
+      }).warn('AIRI client stopped retrying')
+    })
+
+  return {
+    reportUnavailable,
+    reportDisconnected,
+  }
+}
diff --git a/services/minecraft/src/cognitive/conscious/brain.test.ts b/services/minecraft/src/cognitive/conscious/brain.test.ts
index 6b372258b..f31308ee0 100644
--- a/services/minecraft/src/cognitive/conscious/brain.test.ts
+++ b/services/minecraft/src/cognitive/conscious/brain.test.ts
@@ -146,7 +146,7 @@ describe('brain no-action follow-up', () => {
     const result = brain.forgetConversation()
 
     expect(result.ok).toBe(true)
-    expect(result.cleared).toEqual(['conversationHistory', 'lastLlmInputSnapshot', 'contextHistory'])
+    expect(result.cleared).toEqual(['conversationHistory', 'lastLlmInputSnapshot'])
     expect(brain.conversationHistory).toEqual([])
     expect(brain.lastLlmInputSnapshot).toBeNull()
     expect(brain.llmLogEntries).toHaveLength(1)
@@ -285,22 +285,19 @@ inv;
     expect(enqueueSpy).not.toHaveBeenCalled()
   })
 
-  it('uses attempt timeout guard so hanging llm call cannot stall processEvent', async () => {
+  it('does not pass a timeout to llmAgent calls', async () => {
     const deps: any = createDeps('await chat("hi")')
-    deps.llmAgent.callLLM = vi.fn(async () => await new Promise(() => {}))
+    deps.llmAgent.callLLM = vi.fn(async () => ({
+      text: 'await chat("hi")',
+      usage: {},
+    }))
     const brain: any = new Brain(deps)
-    brain.llmAttemptTimeoutMs = 25
-    brain.llmTurnDeadlineMs = 80
 
-    const outcome = await Promise.race([
-      brain.processEvent({} as any, createPerceptionEvent()).then(() => 'done'),
-      new Promise(resolve => setTimeout(resolve, 350, 'timeout')),
-    ])
+    await brain.processEvent({} as any, createPerceptionEvent())
 
-    expect(outcome).toBe('done')
     expect(deps.llmAgent.callLLM).toHaveBeenCalledTimes(1)
     const llmCallOptions = deps.llmAgent.callLLM.mock.calls[0]?.[0]
-    expect(typeof llmCallOptions?.timeoutMs).toBe('number')
+    expect(llmCallOptions?.timeoutMs).toBeUndefined()
     expect(llmCallOptions?.abortSignal).toBeInstanceOf(AbortSignal)
   })
 
@@ -319,8 +316,6 @@ inv;
       })
     })
     const brain: any = new Brain(deps)
-    brain.llmAttemptTimeoutMs = 2000
-    brain.llmTurnDeadlineMs = 2000
 
     const processing = brain.processEvent({} as any, createPerceptionEvent()).then(() => 'done')
     await started
@@ -612,7 +607,7 @@ describe('brain control action queue', () => {
     const brain: any = new Brain(deps)
     const outcome = await Promise.race([
       brain.processEvent({} as any, createPerceptionEvent()).then(() => 'done'),
-      new Promise(resolve => setTimeout(resolve, 80, 'timeout')),
+      new Promise(resolve => setTimeout(resolve, 250, 'timeout')),
     ])
 
     expect(outcome).toBe('done')
diff --git a/services/minecraft/src/cognitive/conscious/brain.ts b/services/minecraft/src/cognitive/conscious/brain.ts
index 1f934c4e2..df682335a 100644
--- a/services/minecraft/src/cognitive/conscious/brain.ts
+++ b/services/minecraft/src/cognitive/conscious/brain.ts
@@ -1,6 +1,8 @@
 import type { Logg } from '@guiiai/logg'
 import type { Message } from '@xsai/shared-chat'
 
+import type { AiriBridge } from '../../airi/airi-bridge'
+import type { MinecraftContextService } from '../../airi/minecraft-context-service'
 import type { ConversationUpdateEvent } from '../../debug/types'
 import type { Action } from '../../libs/mineflayer/action'
 import type { TaskExecutor } from '../action/task-executor'
@@ -9,7 +11,6 @@ import type { EventBus, TracedEvent } from '../event-bus'
 import type { PerceptionSignal } from '../perception/types/signals'
 import type { ReflexManager } from '../reflex/reflex-manager'
 import type { BotEvent, MineflayerWithAgents } from '../types'
-import type { ActiveContextState, ArchivedContext } from './context-summary'
 import type { PlannerGlobalDescriptor } from './js-planner'
 import type { LLMAgent, LLMResult } from './llm-agent'
 import type { LlmLogEntry, LlmLogEntryKind } from './llm-log'
@@ -18,12 +19,6 @@ import type { CancellationToken } from './task-state'
 import { config } from '../../composables/config'
 import { DebugService } from '../../debug'
 import { ActionError } from '../../utils/errors'
-import {
-
-  buildContextHistoryMessage,
-  collapseOldestContexts,
-  generateContextSummary,
-} from './context-summary'
 import { buildConsciousContextView } from './context-view'
 import { createHistoryRuntime } from './history-query'
 import { JavaScriptPlanner } from './js-planner'
@@ -47,6 +42,8 @@ interface BrainDeps {
   logger: Logg
   taskExecutor: TaskExecutor
   reflexManager: ReflexManager
+  airiBridge: AiriBridge
+  minecraftContextService: MinecraftContextService
 }
 
 interface QueuedEvent {
@@ -229,16 +226,13 @@ const MAX_QUEUED_CONTROL_ACTIONS = 5
 const MAX_PENDING_CONTROL_ACTIONS = 4
 const ACTION_QUEUE_RECENT_HISTORY_LIMIT = 20
 const MAX_CONVERSATION_HISTORY_MESSAGES = 200
-const MAX_ACTIVE_CONTEXT_MESSAGES = 30
-const MAX_CONTEXT_SUMMARIES_IN_PREFIX = 10
 const NO_ACTION_FOLLOWUP_BUDGET_DEFAULT = 3
 const NO_ACTION_FOLLOWUP_BUDGET_MAX = 8
 const NO_ACTION_STAGNATION_REPEAT_LIMIT = 2
+const DEFAULT_LLM_ATTEMPT_TIMEOUT_MS = 60_000
 const ERROR_BURST_GUARD_SOURCE_ID = 'brain:error_burst_guard'
 const ERROR_BURST_THRESHOLD = 3
 const ERROR_BURST_WINDOW_TURNS = 5
-const DEFAULT_LLM_ATTEMPT_TIMEOUT_MS = 15_000
-const DEFAULT_LLM_TURN_DEADLINE_MS = 45_000
 const MAX_EVENT_QUEUE_LENGTH = 256
 const MAX_CONSECUTIVE_HIGH_PRIORITY_TURNS = 8
 const PAUSE_ABORT_ERROR_NAME = 'AbortError'
@@ -282,24 +276,10 @@ export class Brain {
   private llmTraceIdCounter = 0
   private turnCounter = 0
   private currentInputEnvelope: RuntimeInputEnvelope | null = null
-  private llmAttemptTimeoutMs = DEFAULT_LLM_ATTEMPT_TIMEOUT_MS
-  private llmTurnDeadlineMs = DEFAULT_LLM_TURN_DEADLINE_MS
   private readonly llmLogRuntime = createLlmLogRuntime(() => this.llmLogEntries)
   private readonly patternRuntime = createPatternRuntime(PATTERN_CATALOG)
-
-  // Context boundary state
-  private archivedContexts: ArchivedContext[] = []
-  private activeContextState: ActiveContextState = {
-    label: null,
-    startTurnId: 0,
-    startedAt: Date.now(),
-  }
-
-  private activeContextStartIndex = 0
-  private cachedContextHistoryMessage: string | null = null
   private readonly historyRuntime = createHistoryRuntime({
     getConversationHistory: () => this.conversationHistory,
-    getArchivedContexts: () => this.archivedContexts,
     getLlmLogEntries: () => this.llmLogEntries,
     getCurrentTurnId: () => this.turnCounter,
   })
@@ -331,10 +311,20 @@ export class Brain {
 
     // Perception Handler
     this.unsubscribeEventBus = this.deps.eventBus.subscribe<PerceptionSignal>('conscious:signal:*', (event: TracedEvent<PerceptionSignal>) => {
+      // AIRI context updates are injected into conversation history without triggering a full cognitive cycle
+      if (event.payload.type === 'airi_context') {
+        this.conversationHistory.push({
+          role: 'user',
+          content: `[AIRI_CONTEXT] ${event.payload.description}`,
+        })
+        this.deps.logger.log('INFO', `Brain: Injected AIRI context: ${event.payload.description.slice(0, 80)}`)
+        return
+      }
+
       this.enqueueEvent(bot, {
         type: 'perception',
         payload: event.payload,
-        source: { type: 'minecraft', id: event.payload.sourceId ?? 'perception' },
+        source: { type: event.payload.sourceId === 'airi' ? 'airi' : 'minecraft', id: event.payload.sourceId ?? 'perception' },
         timestamp: Date.now(),
       }).catch(err => this.deps.logger.withError(err).error('Brain: Failed to process perception event'))
     })
@@ -402,9 +392,12 @@ export class Brain {
     this.deps.taskExecutor.on('action:failed', this.onActionFailed)
 
     this.deps.logger.log('INFO', 'Brain: Online.')
+
+    this.deps.minecraftContextService.bindBot(bot)
   }
 
   public destroy(): void {
+    this.deps.minecraftContextService.unbindBot()
     if (this.unsubscribeEventBus) {
       this.unsubscribeEventBus()
       this.unsubscribeEventBus = null
@@ -523,34 +516,18 @@ export class Brain {
     this.currentLlmAbortController = null
   }
 
-  private async callLLMWithTimeout(messages: Message[], attemptTimeoutMs: number): Promise<LLMResult> {
+  private async callLLM(messages: Message[]): Promise<LLMResult> {
     const abortController = new AbortController()
-    const timeoutError = Object.assign(
-      new Error(`LLM call timeout after ${attemptTimeoutMs}ms`),
-      { name: 'TimeoutError' },
-    )
 
     this.currentLlmAbortController = abortController
-    let timeoutHandle: ReturnType<typeof setTimeout> | undefined
     try {
-      const llmCallPromise = this.deps.llmAgent.callLLM({
+      return await this.deps.llmAgent.callLLM({
         messages,
         abortSignal: abortController.signal,
-        timeoutMs: attemptTimeoutMs,
+        timeoutMs: DEFAULT_LLM_ATTEMPT_TIMEOUT_MS,
       })
-      const timeoutPromise = new Promise<never>((_, reject) => {
-        timeoutHandle = setTimeout(() => {
-          if (!abortController.signal.aborted)
-            abortController.abort(timeoutError)
-          reject(timeoutError)
-        }, attemptTimeoutMs)
-      })
-
-      return await Promise.race([llmCallPromise, timeoutPromise])
     }
     finally {
-      if (timeoutHandle)
-        clearTimeout(timeoutHandle)
       if (this.currentLlmAbortController === abortController)
         this.currentLlmAbortController = null
     }
@@ -565,207 +542,13 @@ export class Brain {
   public forgetConversation(): { ok: true, cleared: string[] } {
     this.conversationHistory = []
     this.lastLlmInputSnapshot = null
-    this.activeContextStartIndex = 0
-    this.activeContextState = { label: null, startTurnId: this.turnCounter, startedAt: Date.now() }
-    this.archivedContexts = []
-    this.cachedContextHistoryMessage = null
     this.emitConversationUpdate(false, true)
     return {
       ok: true,
-      cleared: ['conversationHistory', 'lastLlmInputSnapshot', 'contextHistory'],
+      cleared: ['conversationHistory', 'lastLlmInputSnapshot'],
     }
   }
 
-  /**
-   * Enter a new task context boundary. Called by the LLM via REPL.
-   * If there's already an active context with messages, it is auto-exited first.
-   */
-  public enterContext(label: string): { ok: true, label: string, turnId: number } {
-    const normalizedLabel = (typeof label === 'string' && label.trim()) ? label.trim() : 'unnamed'
-
-    // If the current active context has messages, auto-exit it first
-    const activeMessageCount = this.conversationHistory.length - this.activeContextStartIndex
-    if (activeMessageCount > 0) {
-      this.exitCurrentContext(undefined, 'auto_exit_on_enter')
-    }
-
-    this.activeContextState = {
-      label: normalizedLabel,
-      startTurnId: this.turnCounter,
-      startedAt: Date.now(),
-    }
-    this.activeContextStartIndex = this.conversationHistory.length
-
-    this.appendLlmLog({
-      turnId: this.turnCounter,
-      kind: 'scheduler',
-      eventType: 'system_alert',
-      sourceType: 'system',
-      sourceId: 'brain:context',
-      tags: ['context', 'enter'],
-      text: `Entered context: "${normalizedLabel}"`,
-    })
-
-    return { ok: true, label: normalizedLabel, turnId: this.turnCounter }
-  }
-
-  /**
-   * Exit the current task context, summarize it, and archive it.
-   * Called by the LLM via REPL or internally for auto-trim.
-   */
-  public exitContext(summary?: string): { ok: true, summarized: string, messagesArchived: number } {
-    return this.exitCurrentContext(
-      typeof summary === 'string' && summary.trim() ? summary.trim() : undefined,
-      'explicit',
-    )
-  }
-
-  private exitCurrentContext(
-    providedSummary: string | undefined,
-    reason: 'explicit' | 'auto_exit_on_enter' | 'auto_trim',
-  ): { ok: true, summarized: string, messagesArchived: number } {
-    const activeMessages = this.conversationHistory.slice(this.activeContextStartIndex)
-    const startTurnId = this.activeContextState.startTurnId
-    const endTurnId = this.turnCounter
-    const label = this.activeContextState.label || 'unnamed'
-
-    // Generate summary: prefer LLM-provided, fall back to heuristic
-    const summaryText = providedSummary || generateContextSummary({
-      messages: activeMessages,
-      label,
-      llmLogEntries: this.llmLogEntries,
-      startTurnId,
-      endTurnId,
-    })
-
-    const archived: ArchivedContext = {
-      label,
-      summary: summaryText,
-      startTurnId,
-      endTurnId,
-      messageCount: activeMessages.length,
-      archivedAt: Date.now(),
-    }
-
-    this.archivedContexts.push(archived)
-
-    // Collapse oldest contexts if prefix is too large
-    if (this.archivedContexts.length > MAX_CONTEXT_SUMMARIES_IN_PREFIX) {
-      const collapseCount = this.archivedContexts.length - MAX_CONTEXT_SUMMARIES_IN_PREFIX + 1
-      this.archivedContexts = collapseOldestContexts(this.archivedContexts, collapseCount)
-    }
-
-    // Invalidate the cached prefix message so it's rebuilt next turn
-    this.cachedContextHistoryMessage = null
-
-    // Clear the active context messages from conversation history
-    // Keep them in memory for history queries but mark the new start index
-    this.activeContextStartIndex = this.conversationHistory.length
-
-    // Reset active context state
-    this.activeContextState = {
-      label: null,
-      startTurnId: this.turnCounter,
-      startedAt: Date.now(),
-    }
-
-    this.appendLlmLog({
-      turnId: this.turnCounter,
-      kind: 'scheduler',
-      eventType: 'system_alert',
-      sourceType: 'system',
-      sourceId: 'brain:context',
-      tags: ['context', 'exit', reason],
-      text: `Exited context: "${label}" (${activeMessages.length} messages archived). Summary: ${summaryText}`,
-      metadata: {
-        label,
-        reason,
-        messagesArchived: activeMessages.length,
-        summary: summaryText,
-        startTurnId,
-        endTurnId,
-      },
-    })
-
-    return {
-      ok: true,
-      summarized: summaryText,
-      messagesArchived: activeMessages.length,
-    }
-  }
-
-  /**
-   * Build the [CONTEXT_HISTORY] prefix message from archived contexts.
-   * Caches the result until invalidated by exitContext().
-   */
-  private getContextHistoryMessage(): string | null {
-    if (this.cachedContextHistoryMessage !== null)
-      return this.cachedContextHistoryMessage
-
-    const message = buildContextHistoryMessage(this.archivedContexts)
-    this.cachedContextHistoryMessage = message
-    return message
-  }
-
-  /**
-   * Auto-trim the active context if it exceeds the safety limit.
-   * Summarizes the oldest half and archives it.
-   */
-  private autoTrimActiveContext(): void {
-    const activeMessageCount = this.conversationHistory.length - this.activeContextStartIndex
-    if (activeMessageCount <= MAX_ACTIVE_CONTEXT_MESSAGES)
-      return
-
-    this.deps.logger.log('INFO', `Brain: Auto-trimming active context (${activeMessageCount} messages > ${MAX_ACTIVE_CONTEXT_MESSAGES} limit)`)
-
-    // Split: archive the oldest half, keep the newest half as active
-    const halfPoint = this.activeContextStartIndex + Math.floor(activeMessageCount / 2)
-    const oldMessages = this.conversationHistory.slice(this.activeContextStartIndex, halfPoint)
-
-    const summaryText = generateContextSummary({
-      messages: oldMessages,
-      label: this.activeContextState.label ? `${this.activeContextState.label} (partial)` : '(auto-trimmed)',
-      llmLogEntries: this.llmLogEntries,
-      startTurnId: this.activeContextState.startTurnId,
-      endTurnId: this.turnCounter,
-    })
-
-    const archived: ArchivedContext = {
-      label: this.activeContextState.label ? `${this.activeContextState.label} (partial)` : '(auto-trimmed)',
-      summary: summaryText,
-      startTurnId: this.activeContextState.startTurnId,
-      endTurnId: this.turnCounter,
-      messageCount: oldMessages.length,
-      archivedAt: Date.now(),
-    }
-
-    this.archivedContexts.push(archived)
-
-    if (this.archivedContexts.length > MAX_CONTEXT_SUMMARIES_IN_PREFIX) {
-      const collapseCount = this.archivedContexts.length - MAX_CONTEXT_SUMMARIES_IN_PREFIX + 1
-      this.archivedContexts = collapseOldestContexts(this.archivedContexts, collapseCount)
-    }
-
-    // Move the start index forward
-    this.activeContextStartIndex = halfPoint
-    this.cachedContextHistoryMessage = null
-
-    this.appendLlmLog({
-      turnId: this.turnCounter,
-      kind: 'scheduler',
-      eventType: 'system_alert',
-      sourceType: 'system',
-      sourceId: 'brain:context',
-      tags: ['context', 'auto_trim'],
-      text: `Auto-trimmed active context: archived ${oldMessages.length} messages`,
-      metadata: {
-        archivedCount: oldMessages.length,
-        remainingActive: this.conversationHistory.length - halfPoint,
-        summary: summaryText,
-      },
-    })
-  }
-
   public async injectDebugEvent(event: BotEvent): Promise<void> {
     if (!this.runtimeMineflayer) {
       throw new Error('Brain runtime is not initialized yet')
@@ -917,7 +700,7 @@ export class Brain {
   }
 
   /**
-   * Re-emit the current conversation state with full context metadata.
+   * Re-emit the current conversation state for the debug dashboard.
    * Used by the debug dashboard's `request_conversation` handler on reconnect.
    */
   public broadcastConversationState(): void {
@@ -929,19 +712,6 @@ export class Brain {
       messages: this.toDebugConversationMessages(this.cloneMessages(this.conversationHistory)),
       isProcessing,
       ...(sessionBoundary && { sessionBoundary }),
-      activeContext: {
-        label: this.activeContextState.label,
-        startTurnId: this.activeContextState.startTurnId,
-        messageCount: this.conversationHistory.length - this.activeContextStartIndex,
-      },
-      archivedContexts: this.archivedContexts.map(ctx => ({
-        label: ctx.label,
-        summary: ctx.summary,
-        turns: ctx.endTurnId - ctx.startTurnId + 1,
-        archivedAt: ctx.archivedAt,
-      })),
-      activeContextStartIndex: this.activeContextStartIndex,
-      contextHistoryMessage: this.getContextHistoryMessage(),
     })
   }
 
@@ -966,9 +736,11 @@ export class Brain {
       setNoActionBudget: (value: number) => this.setNoActionFollowupBudget(value),
       getNoActionBudget: () => this.getNoActionBudgetState(),
       forgetConversation: () => this.forgetConversation(),
-      enterContext: (label: string) => this.enterContext(label),
-      exitContext: (summary?: string) => this.exitContext(summary),
       history: this.historyRuntime,
+      notifyAiri: (headline: string, note?: string, urgency?: 'immediate' | 'soon' | 'later') =>
+        this.deps.airiBridge.sendNotify(headline, note, urgency),
+      updateAiriContext: (text: string, hints?: string[], lane?: string) =>
+        this.deps.airiBridge.sendContextUpdate(text, hints, lane),
     }
   }
 
@@ -979,6 +751,13 @@ export class Brain {
     return signal.type === 'chat_message'
   }
 
+  private isAiriCommandEvent(event: BotEvent): boolean {
+    if (event.type !== 'perception')
+      return false
+    const signal = event.payload as PerceptionSignal
+    return signal.type === 'airi_command'
+  }
+
   private getNoActionBudgetState(): NoActionBudgetState {
     return {
       remaining: this.noActionFollowupBudgetRemaining,
@@ -987,7 +766,7 @@ export class Brain {
     }
   }
 
-  private resetNoActionFollowupBudget(reason: 'player_chat' | 'manual'): NoActionBudgetState {
+  private resetNoActionFollowupBudget(reason: 'player_chat' | 'manual' | 'airi_command'): NoActionBudgetState {
     this.noActionFollowupBudgetRemaining = NO_ACTION_FOLLOWUP_BUDGET_DEFAULT
     this.noActionFollowupLastSignature = null
     this.noActionFollowupStagnationCount = 0
@@ -1977,6 +1756,8 @@ export class Brain {
       return
     if (this.isPlayerChatEvent(event))
       this.resetNoActionFollowupBudget('player_chat')
+    if (this.isAiriCommandEvent(event))
+      this.resetNoActionFollowupBudget('airi_command')
 
     const turnId = ++this.turnCounter
     this.maybeActivateErrorBurstGuard(bot, event, turnId)
@@ -2037,8 +1818,6 @@ export class Brain {
     let result: string | null = null
     let capturedReasoning: string | undefined
     let lastError: unknown
-    const llmTurnDeadlineAt = Date.now() + this.llmTurnDeadlineMs
-
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       // Check pause at start of each retry attempt
       if (this.paused) {
@@ -2056,27 +1835,10 @@ export class Brain {
       }
 
       try {
-        const remainingTurnMs = llmTurnDeadlineAt - Date.now()
-        if (remainingTurnMs <= 0) {
-          lastError = Object.assign(
-            new Error(`LLM turn deadline exceeded after ${this.llmTurnDeadlineMs}ms`),
-            { name: 'TimeoutError' },
-          )
-          this.deps.logger.withError(lastError as Error).warn('Brain: LLM turn deadline exceeded, skipping turn')
-          break
-        }
-        const attemptTimeoutMs = Math.max(1, Math.min(this.llmAttemptTimeoutMs, remainingTurnMs))
-
-        // Auto-trim active context if it exceeds the safety limit
-        this.autoTrimActiveContext()
-
-        // Build messages: system + [CONTEXT_HISTORY prefix] + active context messages + new user message
-        const contextHistoryMsg = this.getContextHistoryMessage()
-        const activeMessages = this.conversationHistory.slice(this.activeContextStartIndex)
+        // Build messages: system + conversation history + new user message
         const messages: Message[] = [
           { role: 'system', content: systemPrompt },
-          ...(contextHistoryMsg ? [{ role: 'user' as const, content: contextHistoryMsg }] : []),
-          ...activeMessages,
+          ...this.conversationHistory,
           { role: 'user', content: userMessage },
         ]
         this.lastLlmInputSnapshot = {
@@ -2103,14 +1865,12 @@ export class Brain {
             attempt,
             maxAttempts,
             messageCount: messages.length,
-            timeoutMs: attemptTimeoutMs,
-            remainingTurnMs,
           },
         })
 
         const traceStart = Date.now()
 
-        const llmResult = await this.callLLMWithTimeout(messages, attemptTimeoutMs)
+        const llmResult = await this.callLLM(messages)
 
         const content = llmResult.text
         const reasoning = llmResult.reasoning
@@ -2281,14 +2041,10 @@ export class Brain {
         ...(capturedReasoning && { reasoning: capturedReasoning }),
       } as Message)
 
-      // Trim conversation history as an in-memory safety net.
-      // The active context boundary system handles LLM context window sizing;
-      // this only prevents unbounded memory growth for very long sessions.
+      // Trim conversation history as an in-memory safety net for long sessions.
       if (this.conversationHistory.length > MAX_CONVERSATION_HISTORY_MESSAGES) {
         const trimCount = this.conversationHistory.length - MAX_CONVERSATION_HISTORY_MESSAGES
         this.conversationHistory = this.conversationHistory.slice(trimCount)
-        // Adjust the active context start index to account for removed messages
-        this.activeContextStartIndex = Math.max(0, this.activeContextStartIndex - trimCount)
       }
 
       const actionDefs = new Map(this.deps.taskExecutor.getAvailableActions().map(action => [action.name, action]))
@@ -2509,17 +2265,6 @@ export class Brain {
       parts.push(`[ERROR_BURST] active=yes`)
     }
 
-    // Context boundary status — reminds the model to use enterContext/exitContext
-    const activeLabel = this.activeContextState.label
-    const activeCount = this.conversationHistory.length - this.activeContextStartIndex
-    const archivedCount = this.archivedContexts.length
-    if (activeLabel) {
-      parts.push(`[CONTEXT] active="${activeLabel}" (${activeCount} messages); archived=${archivedCount}`)
-    }
-    else {
-      parts.push(`[CONTEXT] no active context (${activeCount} messages unmanaged); archived=${archivedCount}. Remember: call enterContext('label') when starting a task.`)
-    }
-
     return parts.join('\n\n')
   }
 
diff --git a/services/minecraft/src/cognitive/conscious/context-summary.ts b/services/minecraft/src/cognitive/conscious/context-summary.ts
deleted file mode 100644
index 420999359..000000000
--- a/services/minecraft/src/cognitive/conscious/context-summary.ts
+++ /dev/null
@@ -1,182 +0,0 @@
-import type { Message } from '@xsai/shared-chat'
-
-import type { LlmLogEntry } from './llm-log'
-
-/**
- * Archived context boundary produced by exitContext().
- * Each entry represents a completed task block whose messages have been
- * removed from the active conversation history and replaced by this summary.
- */
-export interface ArchivedContext {
-  label: string
-  summary: string
-  startTurnId: number
-  endTurnId: number
-  messageCount: number
-  archivedAt: number
-}
-
-/**
- * Tracks the currently active context boundary.
- */
-export interface ActiveContextState {
-  label: string | null
-  startTurnId: number
-  startedAt: number
-}
-
-interface ContextSummaryInput {
-  messages: Message[]
-  label: string | null
-  llmLogEntries: readonly LlmLogEntry[]
-  startTurnId: number
-  endTurnId: number
-}
-
-const MAX_SUMMARY_ACTIONS = 5
-const MAX_SUMMARY_LENGTH = 600
-
-/**
- * Generate a deterministic heuristic summary from a block of conversation
- * messages and their associated llmLog entries. No LLM call is made.
- *
- * The summary captures:
- * - Context label (if provided via enterContext)
- * - The triggering player instruction (if any)
- * - Action sequence with outcomes
- * - Turn count
- */
-export function generateContextSummary(input: ContextSummaryInput): string {
-  const { messages, label, llmLogEntries, startTurnId, endTurnId } = input
-
-  const parts: string[] = []
-
-  // Label
-  if (label) {
-    parts.push(`Task: ${label}`)
-  }
-
-  // Find the first player chat message in this context block
-  const playerInstruction = findPlayerInstruction(messages)
-  if (playerInstruction) {
-    parts.push(`Trigger: ${truncate(playerInstruction, 120)}`)
-  }
-
-  // Extract action outcomes from llmLog entries within this turn range
-  const actions = extractActionSummaries(llmLogEntries, startTurnId, endTurnId)
-  if (actions.length > 0) {
-    const actionLines = actions.slice(0, MAX_SUMMARY_ACTIONS).map(a => `  ${a}`)
-    parts.push(`Actions:\n${actionLines.join('\n')}`)
-  }
-
-  // Turn count
-  const turnCount = endTurnId - startTurnId + 1
-  parts.push(`Turns: ${turnCount} (${startTurnId}–${endTurnId})`)
-
-  const result = parts.join('\n')
-  return truncate(result, MAX_SUMMARY_LENGTH)
-}
-
-/**
- * Build the [CONTEXT_HISTORY] message content from archived context summaries.
- * Returns null if there are no archived contexts.
- */
-export function buildContextHistoryMessage(archives: readonly ArchivedContext[]): string | null {
-  if (archives.length === 0)
-    return null
-
-  const sections = archives.map((ctx, i) => {
-    const header = `[${i + 1}] ${ctx.label || 'unnamed'}`
-    return `${header}\n${ctx.summary}`
-  })
-
-  return `[CONTEXT_HISTORY] Completed task summaries (${archives.length}):\n\n${sections.join('\n\n')}`
-}
-
-/**
- * Collapse the oldest N archived contexts into a single meta-summary.
- * Used when the number of archived contexts exceeds the prefix limit.
- */
-export function collapseOldestContexts(
-  archives: ArchivedContext[],
-  collapseCount: number,
-): ArchivedContext[] {
-  if (collapseCount <= 0 || archives.length <= collapseCount)
-    return archives
-
-  const toCollapse = archives.slice(0, collapseCount)
-  const remaining = archives.slice(collapseCount)
-
-  const labels = toCollapse
-    .map(ctx => ctx.label || 'unnamed')
-    .join(', ')
-
-  const totalMessages = toCollapse.reduce((sum, ctx) => sum + ctx.messageCount, 0)
-  const totalTurns = toCollapse.reduce((sum, ctx) => sum + (ctx.endTurnId - ctx.startTurnId + 1), 0)
-
-  const collapsed: ArchivedContext = {
-    label: `(collapsed: ${labels})`,
-    summary: `Collapsed ${toCollapse.length} earlier contexts (${totalTurns} turns, ${totalMessages} messages). Topics: ${labels}.`,
-    startTurnId: toCollapse[0].startTurnId,
-    endTurnId: toCollapse.at(-1).endTurnId,
-    messageCount: totalMessages,
-    archivedAt: Date.now(),
-  }
-
-  return [collapsed, ...remaining]
-}
-
-// --- Helpers ---
-
-function findPlayerInstruction(messages: Message[]): string | null {
-  for (const msg of messages) {
-    if (msg.role !== 'user' || typeof msg.content !== 'string')
-      continue
-    // Player chat events are formatted as "[EVENT] <player> whispered: ..." or "[EVENT] <player>: ..."
-    const match = msg.content.match(/\[EVENT\]\s*(?:<\w+>|\w+)\s*(?:whispered:|:)\s*(.+)/i)
-    if (match?.[1])
-      return match[1].trim()
-  }
-  return null
-}
-
-function extractActionSummaries(
-  entries: readonly LlmLogEntry[],
-  startTurnId: number,
-  endTurnId: number,
-): string[] {
-  const summaries: string[] = []
-
-  for (const entry of entries) {
-    if (entry.turnId < startTurnId || entry.turnId > endTurnId)
-      continue
-
-    // Capture action queue results (success/failure)
-    if (entry.kind === 'scheduler' && entry.tags.includes('action_queue')) {
-      if (entry.tags.includes('success') || entry.tags.includes('failure')) {
-        const tool = entry.tags.find(t => !['scheduler', 'action_queue', 'success', 'failure'].includes(t)) ?? '?'
-        const status = entry.tags.includes('success') ? 'ok' : 'fail'
-        summaries.push(`${tool}: ${status}`)
-      }
-    }
-
-    // Capture direct repl_result action summaries
-    if (entry.kind === 'repl_result' && entry.metadata) {
-      const meta = entry.metadata as Record<string, unknown>
-      const actions = meta.actions as Array<{ tool: string, ok: boolean }> | undefined
-      if (actions && Array.isArray(actions)) {
-        for (const action of actions) {
-          if (action.tool === 'skip')
-            continue
-          summaries.push(`${action.tool}: ${action.ok ? 'ok' : 'fail'}`)
-        }
-      }
-    }
-  }
-
-  return summaries
-}
-
-function truncate(text: string, maxLength: number): string {
-  return text.length <= maxLength ? text : `${text.slice(0, maxLength - 3)}...`
-}
diff --git a/services/minecraft/src/cognitive/conscious/history-query.ts b/services/minecraft/src/cognitive/conscious/history-query.ts
index 89b6ee002..d96b1d937 100644
--- a/services/minecraft/src/cognitive/conscious/history-query.ts
+++ b/services/minecraft/src/cognitive/conscious/history-query.ts
@@ -1,6 +1,5 @@
 import type { Message } from '@xsai/shared-chat'
 
-import type { ArchivedContext } from './context-summary'
 import type { LlmLogEntry } from './llm-log'
 
 /**
@@ -16,21 +15,18 @@ export interface TurnSummary {
 
 interface HistoryQueryDeps {
   getConversationHistory: () => readonly Message[]
-  getArchivedContexts: () => readonly ArchivedContext[]
   getLlmLogEntries: () => readonly LlmLogEntry[]
   getCurrentTurnId: () => number
 }
 
 /**
  * Creates the `history` runtime object exposed to the REPL sandbox.
- * Provides search-oriented access to the full conversation history
- * (both active context and archived contexts) without requiring all
- * messages to be in the LLM prompt.
+ * Provides search-oriented access to the in-memory conversation history.
  */
 export function createHistoryRuntime(deps: HistoryQueryDeps) {
   return {
     /**
-     * Last N user/assistant message pairs from the current active context.
+     * Last N user/assistant message pairs from conversation history.
      */
     recent(n = 5): Array<{ role: string, content: string }> {
       const history = deps.getConversationHistory()
@@ -51,37 +47,23 @@ export function createHistoryRuntime(deps: HistoryQueryDeps) {
     },
 
     /**
-     * Text search across ALL history (archived summaries + active messages).
+     * Text search across conversation history.
      * Returns matching messages with their role and a content snippet.
      */
-    search(query: string, maxResults = 10): Array<{ role: string, content: string, source: 'active' | 'archived' }> {
+    search(query: string, maxResults = 10): Array<{ role: string, content: string, source: 'conversation' }> {
       if (!query || typeof query !== 'string')
         return []
 
       const needle = query.toLowerCase()
-      const results: Array<{ role: string, content: string, source: 'active' | 'archived' }> = []
+      const results: Array<{ role: string, content: string, source: 'conversation' }> = []
 
-      // Search archived context summaries
-      for (const ctx of deps.getArchivedContexts()) {
-        if (ctx.summary.toLowerCase().includes(needle) || (ctx.label && ctx.label.toLowerCase().includes(needle))) {
-          results.push({
-            role: 'context',
-            content: `[${ctx.label || 'unnamed'}] ${ctx.summary}`,
-            source: 'archived',
-          })
-          if (results.length >= maxResults)
-            return results
-        }
-      }
-
-      // Search active conversation history
       for (const msg of deps.getConversationHistory()) {
         const content = typeof msg.content === 'string' ? msg.content : String(msg.content)
         if (content.toLowerCase().includes(needle)) {
           results.push({
             role: msg.role,
             content: content.length > 300 ? `${content.slice(0, 297)}...` : content,
-            source: 'active',
+            source: 'conversation',
           })
           if (results.length >= maxResults)
             return results
@@ -161,38 +143,7 @@ export function createHistoryRuntime(deps: HistoryQueryDeps) {
     },
 
     /**
-     * List all archived context summaries.
-     */
-    contexts(): Array<{ label: string, summary: string, turns: number, archivedAt: number }> {
-      return deps.getArchivedContexts().map(ctx => ({
-        label: ctx.label,
-        summary: ctx.summary,
-        turns: ctx.endTurnId - ctx.startTurnId + 1,
-        archivedAt: ctx.archivedAt,
-      }))
-    },
-
-    /**
-     * Get a specific archived context by label (partial match).
-     */
-    context(label: string): { label: string, summary: string, turns: number } | null {
-      if (!label || typeof label !== 'string')
-        return null
-      const needle = label.toLowerCase()
-      const found = deps.getArchivedContexts().find(
-        ctx => ctx.label.toLowerCase().includes(needle),
-      )
-      if (!found)
-        return null
-      return {
-        label: found.label,
-        summary: found.summary,
-        turns: found.endTurnId - found.startTurnId + 1,
-      }
-    },
-
-    /**
-     * Total message count in the active conversation history.
+     * Total message count in the conversation history.
      */
     count(): number {
       return deps.getConversationHistory().length
diff --git a/services/minecraft/src/cognitive/conscious/js-planner-sandbox-protocol.ts b/services/minecraft/src/cognitive/conscious/js-planner-sandbox-protocol.ts
new file mode 100644
index 000000000..b22f79b68
--- /dev/null
+++ b/services/minecraft/src/cognitive/conscious/js-planner-sandbox-protocol.ts
@@ -0,0 +1,152 @@
+import type { ActionInstruction } from '../action/types'
+import type { BotEvent } from '../types'
+
+export interface ActionRuntimeResult {
+  action: ActionInstruction
+  ok: boolean
+  result?: unknown
+  error?: string
+}
+
+export interface QuerySeed {
+  blocks: Array<Record<string, unknown>>
+  craftable: string[]
+  entities: Array<Record<string, unknown>>
+  gaze: unknown[]
+  inventory: Array<Record<string, unknown>>
+  self: Record<string, unknown> | null
+}
+
+export interface HistorySeed {
+  conversationHistory: Array<{ role: string, content: string }>
+  currentTurn: number
+  llmLogEntries: Array<Record<string, unknown>>
+}
+
+export interface RuntimeSnapshot {
+  actionQueue: unknown
+  currentInput: unknown
+  errorBurstGuard: unknown
+  event: BotEvent
+  historySeed: HistorySeed
+  lastAction: ActionRuntimeResult | null
+  llmInput: {
+    attempt: number
+    conversationHistory: unknown[]
+    messages: unknown[]
+    systemPrompt: string
+    updatedAt: number
+    userMessage: string
+  } | null | undefined
+  llmLogEntries: Array<Record<string, unknown>>
+  mem: Record<string, unknown>
+  noActionBudget: unknown
+  prevRun: { actions: ActionRuntimeResult[], logs: string[], returnRaw?: unknown } | null
+  querySeed: QuerySeed | null
+  snapshot: Record<string, unknown>
+}
+
+export interface BridgeAvailability {
+  forgetConversation: boolean
+  getNoActionBudget: boolean
+  notifyAiri: boolean
+  patternFind: boolean
+  patternGet: boolean
+  patternIds: boolean
+  patternList: boolean
+  queryBlockAt: boolean
+  queryMap: boolean
+  setNoActionBudget: boolean
+  updateAiriContext: boolean
+}
+
+export interface SandboxWorkerRequest {
+  bootstrapScript: string
+  bridgeAvailability: BridgeAvailability
+  memoryLimitMb: number
+  runtime: RuntimeSnapshot
+  script: string
+  timeoutMs: number
+  toolNames: string[]
+}
+
+export interface SandboxWorkerResult {
+  logs: string[]
+  mem: Record<string, unknown>
+  returnRaw?: unknown
+}
+
+export interface SerializedWorkerError {
+  message: string
+  name: string
+  stack?: string
+}
+
+export interface SandboxWorkerState {
+  logs: string[]
+  mem: Record<string, unknown>
+}
+
+export type WorkerToParentMessage
+  = | { type: 'ready' }
+    | { type: 'bridge-request', requestId: number, method: string, args: unknown[] }
+    | { type: 'result', result: SandboxWorkerResult }
+    | { type: 'error', error: SerializedWorkerError, state?: SandboxWorkerState }
+    | { type: 'catastrophic-error', error: SerializedWorkerError }
+
+export type ParentToWorkerMessage
+  = | { type: 'evaluate', payload: SandboxWorkerRequest }
+    | { type: 'bridge-response', requestId: number, ok: true, result?: unknown }
+    | { type: 'bridge-response', requestId: number, ok: false, error: SerializedWorkerError }
+
+function workerErrorName(error: unknown): string {
+  if (typeof error === 'object' && error !== null && 'name' in error && typeof error.name === 'string')
+    return error.name
+  if (error instanceof Error)
+    return error.name
+  return 'Error'
+}
+
+function workerErrorMessage(error: unknown): string {
+  if (typeof error === 'object' && error !== null && 'message' in error && typeof error.message === 'string')
+    return error.message
+  if (error instanceof Error)
+    return error.message
+  return String(error)
+}
+
+function workerErrorStack(error: unknown): string | undefined {
+  if (typeof error === 'object' && error !== null && 'stack' in error && typeof error.stack === 'string')
+    return error.stack
+  if (error instanceof Error)
+    return error.stack
+  return undefined
+}
+
+export function serializeWorkerError(error: unknown): SerializedWorkerError {
+  const stack = workerErrorStack(error)
+  return stack
+    ? {
+        message: workerErrorMessage(error),
+        name: workerErrorName(error),
+        stack,
+      }
+    : {
+        message: workerErrorMessage(error),
+        name: workerErrorName(error),
+      }
+}
+
+export function hydrateWorkerError(error: SerializedWorkerError): Error {
+  const hydrated = new Error(error.message)
+  hydrated.name = error.name
+  if (error.stack)
+    hydrated.stack = error.stack
+  return hydrated
+}
+
+export function createWorkerError(message: string, state?: SandboxWorkerState, cause?: unknown): Error & { state?: SandboxWorkerState } {
+  const error = cause instanceof Error ? cause : new Error(message)
+  error.message = message
+  return Object.assign(error, state ? { state } : {})
+}
diff --git a/services/minecraft/src/cognitive/conscious/js-planner-sandbox-runner.ts b/services/minecraft/src/cognitive/conscious/js-planner-sandbox-runner.ts
new file mode 100644
index 000000000..bdfb49f05
--- /dev/null
+++ b/services/minecraft/src/cognitive/conscious/js-planner-sandbox-runner.ts
@@ -0,0 +1,196 @@
+import type {
+  ParentToWorkerMessage,
+  SandboxWorkerRequest,
+  SandboxWorkerResult,
+  WorkerToParentMessage,
+} from './js-planner-sandbox-protocol'
+
+import { fork } from 'node:child_process'
+import { realpathSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { errorMessageFrom } from '@moeru/std'
+
+import {
+  createWorkerError,
+  serializeWorkerError,
+} from './js-planner-sandbox-protocol'
+
+const require = createRequire(import.meta.url)
+
+const SANDBOX_WORKER_ENTRY_PATH = realpathSync(fileURLToPath(new URL('./js-planner-worker.ts', import.meta.url)))
+const ISOLATED_VM_ENTRY_PATH = realpathSync(require.resolve('isolated-vm'))
+const SANDBOX_SOURCE_DIRECTORY = realpathSync(dirname(SANDBOX_WORKER_ENTRY_PATH))
+
+function ancestorPath(path: string, levels: number): string {
+  let current = path
+  for (let index = 0; index < levels; index++)
+    current = dirname(current)
+  return current
+}
+
+const PNPM_MODULE_STORE_PATH = realpathSync(ancestorPath(ISOLATED_VM_ENTRY_PATH, 4))
+
+function cloneStructured<T>(value: T): T {
+  if (typeof value === 'undefined')
+    return value
+
+  try {
+    return structuredClone(value)
+  }
+  catch {
+    return JSON.parse(JSON.stringify(value)) as T
+  }
+}
+
+interface SandboxRunnerOptions {
+  bridgeTimeoutMs: number
+  maxBridgeCalls: number
+  onBridgeRequest: (method: string, args: unknown[]) => Promise<unknown>
+}
+
+export async function executeSandboxWorker(
+  request: SandboxWorkerRequest,
+  options: SandboxRunnerOptions,
+): Promise<SandboxWorkerResult> {
+  const hardTimeoutMs = Math.max(request.timeoutMs + 2_000, options.bridgeTimeoutMs + 2_000)
+
+  return await new Promise<SandboxWorkerResult>((resolve, reject) => {
+    const stderrChunks: string[] = []
+    let bridgeCallCount = 0
+    let hardTimeout: ReturnType<typeof setTimeout> | undefined
+    let settled = false
+
+    const child = fork(SANDBOX_WORKER_ENTRY_PATH, [ISOLATED_VM_ENTRY_PATH], {
+      cwd: SANDBOX_SOURCE_DIRECTORY,
+      env: {},
+      execArgv: [
+        '--permission',
+        '--allow-addons',
+        `--allow-fs-read=${SANDBOX_SOURCE_DIRECTORY}`,
+        `--allow-fs-read=${PNPM_MODULE_STORE_PATH}`,
+        '--disable-proto=throw',
+        '--frozen-intrinsics',
+        '--experimental-transform-types',
+        '--no-warnings',
+      ],
+      serialization: 'advanced',
+      stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+    })
+
+    const finalize = (handler: () => void) => {
+      if (settled)
+        return
+
+      settled = true
+      if (hardTimeout)
+        clearTimeout(hardTimeout)
+      child.removeAllListeners()
+      child.stderr?.removeAllListeners()
+      handler()
+    }
+
+    const withCapturedStderr = (message: string): string => {
+      const stderr = stderrChunks.join('').trim()
+      return stderr.length > 0 ? `${message}\n${stderr}` : message
+    }
+
+    const respondToBridgeRequest = async (
+      message: Extract<WorkerToParentMessage, { type: 'bridge-request' }>,
+    ): Promise<void> => {
+      let response: ParentToWorkerMessage
+
+      try {
+        bridgeCallCount++
+        if (bridgeCallCount > options.maxBridgeCalls) {
+          throw new Error(`Sandbox bridge call limit exceeded: max ${options.maxBridgeCalls} per evaluation`)
+        }
+
+        const result = await Promise.race([
+          options.onBridgeRequest(message.method, message.args),
+          new Promise<never>((_, reject) => {
+            setTimeout(
+              () => reject(new Error(`Sandbox bridge timed out after ${options.bridgeTimeoutMs}ms for ${message.method}`)),
+              options.bridgeTimeoutMs,
+            )
+          }),
+        ])
+
+        response = {
+          type: 'bridge-response',
+          requestId: message.requestId,
+          ok: true,
+          result: cloneStructured(result),
+        }
+      }
+      catch (error) {
+        response = {
+          type: 'bridge-response',
+          requestId: message.requestId,
+          ok: false,
+          error: serializeWorkerError(error),
+        }
+      }
+
+      if (child.connected)
+        child.send(response)
+    }
+
+    hardTimeout = setTimeout(() => {
+      const timeoutError = createWorkerError(
+        withCapturedStderr(`Sandbox worker timed out after ${hardTimeoutMs}ms`),
+      )
+      void child.kill('SIGKILL')
+      finalize(() => reject(timeoutError))
+    }, hardTimeoutMs)
+
+    child.stderr?.on('data', chunk => stderrChunks.push(String(chunk)))
+
+    child.on('error', (error) => {
+      finalize(() => reject(createWorkerError(withCapturedStderr(errorMessageFrom(error) ?? String(error)), undefined, error)))
+    })
+
+    child.on('exit', (code, signal) => {
+      if (settled)
+        return
+
+      const reason = signal
+        ? `Sandbox worker exited via signal ${signal}`
+        : `Sandbox worker exited with code ${code ?? 'unknown'}`
+
+      finalize(() => reject(createWorkerError(withCapturedStderr(reason))))
+    })
+
+    child.on('message', (message: WorkerToParentMessage) => {
+      if (!message || typeof message !== 'object')
+        return
+
+      if (message.type === 'ready') {
+        child.send({ type: 'evaluate', payload: request } satisfies ParentToWorkerMessage)
+        return
+      }
+
+      if (message.type === 'bridge-request') {
+        void respondToBridgeRequest(message)
+        return
+      }
+
+      if (message.type === 'result') {
+        finalize(() => resolve(message.result))
+        return
+      }
+
+      if (message.type === 'error') {
+        finalize(() => reject(createWorkerError(withCapturedStderr(message.error.message), message.state, message.error)))
+        return
+      }
+
+      if (message.type === 'catastrophic-error') {
+        void child.kill('SIGKILL')
+        finalize(() => reject(createWorkerError(withCapturedStderr(message.error.message), undefined, message.error)))
+      }
+    })
+  })
+}
diff --git a/services/minecraft/src/cognitive/conscious/js-planner-worker.ts b/services/minecraft/src/cognitive/conscious/js-planner-worker.ts
new file mode 100644
index 000000000..2caa2868d
--- /dev/null
+++ b/services/minecraft/src/cognitive/conscious/js-planner-worker.ts
@@ -0,0 +1,291 @@
+import type {
+  ActionRuntimeResult,
+  ParentToWorkerMessage,
+  RuntimeSnapshot,
+  SandboxWorkerRequest,
+  SerializedWorkerError,
+  WorkerToParentMessage,
+} from './js-planner-sandbox-protocol'
+
+import process from 'node:process'
+
+import { pathToFileURL } from 'node:url'
+import { inspect } from 'node:util'
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function cloneStructured<T>(value: T): T {
+  if (typeof value === 'undefined')
+    return value
+
+  try {
+    return structuredClone(value)
+  }
+  catch {
+    return JSON.parse(JSON.stringify(value)) as T
+  }
+}
+
+function workerErrorName(error: unknown): string {
+  if (typeof error === 'object' && error !== null && 'name' in error && typeof error.name === 'string')
+    return error.name
+  if (error instanceof Error)
+    return error.name
+  return 'Error'
+}
+
+function workerErrorMessage(error: unknown): string {
+  if (typeof error === 'object' && error !== null && 'message' in error && typeof error.message === 'string')
+    return error.message
+  if (error instanceof Error)
+    return error.message
+  return String(error)
+}
+
+function workerErrorStack(error: unknown): string | undefined {
+  if (typeof error === 'object' && error !== null && 'stack' in error && typeof error.stack === 'string')
+    return error.stack
+  if (error instanceof Error)
+    return error.stack
+  return undefined
+}
+
+function serializeWorkerError(error: unknown): SerializedWorkerError {
+  const stack = workerErrorStack(error)
+  return stack
+    ? {
+        message: workerErrorMessage(error),
+        name: workerErrorName(error),
+        stack,
+      }
+    : {
+        message: workerErrorMessage(error),
+        name: workerErrorName(error),
+      }
+}
+
+function hydrateWorkerError(error: SerializedWorkerError): Error {
+  const hydrated = new Error(error.message)
+  hydrated.name = error.name
+  if (error.stack)
+    hydrated.stack = error.stack
+  return hydrated
+}
+
+function send(message: WorkerToParentMessage): void {
+  process.send?.(message)
+}
+
+function appendLog(logs: string[], args: unknown[]): string {
+  const rendered = args.map(arg => inspect(arg, { depth: 4, breakLength: 120 })).join(' ')
+  logs.push(rendered)
+  return rendered
+}
+
+function serializeBridgeValue(value: unknown): string {
+  return JSON.stringify({
+    isUndefined: typeof value === 'undefined',
+    value,
+  })
+}
+
+function readMemSnapshot(context: any, timeoutMs: number): Record<string, unknown> {
+  try {
+    const mem = context.evalSync('mem', { timeout: timeoutMs, copy: true })
+    return isRecord(mem) ? cloneStructured(mem) : {}
+  }
+  catch {
+    return {}
+  }
+}
+
+function setGlobalValue(globalRef: any, name: string, value: unknown, ivm: any): void {
+  if (typeof value === 'undefined') {
+    globalRef.setSync(name, undefined)
+    return
+  }
+
+  globalRef.setSync(name, new ivm.ExternalCopy(value).copyInto())
+}
+
+function bindDataGlobals(globalRef: any, runtime: RuntimeSnapshot, ivm: any): void {
+  const currentRun = {
+    actions: [] as ActionRuntimeResult[],
+    logs: [] as string[],
+    returnRaw: undefined,
+  }
+
+  setGlobalValue(globalRef, 'snapshot', runtime.snapshot, ivm)
+  setGlobalValue(globalRef, 'event', runtime.event, ivm)
+  globalRef.setSync('now', Date.now())
+  setGlobalValue(globalRef, 'self', runtime.snapshot.self ?? null, ivm)
+  setGlobalValue(globalRef, 'environment', runtime.snapshot.environment ?? null, ivm)
+  setGlobalValue(globalRef, 'social', runtime.snapshot.social ?? null, ivm)
+  setGlobalValue(globalRef, 'threat', runtime.snapshot.threat ?? null, ivm)
+  setGlobalValue(globalRef, 'attention', runtime.snapshot.attention ?? null, ivm)
+  setGlobalValue(globalRef, 'autonomy', runtime.snapshot.autonomy ?? null, ivm)
+  setGlobalValue(globalRef, 'llmInput', runtime.llmInput ?? null, ivm)
+  setGlobalValue(globalRef, 'currentInput', runtime.currentInput, ivm)
+  setGlobalValue(globalRef, 'llmLogSeed', runtime.llmLogEntries, ivm)
+  setGlobalValue(globalRef, 'historySeed', runtime.historySeed, ivm)
+  setGlobalValue(globalRef, 'actionQueue', runtime.actionQueue, ivm)
+  setGlobalValue(globalRef, 'noActionBudget', runtime.noActionBudget, ivm)
+  setGlobalValue(globalRef, 'errorBurstGuard', runtime.errorBurstGuard, ivm)
+  setGlobalValue(globalRef, 'llmMessages', runtime.llmInput?.messages ?? [], ivm)
+  globalRef.setSync('llmSystemPrompt', runtime.llmInput?.systemPrompt ?? '')
+  globalRef.setSync('llmUserMessage', runtime.llmInput?.userMessage ?? '')
+  setGlobalValue(globalRef, 'llmConversationHistory', runtime.llmInput?.conversationHistory ?? [], ivm)
+  setGlobalValue(globalRef, 'querySeed', runtime.querySeed, ivm)
+  globalRef.setSync('query', undefined)
+  globalRef.setSync('llmLog', null)
+  globalRef.setSync('history', null)
+  globalRef.setSync('patterns', null)
+  globalRef.setSync('bot', null)
+  globalRef.setSync('mineflayer', null)
+  setGlobalValue(globalRef, 'mem', runtime.mem, ivm)
+  setGlobalValue(globalRef, 'prevRun', runtime.prevRun, ivm)
+  setGlobalValue(globalRef, 'lastRun', currentRun, ivm)
+  setGlobalValue(globalRef, 'lastAction', runtime.lastAction, ivm)
+}
+
+let nextRequestId = 1
+const pendingRequests = new Map<number, { resolve: (value: unknown) => void, reject: (error: Error) => void }>()
+
+async function requestParent(method: string, args: unknown[]): Promise<unknown> {
+  const requestId = nextRequestId++
+  send({
+    type: 'bridge-request',
+    requestId,
+    method,
+    args: cloneStructured(args),
+  })
+
+  return await new Promise((resolve, reject) => {
+    pendingRequests.set(requestId, { resolve, reject })
+  })
+}
+
+async function runEvaluation(payload: SandboxWorkerRequest): Promise<void> {
+  const isolatedVmEntryPath = process.argv[2]
+  if (!isolatedVmEntryPath)
+    throw new Error('Sandbox worker missing isolated-vm entry path')
+
+  const ivmModule = await import(pathToFileURL(isolatedVmEntryPath).href)
+  const ivm = (ivmModule.default ?? ivmModule) as any
+  const logs: string[] = []
+
+  let bridgeRef: any
+  let context: any
+  let isolate: any
+  let returnRaw: unknown
+
+  try {
+    isolate = new ivm.Isolate({
+      memoryLimit: payload.memoryLimitMb,
+      onCatastrophicError: (error: unknown) => {
+        send({ type: 'catastrophic-error', error: serializeWorkerError(error) })
+      },
+    })
+
+    context = isolate.createContextSync()
+    const globalRef = context.global
+
+    bridgeRef = new ivm.Reference(async (method: string, args: unknown[]) => {
+      return serializeBridgeValue(await requestParent(method, args))
+    })
+
+    globalRef.setSync('globalThis', globalRef.derefInto())
+    globalRef.setSync('global', globalRef.derefInto())
+
+    bindDataGlobals(globalRef, payload.runtime, ivm)
+    globalRef.setSync('__plannerLog', new ivm.Callback((...args: unknown[]) => appendLog(logs, args)))
+    globalRef.setSync('__plannerBridge', bridgeRef)
+    setGlobalValue(globalRef, '__plannerBridgeAvailability', payload.bridgeAvailability, ivm)
+    setGlobalValue(globalRef, '__plannerBootstrapActionNames', payload.toolNames, ivm)
+
+    context.evalSync(payload.bootstrapScript, { timeout: payload.timeoutMs })
+
+    returnRaw = await context.evalClosure(
+      `return (async () => {\n${payload.script}\n})()`,
+      [],
+      {
+        timeout: payload.timeoutMs,
+        result: { copy: true, promise: true },
+      },
+    )
+
+    send({
+      type: 'result',
+      result: {
+        logs: cloneStructured(logs),
+        mem: readMemSnapshot(context, payload.timeoutMs),
+        returnRaw: typeof returnRaw === 'undefined' ? undefined : cloneStructured(returnRaw),
+      },
+    })
+  }
+  catch (error) {
+    send({
+      type: 'error',
+      error: serializeWorkerError(error),
+      state: {
+        logs: cloneStructured(logs),
+        mem: context ? readMemSnapshot(context, payload.timeoutMs) : {},
+      },
+    })
+  }
+  finally {
+    for (const pending of pendingRequests.values())
+      pending.reject(new Error('Sandbox worker is shutting down'))
+
+    pendingRequests.clear()
+    bridgeRef?.release?.()
+    context?.release?.()
+    isolate?.dispose?.()
+    process.disconnect?.()
+  }
+}
+
+let hasStarted = false
+
+process.on('message', (message: ParentToWorkerMessage) => {
+  if (!message || typeof message !== 'object')
+    return
+
+  if (message.type === 'bridge-response') {
+    const pending = pendingRequests.get(message.requestId)
+    if (!pending)
+      return
+
+    pendingRequests.delete(message.requestId)
+    if (message.ok)
+      pending.resolve(message.result)
+    else
+      pending.reject(hydrateWorkerError(message.error))
+    return
+  }
+
+  if (message.type === 'evaluate' && !hasStarted) {
+    hasStarted = true
+    void runEvaluation(message.payload)
+  }
+})
+
+process.on('disconnect', () => {
+  for (const pending of pendingRequests.values())
+    pending.reject(new Error('Sandbox worker lost its parent process'))
+  pendingRequests.clear()
+})
+
+process.on('uncaughtException', (error) => {
+  send({ type: 'error', error: serializeWorkerError(error) })
+  process.exitCode = 1
+})
+
+process.on('unhandledRejection', (reason) => {
+  send({ type: 'error', error: serializeWorkerError(reason) })
+  process.exitCode = 1
+})
+
+send({ type: 'ready' })
diff --git a/services/minecraft/src/cognitive/conscious/js-planner.test.ts b/services/minecraft/src/cognitive/conscious/js-planner.test.ts
index 37ff73b10..08c776c9c 100644
--- a/services/minecraft/src/cognitive/conscious/js-planner.test.ts
+++ b/services/minecraft/src/cognitive/conscious/js-planner.test.ts
@@ -358,6 +358,64 @@ describe('javaScriptPlanner', () => {
     expect(planned.actions).toHaveLength(0)
   })
 
+  it('bridges AIRI notification callbacks through the isolate', async () => {
+    const planner = new JavaScriptPlanner()
+    const executeAction = vi.fn(async action => `ok:${action.tool}`)
+    const notifyAiri = vi.fn()
+    const updateAiriContext = vi.fn()
+
+    const planned = await planner.evaluate(`
+      notifyAiri('Need help', 'Low health', 'immediate')
+      updateAiriContext('Shelter built', ['shelter', 'spawn'], 'memory')
+      return 'ok'
+    `, actions, {
+      ...globals,
+      notifyAiri,
+      updateAiriContext,
+    } as any, executeAction)
+
+    expect(planned.returnValue).toBe('\'ok\'')
+    expect(notifyAiri).toHaveBeenCalledWith('Need help', 'Low health', 'immediate')
+    expect(updateAiriContext).toHaveBeenCalledWith('Shelter built', ['shelter', 'spawn'], 'memory')
+  })
+
+  it('does not leak sandbox bridge handles into user scope', async () => {
+    const planner = new JavaScriptPlanner()
+    const executeAction = vi.fn(async action => `ok:${action.tool}`)
+    const planned = await planner.evaluate(`
+      return {
+        bridge: typeof __plannerBridge,
+        bridgeRef: typeof __plannerBridgeRef,
+        availability: typeof __plannerAvailability,
+        logRef: typeof __plannerLogRef,
+        queryMap: typeof __plannerQueryMap,
+      }
+    `, actions, globals, executeAction)
+
+    expect(planned.returnValue).toContain('bridge: \'undefined\'')
+    expect(planned.returnValue).toContain('bridgeRef: \'undefined\'')
+    expect(planned.returnValue).toContain('availability: \'undefined\'')
+    expect(planned.returnValue).toContain('logRef: \'undefined\'')
+    expect(planned.returnValue).toContain('queryMap: \'undefined\'')
+  })
+
+  it('fails closed when a host bridge call never resolves', async () => {
+    const planner = new JavaScriptPlanner({ bridgeTimeoutMs: 40 })
+    const executeAction = vi.fn(async () => await new Promise(() => {}))
+
+    await expect(planner.evaluate('await chat("hello")', actions, globals, executeAction)).rejects.toThrow(/Sandbox bridge timed out/i)
+  })
+
+  it('does not expose host process globals inside the isolate', async () => {
+    const planner = new JavaScriptPlanner()
+    const executeAction = vi.fn(async action => `ok:${action.tool}`)
+    const planned = await planner.evaluate('return { process: typeof process, require: typeof require, escaped: Function("return typeof process")() }', actions, globals, executeAction)
+
+    expect(planned.returnValue).toContain('process: \'undefined\'')
+    expect(planned.returnValue).toContain('require: \'undefined\'')
+    expect(planned.returnValue).toContain('escaped: \'undefined\'')
+  })
+
   it('renders nested return objects without [Object] truncation', async () => {
     const planner = new JavaScriptPlanner()
     const executeAction = vi.fn(async action => `ok:${action.tool}`)
diff --git a/services/minecraft/src/cognitive/conscious/js-planner.ts b/services/minecraft/src/cognitive/conscious/js-planner.ts
index e5214d70f..cb941d395 100644
--- a/services/minecraft/src/cognitive/conscious/js-planner.ts
+++ b/services/minecraft/src/cognitive/conscious/js-planner.ts
@@ -2,24 +2,28 @@ import type { Action } from '../../libs/mineflayer/action'
 import type { Mineflayer } from '../../libs/mineflayer/core'
 import type { ActionInstruction } from '../action/types'
 import type { BotEvent } from '../types'
+import type {
+  ActionRuntimeResult,
+  QuerySeed,
+  RuntimeSnapshot,
+  SandboxWorkerRequest,
+  SandboxWorkerState,
+} from './js-planner-sandbox-protocol'
 import type { PatternRuntime } from './patterns/types'
 
-import vm from 'node:vm'
-
 import { inspect } from 'node:util'
 
+import { errorMessageFrom } from '@moeru/std'
+
+import { executeSandboxWorker } from './js-planner-sandbox-runner'
 import { createQueryRuntime } from './query-dsl'
 
 interface JavaScriptPlannerOptions {
+  bridgeTimeoutMs?: number
   timeoutMs?: number
   maxActionsPerTurn?: number
-}
-
-interface ActionRuntimeResult {
-  action: ActionInstruction
-  ok: boolean
-  result?: unknown
-  error?: string
+  maxBridgeCalls?: number
+  memoryLimitMb?: number
 }
 
 interface ActivePlannerRun {
@@ -36,33 +40,421 @@ interface ValidationResult {
   error?: string
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-function isCoord(value: unknown): value is { x: number, y: number, z: number } {
-  return isRecord(value)
-    && typeof value.x === 'number'
-    && typeof value.y === 'number'
-    && typeof value.z === 'number'
-}
-
-function deepFreeze<T>(value: T): T {
-  if (!value || typeof value !== 'object')
-    return value
-
-  for (const key of Object.keys(value as Record<string, unknown>)) {
-    const child = (value as Record<string, unknown>)[key]
-    deepFreeze(child)
+const QUERY_BOOTSTRAP = String.raw`
+class PlannerNameQueryChain {
+  constructor(values, predicates = [], dedupe = false) {
+    this.values = values
+    this.predicates = predicates
+    this.dedupe = dedupe
   }
 
-  return Object.freeze(value)
+  whereIncludes(fragment) {
+    const needle = String(fragment).toLowerCase()
+    return new PlannerNameQueryChain(
+      this.values,
+      [...this.predicates, value => String(value).toLowerCase().includes(needle)],
+      this.dedupe,
+    )
+  }
+
+  uniq() {
+    return new PlannerNameQueryChain(this.values, this.predicates, true)
+  }
+
+  list() {
+    let result = this.values.filter(value => this.predicates.every(predicate => predicate(value)))
+    if (this.dedupe)
+      result = [...new Set(result)]
+    return result
+  }
 }
 
-function toStructuredClone<T>(value: T): T {
-  return JSON.parse(JSON.stringify(value)) as T
+class PlannerBlockQueryChain {
+  constructor(records, state = { range: 16, limit: 200, predicates: [] }) {
+    this.records = records
+    this.state = state
+  }
+
+  within(range) {
+    return this.clone({ range: __plannerClamp(Math.floor(range), 1, 64) })
+  }
+
+  limit(limit) {
+    return this.clone({ limit: __plannerClamp(Math.floor(limit), 1, 500) })
+  }
+
+  isOre() {
+    return this.clone({ predicates: [...this.state.predicates, block => __plannerIsOreName(block.name)] })
+  }
+
+  whereName(nameOrNames) {
+    const names = new Set((Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames]).map(name => String(name).toLowerCase()))
+    return this.clone({ predicates: [...this.state.predicates, block => names.has(String(block.name).toLowerCase())] })
+  }
+
+  sortByDistance() {
+    return this
+  }
+
+  names() {
+    return new PlannerNameQueryChain(this.list().map(block => block.name))
+  }
+
+  first() {
+    return this.list()[0] ?? null
+  }
+
+  list() {
+    const filtered = this.records
+      .filter(block => typeof block.distance === 'number' && block.distance <= this.state.range)
+      .filter(block => this.state.predicates.every(predicate => predicate(block)))
+      .sort((a, b) => a.distance - b.distance)
+    return filtered.slice(0, this.state.limit)
+  }
+
+  clone(patch) {
+    return new PlannerBlockQueryChain(this.records, { ...this.state, ...patch })
+  }
 }
 
+class PlannerEntityQueryChain {
+  constructor(records, state = { range: 16, limit: 200, predicates: [] }) {
+    this.records = records
+    this.state = state
+  }
+
+  within(range) {
+    return this.clone({ range: __plannerClamp(Math.floor(range), 1, 128) })
+  }
+
+  limit(limit) {
+    return this.clone({ limit: __plannerClamp(Math.floor(limit), 1, 500) })
+  }
+
+  whereType(typeOrTypes) {
+    const types = new Set((Array.isArray(typeOrTypes) ? typeOrTypes : [typeOrTypes]).map(type => String(type).toLowerCase()))
+    return this.clone({ predicates: [...this.state.predicates, entity => types.has(String(entity.name ?? entity.type).toLowerCase())] })
+  }
+
+  names() {
+    return new PlannerNameQueryChain(this.list().map(entity => entity.name))
+  }
+
+  first() {
+    return this.list()[0] ?? null
+  }
+
+  list() {
+    const filtered = this.records
+      .filter(entity => typeof entity.distance === 'number' && entity.distance <= this.state.range)
+      .filter(entity => this.state.predicates.every(predicate => predicate(entity)))
+      .sort((a, b) => a.distance - b.distance)
+    return filtered.slice(0, this.state.limit)
+  }
+
+  clone(patch) {
+    return new PlannerEntityQueryChain(this.records, { ...this.state, ...patch })
+  }
+}
+
+class PlannerInventoryQueryChain {
+  constructor(records, state = { predicates: [] }) {
+    this.records = records
+    this.state = state
+  }
+
+  whereName(nameOrNames) {
+    const names = new Set((Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames]).map(name => String(name).toLowerCase()))
+    return this.clone({ predicates: [...this.state.predicates, item => names.has(String(item.name).toLowerCase())] })
+  }
+
+  names() {
+    return new PlannerNameQueryChain(this.list().map(item => item.name))
+  }
+
+  countByName() {
+    return this.list().reduce((counts, item) => {
+      counts[item.name] = (counts[item.name] ?? 0) + item.count
+      return counts
+    }, {})
+  }
+
+  count(name) {
+    const needle = String(name).toLowerCase()
+    return this.list()
+      .filter(item => String(item.name).toLowerCase() === needle)
+      .reduce((sum, item) => sum + item.count, 0)
+  }
+
+  has(name, atLeast = 1) {
+    return this.count(name) >= Math.max(1, Math.floor(atLeast))
+  }
+
+  summary() {
+    const counts = this.countByName()
+    return Object.entries(counts)
+      .map(([name, count]) => ({ name, count }))
+      .sort((a, b) => {
+        if (b.count !== a.count)
+          return b.count - a.count
+        return a.name.localeCompare(b.name)
+      })
+  }
+
+  list() {
+    return this.records.filter(item => this.state.predicates.every(predicate => predicate(item)))
+  }
+
+  clone(patch) {
+    return new PlannerInventoryQueryChain(this.records, { ...this.state, ...patch })
+  }
+}
+
+function __plannerClamp(value, min, max) {
+  return Math.min(max, Math.max(min, value))
+}
+
+function __plannerIsOreName(name) {
+  return String(name).endsWith('_ore') || name === 'ancient_debris'
+}
+
+function __plannerCreateQueryRuntime(seed) {
+  if (!seed)
+    return undefined
+
+  return {
+    self: () => seed.self,
+    snapshot: (range = 16) => {
+      const normalizedRange = __plannerClamp(Math.floor(range), 1, 64)
+      const inventory = new PlannerInventoryQueryChain(seed.inventory)
+      const blockQuery = new PlannerBlockQueryChain(seed.blocks).within(normalizedRange).limit(20)
+      const entityQuery = new PlannerEntityQueryChain(seed.entities).within(normalizedRange).limit(20)
+      return {
+        self: seed.self,
+        inventory: {
+          counts: inventory.countByName(),
+          summary: inventory.summary(),
+          emptySlots: Math.max(0, 36 - inventory.list().length),
+          totalStacks: inventory.list().length,
+        },
+        nearby: {
+          blocks: blockQuery.list(),
+          entities: entityQuery.list(),
+          ores: blockQuery.isOre().list(),
+        },
+      }
+    },
+    blocks: () => new PlannerBlockQueryChain(seed.blocks),
+    blockAt: position => __plannerQueryBlockAt ? __plannerQueryBlockAt(position) : null,
+    entities: () => new PlannerEntityQueryChain(seed.entities),
+    inventory: () => new PlannerInventoryQueryChain(seed.inventory),
+    craftable: () => new PlannerNameQueryChain(seed.craftable),
+    gaze: options => {
+      const range = typeof options?.range === 'number' ? options.range : 16
+      return seed.gaze.filter(item => typeof item?.distance !== 'number' || item.distance <= range)
+    },
+    map: options => __plannerQueryMap ? __plannerQueryMap(options) : null,
+  }
+}
+
+function __plannerCreateLlmLogRuntime(entries) {
+  class PlannerLlmLogQuery {
+    constructor(sourceEntries, predicates = [], sorter = undefined, sliceLatest = undefined) {
+      this.sourceEntries = sourceEntries
+      this.predicates = predicates
+      this.sorter = sorter
+      this.sliceLatest = sliceLatest
+    }
+
+    whereKind(kind) {
+      const set = new Set(Array.isArray(kind) ? kind : [kind])
+      return this.clone({ predicates: [...this.predicates, entry => set.has(entry.kind)] })
+    }
+
+    whereTag(tag) {
+      const set = new Set((Array.isArray(tag) ? tag : [tag]).map(item => String(item).toLowerCase()))
+      return this.clone({ predicates: [...this.predicates, entry => entry.tags.some(item => set.has(String(item).toLowerCase()))] })
+    }
+
+    whereSource(sourceType, sourceId) {
+      return this.clone({ predicates: [...this.predicates, entry => {
+        if (entry.sourceType !== sourceType)
+          return false
+        if (sourceId !== undefined)
+          return entry.sourceId === sourceId
+        return true
+      }] })
+    }
+
+    errors() {
+      return this.whereTag('error')
+    }
+
+    turns() {
+      return this.whereKind('turn_input')
+    }
+
+    between(startTs, endTs) {
+      return this.clone({ predicates: [...this.predicates, entry => entry.timestamp >= startTs && entry.timestamp <= endTs] })
+    }
+
+    textIncludes(fragment) {
+      const needle = String(fragment).toLowerCase()
+      return this.clone({ predicates: [...this.predicates, entry => String(entry.text).toLowerCase().includes(needle)] })
+    }
+
+    latest(count) {
+      return this.clone({ sorter: (a, b) => b.timestamp - a.timestamp, sliceLatest: Math.max(1, Math.floor(count)) })
+    }
+
+    list() {
+      let result = this.sourceEntries.filter(entry => this.predicates.every(predicate => predicate(entry)))
+      if (this.sorter)
+        result = [...result].sort(this.sorter)
+      if (this.sliceLatest !== undefined)
+        result = result.slice(0, this.sliceLatest)
+      return result.map(entry => ({ ...entry, tags: [...(entry.tags ?? [])] }))
+    }
+
+    first() {
+      return this.list()[0] ?? null
+    }
+
+    count() {
+      return this.list().length
+    }
+
+    clone(patch) {
+      return new PlannerLlmLogQuery(
+        this.sourceEntries,
+        patch.predicates ?? this.predicates,
+        patch.sorter ?? this.sorter,
+        patch.sliceLatest ?? this.sliceLatest,
+      )
+    }
+  }
+
+  return {
+    entries: Array.isArray(entries) ? entries.map(entry => ({ ...entry, tags: [...(entry.tags ?? [])] })) : [],
+    query: () => new PlannerLlmLogQuery(Array.isArray(entries) ? entries : []),
+    latest: (count = 20) => new PlannerLlmLogQuery(Array.isArray(entries) ? entries : []).latest(count).list(),
+    byId: (id) => {
+      const item = (Array.isArray(entries) ? entries : []).find(entry => entry.id === id)
+      return item ? { ...item, tags: [...(item.tags ?? [])] } : null
+    },
+  }
+}
+
+function __plannerCreateHistoryRuntime(seed) {
+  if (!seed)
+    return null
+
+  const conversationHistory = Array.isArray(seed.conversationHistory) ? seed.conversationHistory : []
+  const llmLogEntries = Array.isArray(seed.llmLogEntries) ? seed.llmLogEntries : []
+  const currentTurnId = typeof seed.currentTurn === 'number' ? seed.currentTurn : 0
+
+  return {
+    recent: (n = 5) => {
+      const pairs = []
+      for (let i = conversationHistory.length - 1; i >= 0 && pairs.length < n * 2; i--) {
+        const msg = conversationHistory[i]
+        if (msg.role === 'user' || msg.role === 'assistant') {
+          pairs.unshift({
+            role: msg.role,
+            content: typeof msg.content === 'string' ? msg.content : String(msg.content),
+          })
+        }
+      }
+      return pairs.slice(-(n * 2))
+    },
+    search: (query, maxResults = 10) => {
+      if (!query || typeof query !== 'string')
+        return []
+
+      const needle = query.toLowerCase()
+      const results = []
+      for (const msg of conversationHistory) {
+        const content = typeof msg.content === 'string' ? msg.content : String(msg.content)
+        if (content.toLowerCase().includes(needle)) {
+          results.push({
+            role: msg.role,
+            content: content.length > 300 ? content.slice(0, 297) + '...' : content,
+            source: 'conversation',
+          })
+          if (results.length >= maxResults)
+            return results
+        }
+      }
+      return results
+    },
+    turns: (n = 10) => {
+      const turnMap = new Map()
+      for (const entry of llmLogEntries) {
+        if (entry.kind !== 'turn_input')
+          continue
+
+        turnMap.set(entry.turnId, {
+          turnId: entry.turnId,
+          eventType: entry.eventType,
+          actionCount: 0,
+          hasError: false,
+          text: entry.text,
+        })
+      }
+
+      for (const entry of llmLogEntries) {
+        if (entry.kind !== 'repl_result')
+          continue
+
+        const turn = turnMap.get(entry.turnId)
+        if (!turn)
+          continue
+
+        const meta = entry.metadata && typeof entry.metadata === 'object' ? entry.metadata : undefined
+        if (meta) {
+          turn.actionCount = typeof meta.actionCount === 'number' ? meta.actionCount : 0
+          turn.hasError = (typeof meta.errorCount === 'number' && meta.errorCount > 0)
+            || (Array.isArray(entry.tags) && entry.tags.includes('error'))
+        }
+      }
+
+      for (const entry of llmLogEntries) {
+        if (entry.kind !== 'repl_error')
+          continue
+
+        const turn = turnMap.get(entry.turnId)
+        if (turn)
+          turn.hasError = true
+      }
+
+      const sorted = [...turnMap.values()].sort((a, b) => b.turnId - a.turnId)
+      return sorted.slice(0, Math.max(1, Math.floor(n)))
+    },
+    playerChats: (n = 5) => {
+      const chats = []
+      for (let i = conversationHistory.length - 1; i >= 0 && chats.length < n; i--) {
+        const msg = conversationHistory[i]
+        if (msg.role !== 'user' || typeof msg.content !== 'string')
+          continue
+
+        const match = msg.content.match(/\[EVENT\]\s*([^:\n]+:[^\n]+)/)
+        if (match?.[1] && !match[1].startsWith('Perception Signal:'))
+          chats.unshift(match[1])
+      }
+      return chats
+    },
+    count: () => conversationHistory.length,
+    currentTurn: () => currentTurnId,
+  }
+}
+
+function __plannerExpectationDetail(message, fallback) {
+  if (typeof message === 'string' && message.trim().length > 0)
+    return message
+  return fallback
+}
+`
+
 export interface RuntimeGlobals {
   event: BotEvent
   snapshot: Record<string, unknown>
@@ -77,8 +469,8 @@ export interface RuntimeGlobals {
   setNoActionBudget?: (value: number) => { ok: true, remaining: number, default: number, max: number }
   getNoActionBudget?: () => { remaining: number, default: number, max: number }
   forgetConversation?: () => { ok: true, cleared: string[] }
-  enterContext?: (label: string) => { ok: true, label: string, turnId: number }
-  exitContext?: (summary?: string) => { ok: true, summarized: string, messagesArchived: number }
+  notifyAiri?: (headline: string, note?: string, urgency?: 'immediate' | 'soon' | 'later') => void
+  updateAiriContext?: (text: string, hints?: string[], lane?: string) => void
   history?: unknown
   llmInput?: {
     systemPrompt: string
@@ -107,6 +499,38 @@ interface DescribeGlobalsOptions {
   includeBuiltins?: boolean
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function deepFreeze<T>(value: T): T {
+  if (!value || typeof value !== 'object')
+    return value
+
+  for (const key of Object.keys(value as Record<string, unknown>)) {
+    const child = (value as Record<string, unknown>)[key]
+    deepFreeze(child)
+  }
+
+  return Object.freeze(value)
+}
+
+function cloneStructured<T>(value: T): T {
+  if (typeof value === 'undefined')
+    return value
+
+  try {
+    return structuredClone(value)
+  }
+  catch {
+    return JSON.parse(JSON.stringify(value)) as T
+  }
+}
+
+function copyForIsolate<T>(value: T): T {
+  return deepFreeze(cloneStructured(value))
+}
+
 export function extractJavaScriptCandidate(input: string): string {
   const trimmed = input.trim()
   // eslint-disable-next-line regexp/no-super-linear-backtracking
@@ -118,18 +542,22 @@ export function extractJavaScriptCandidate(input: string): string {
 }
 
 export class JavaScriptPlanner {
-  private readonly context: vm.Context
   private activeRun: ActivePlannerRun | null = null
+  private readonly bridgeTimeoutMs: number
   private readonly maxActionsPerTurn: number
-  private readonly sandbox: Record<string, unknown>
+  private readonly maxBridgeCalls: number
+  private persistedLastAction: ActionRuntimeResult | null = null
+  private persistedLastRun: { actions: ActionRuntimeResult[], logs: string[], returnRaw?: unknown } | null = null
+  private persistedMem: Record<string, unknown> = {}
   private readonly timeoutMs: number
+  private readonly memoryLimitMb: number
 
   constructor(options: JavaScriptPlannerOptions = {}) {
+    this.bridgeTimeoutMs = options.bridgeTimeoutMs ?? 30_000
+    this.maxBridgeCalls = options.maxBridgeCalls ?? 64
     this.timeoutMs = options.timeoutMs ?? 750
     this.maxActionsPerTurn = options.maxActionsPerTurn ?? 5
-    this.sandbox = {}
-    this.context = vm.createContext(this.sandbox)
-    this.installBuiltins()
+    this.memoryLimitMb = options.memoryLimitMb ?? 32
   }
 
   public async evaluate(
@@ -149,44 +577,167 @@ export class JavaScriptPlanner {
     }
 
     this.activeRun = run
-    this.installActionTools(availableActions)
-    this.bindRuntimeGlobals(globals, run)
+    let result: unknown
+    let state: SandboxWorkerState = { logs: [], mem: this.persistedMem }
 
     try {
-      const wrapped = `(async () => {\n${script}\n})()`
-      const result = await new vm.Script(wrapped).runInContext(this.context, { timeout: this.timeoutMs })
-
-      const returnValue = typeof result === 'undefined'
-        ? undefined
-        : inspect(result, {
-            depth: null,
-            breakLength: 100,
-            maxArrayLength: 100,
-            maxStringLength: 10_000,
-          })
-
-      if (isRecord(this.sandbox.lastRun)) {
-        this.sandbox.lastRun.returnRaw = result
-      }
+      const workerResult = await executeSandboxWorker(
+        this.buildSandboxWorkerRequest(script, availableActions, globals),
+        {
+          bridgeTimeoutMs: this.bridgeTimeoutMs,
+          maxBridgeCalls: this.maxBridgeCalls,
+          onBridgeRequest: (method, args) => this.handleBridgeRequest(method, args, globals),
+        },
+      )
+      state = { logs: workerResult.logs, mem: workerResult.mem }
+      result = workerResult.returnRaw
+      run.logs = workerResult.logs
 
       return {
         actions: run.executed,
-        logs: run.logs,
-        returnValue,
+        logs: workerResult.logs,
+        returnValue: typeof result === 'undefined'
+          ? undefined
+          : inspect(result, {
+              depth: null,
+              breakLength: 100,
+              maxArrayLength: 100,
+              maxStringLength: 10_000,
+            }),
       }
     }
+    catch (error) {
+      if (isRecord(error) && 'state' in error && isRecord(error.state)) {
+        const errorState = error.state as Partial<SandboxWorkerState>
+        state = {
+          logs: Array.isArray(errorState.logs) ? cloneStructured(errorState.logs) : [],
+          mem: isRecord(errorState.mem) ? cloneStructured(errorState.mem) : {},
+        }
+        run.logs = state.logs
+      }
+      throw error
+    }
     finally {
+      this.persistedMem = cloneStructured(state.mem)
+      this.persistedLastRun = {
+        actions: cloneStructured(run.executed),
+        logs: cloneStructured(state.logs),
+        returnRaw: typeof result === 'undefined' ? undefined : cloneStructured(result),
+      }
+      this.persistedLastAction = run.executed.at(-1)
+        ? cloneStructured(run.executed.at(-1) as ActionRuntimeResult)
+        : null
       this.activeRun = null
     }
   }
 
+  private buildSandboxWorkerRequest(
+    script: string,
+    availableActions: Action[],
+    globals: RuntimeGlobals,
+  ): SandboxWorkerRequest {
+    return {
+      bootstrapScript: this.buildBootstrapScript(),
+      bridgeAvailability: {
+        forgetConversation: Boolean(globals.forgetConversation),
+        getNoActionBudget: Boolean(globals.getNoActionBudget),
+        notifyAiri: Boolean(globals.notifyAiri),
+        patternFind: Boolean(globals.patterns?.find),
+        patternGet: Boolean(globals.patterns?.get),
+        patternIds: Boolean(globals.patterns?.ids),
+        patternList: Boolean(globals.patterns?.list),
+        queryBlockAt: Boolean(globals.mineflayer),
+        queryMap: Boolean(globals.mineflayer),
+        setNoActionBudget: Boolean(globals.setNoActionBudget),
+        updateAiriContext: Boolean(globals.updateAiriContext),
+      },
+      memoryLimitMb: this.memoryLimitMb,
+      runtime: this.buildRuntimeSnapshot(globals),
+      script,
+      timeoutMs: this.timeoutMs,
+      toolNames: availableActions.map(action => action.name),
+    }
+  }
+
+  private async handleBridgeRequest(method: string, args: unknown[], globals: RuntimeGlobals): Promise<unknown> {
+    switch (method) {
+      case 'tool': {
+        const [tool, toolArgs] = args
+        if (typeof tool !== 'string' || !Array.isArray(toolArgs))
+          throw new Error('Sandbox tool bridge received invalid arguments')
+        return await this.runActionFromSandbox(tool, toolArgs)
+      }
+
+      case 'query.blockAt': {
+        if (!globals.mineflayer)
+          return null
+        const [position] = args
+        return cloneStructured(createQueryRuntime(globals.mineflayer).blockAt(position as { x: number, y: number, z: number }))
+      }
+
+      case 'query.map': {
+        if (!globals.mineflayer)
+          return null
+        const [options] = args
+        return cloneStructured(createQueryRuntime(globals.mineflayer).map(options as {
+          radius?: number
+          showElevation?: boolean
+          showEntities?: boolean
+          view?: 'top-down' | 'cross-section'
+          yLevel?: number
+        }))
+      }
+
+      case 'patterns.get':
+        return cloneStructured(globals.patterns?.get?.(args[0] as string) ?? null)
+
+      case 'patterns.find':
+        return cloneStructured(globals.patterns?.find?.(args[0] as string, args[1] as number | undefined) ?? [])
+
+      case 'patterns.ids':
+        return cloneStructured(globals.patterns?.ids?.() ?? [])
+
+      case 'patterns.list':
+        return cloneStructured(globals.patterns?.list?.(args[0] as number | undefined) ?? [])
+
+      case 'setNoActionBudget':
+        return cloneStructured(globals.setNoActionBudget?.(args[0] as number) ?? null)
+
+      case 'getNoActionBudget':
+        return cloneStructured(globals.getNoActionBudget?.() ?? null)
+
+      case 'forgetConversation':
+        return cloneStructured(globals.forgetConversation?.() ?? null)
+
+      case 'notifyAiri':
+        return cloneStructured(globals.notifyAiri?.(
+          args[0] as string,
+          args[1] as string | undefined,
+          args[2] as 'immediate' | 'soon' | 'later' | undefined,
+        ) ?? null)
+
+      case 'updateAiriContext':
+        return cloneStructured(globals.updateAiriContext?.(
+          args[0] as string,
+          args[1] as string[] | undefined,
+          args[2] as string | undefined,
+        ) ?? null)
+
+      default:
+        throw new Error(`Unknown sandbox bridge method: ${method}`)
+    }
+  }
+
   public canEvaluateAsExpression(content: string): boolean {
     const script = extractJavaScriptCandidate(content)
     if (!script.trim())
       return false
 
     try {
-      void new vm.Script(`(async () => (\n${script}\n))()`)
+      // NOTICE: This parse-only check stays in the host runtime and never executes
+      // untrusted code. It only decides whether REPL input can be wrapped as an expression.
+      // eslint-disable-next-line no-new-func
+      void new Function(`return (async () => (\n${script}\n))()`)
       return true
     }
     catch {
@@ -200,8 +751,8 @@ export class JavaScriptPlanner {
     options: DescribeGlobalsOptions = {},
   ): PlannerGlobalDescriptor[] {
     const descriptors: PlannerGlobalDescriptor[] = []
-
     const includeBuiltins = options.includeBuiltins ?? true
+    const runtime = this.buildRuntimeSnapshot(globals)
 
     const staticGlobals: Array<Omit<PlannerGlobalDescriptor, 'preview'>> = [
       { name: 'skip', kind: 'tool', readonly: true },
@@ -228,8 +779,6 @@ export class JavaScriptPlanner {
       { name: 'setNoActionBudget', kind: 'function', readonly: true },
       { name: 'getNoActionBudget', kind: 'function', readonly: true },
       { name: 'forget_conversation', kind: 'function', readonly: true },
-      { name: 'enterContext', kind: 'function', readonly: true },
-      { name: 'exitContext', kind: 'function', readonly: true },
       { name: 'history', kind: 'object', readonly: true },
       { name: 'llmMessages', kind: 'object', readonly: true },
       { name: 'llmSystemPrompt', kind: 'string', readonly: true },
@@ -250,52 +799,73 @@ export class JavaScriptPlanner {
       { name: 'lastRun', kind: 'object', readonly: true },
       { name: 'prevRun', kind: 'object', readonly: true },
       { name: 'lastAction', kind: 'object', readonly: true },
+      { name: 'notifyAiri', kind: 'function', readonly: true },
+      { name: 'updateAiriContext', kind: 'function', readonly: true },
     ]
 
     const valueByName: Record<string, unknown> = {
-      'snapshot': globals.snapshot,
-      'event': globals.event,
+      'snapshot': runtime.snapshot,
+      'event': runtime.event,
       'now': Date.now(),
-      'self': (globals.snapshot as Record<string, unknown>)?.self,
-      'environment': (globals.snapshot as Record<string, unknown>)?.environment,
-      'social': (globals.snapshot as Record<string, unknown>)?.social,
-      'threat': (globals.snapshot as Record<string, unknown>)?.threat,
-      'attention': (globals.snapshot as Record<string, unknown>)?.attention,
-      'autonomy': (globals.snapshot as Record<string, unknown>)?.autonomy,
-      'llmInput': globals.llmInput ?? null,
-      'currentInput': globals.currentInput ?? null,
-      'llmLog': globals.llmLog ?? null,
-      'actionQueue': globals.actionQueue ?? null,
-      'noActionBudget': globals.noActionBudget ?? null,
-      'errorBurstGuard': globals.errorBurstGuard ?? null,
-      'llmMessages': globals.llmInput?.messages ?? [],
-      'llmSystemPrompt': globals.llmInput?.systemPrompt ?? '',
-      'llmUserMessage': globals.llmInput?.userMessage ?? '',
-      'llmConversationHistory': globals.llmInput?.conversationHistory ?? [],
-      'query': globals.mineflayer ? createQueryRuntime(globals.mineflayer) : undefined,
-      'patterns': globals.patterns ?? null,
+      'self': runtime.snapshot.self,
+      'environment': runtime.snapshot.environment,
+      'social': runtime.snapshot.social,
+      'threat': runtime.snapshot.threat,
+      'attention': runtime.snapshot.attention,
+      'autonomy': runtime.snapshot.autonomy,
+      'llmInput': runtime.llmInput,
+      'currentInput': runtime.currentInput,
+      'llmLog': runtime.llmLogEntries.length > 0 ? { entries: runtime.llmLogEntries } : { entries: [] },
+      'actionQueue': runtime.actionQueue,
+      'noActionBudget': runtime.noActionBudget,
+      'errorBurstGuard': runtime.errorBurstGuard,
+      'llmMessages': runtime.llmInput?.messages ?? [],
+      'llmSystemPrompt': runtime.llmInput?.systemPrompt ?? '',
+      'llmUserMessage': runtime.llmInput?.userMessage ?? '',
+      'llmConversationHistory': runtime.llmInput?.conversationHistory ?? [],
+      'query': runtime.querySeed
+        ? {
+            self: '[Function self]',
+            snapshot: '[Function snapshot]',
+            gaze: '[Function gaze]',
+            blocks: '[Function blocks]',
+            entities: '[Function entities]',
+            inventory: '[Function inventory]',
+            craftable: '[Function craftable]',
+            blockAt: '[Function blockAt]',
+            map: '[Function map]',
+          }
+        : undefined,
+      'patterns': globals.patterns ? { get: '[Function]', find: '[Function]', ids: '[Function]', list: '[Function]' } : null,
       'patterns.get': globals.patterns?.get,
       'patterns.find': globals.patterns?.find,
       'patterns.ids': globals.patterns?.ids,
       'patterns.list': globals.patterns?.list,
-      'bot': globals.bot ?? globals.mineflayer?.bot,
-      'mineflayer': globals.mineflayer ?? null,
-      'mem': this.sandbox.mem,
-      'lastRun': this.sandbox.lastRun,
-      'prevRun': this.sandbox.prevRun,
-      'lastAction': this.sandbox.lastAction,
-      'skip': this.sandbox.skip,
-      'use': this.sandbox.use,
-      'log': this.sandbox.log,
-      'expect': this.sandbox.expect,
-      'expectMoved': this.sandbox.expectMoved,
-      'expectNear': this.sandbox.expectNear,
-      'setNoActionBudget': this.sandbox.setNoActionBudget,
-      'getNoActionBudget': this.sandbox.getNoActionBudget,
-      'forget_conversation': this.sandbox.forget_conversation,
-      'enterContext': this.sandbox.enterContext,
-      'exitContext': this.sandbox.exitContext,
-      'history': this.sandbox.history,
+      'history': {
+        recent: '[Function recent]',
+        search: '[Function search]',
+        turns: '[Function turns]',
+        playerChats: '[Function playerChats]',
+        count: '[Function count]',
+        currentTurn: '[Function currentTurn]',
+      },
+      'bot': null,
+      'mineflayer': null,
+      'mem': this.persistedMem,
+      'lastRun': this.persistedLastRun,
+      'prevRun': this.persistedLastRun,
+      'lastAction': this.persistedLastAction,
+      'notifyAiri': globals.notifyAiri ?? null,
+      'updateAiriContext': globals.updateAiriContext ?? null,
+      'skip': '[Function skip]',
+      'use': '[Function use]',
+      'log': '[Function log]',
+      'expect': '[Function expect]',
+      'expectMoved': '[Function expectMoved]',
+      'expectNear': '[Function expectNear]',
+      'setNoActionBudget': globals.setNoActionBudget ?? null,
+      'getNoActionBudget': globals.getNoActionBudget ?? null,
+      'forget_conversation': globals.forgetConversation ?? null,
     }
 
     if (includeBuiltins) {
@@ -320,169 +890,286 @@ export class JavaScriptPlanner {
     return descriptors
   }
 
-  private installBuiltins(): void {
-    this.defineGlobalTool('skip', async () => this.runAction('skip', {}))
-    this.defineGlobalTool('use', (toolName: unknown, params?: unknown) => {
-      if (typeof toolName !== 'string' || toolName.length === 0) {
-        throw new Error('use(toolName, params) requires a non-empty string toolName')
-      }
+  private buildRuntimeSnapshot(globals: RuntimeGlobals): RuntimeSnapshot {
+    const llmLogEntries = this.buildLlmLogSeed(globals.llmLog)
+    const llmInput = copyForIsolate(globals.llmInput ?? null)
 
-      const mappedParams = isRecord(params) ? params : {}
-      return this.runAction(toolName, mappedParams)
-    })
-    this.defineGlobalTool('log', (...args: unknown[]) => {
-      if (!this.activeRun)
-        throw new Error('log() is only allowed during REPL evaluation')
-
-      const rendered = args.map(arg => inspect(arg, { depth: 4, breakLength: 120 })).join(' ')
-      this.activeRun.logs.push(rendered)
-      return rendered
-    })
-    this.defineGlobalTool('expect', (condition: unknown, message?: unknown) => {
-      if (condition)
-        return true
-
-      const detail = typeof message === 'string' && message.trim().length > 0
-        ? message
-        : 'Condition evaluated to false'
-      throw new Error(`Expectation failed: ${detail}`)
-    })
-    this.defineGlobalTool('expectMoved', (minBlocks?: unknown, message?: unknown) => {
-      const threshold = typeof minBlocks === 'number' ? minBlocks : 0.5
-      const telemetry = this.getLastActionResultRecord()
-      const movedDistance = typeof telemetry?.movedDistance === 'number'
-        ? telemetry.movedDistance
-        : null
-
-      if (movedDistance === null) {
-        throw new Error('Expectation failed: expectMoved() requires last action result with movedDistance telemetry')
-      }
-
-      if (movedDistance >= threshold)
-        return true
-
-      const detail = typeof message === 'string' && message.trim().length > 0
-        ? message
-        : `Expected movedDistance >= ${threshold}, got ${movedDistance}`
-      throw new Error(`Expectation failed: ${detail}`)
-    })
-    this.defineGlobalTool('expectNear', (targetOrMaxDist?: unknown, maxDistOrMessage?: unknown, maybeMessage?: unknown) => {
-      const telemetry = this.getLastActionResultRecord()
-
-      let target: { x: number, y: number, z: number } | null = null
-      let maxDist = 2
-      let message: string | undefined
-
-      if (isCoord(targetOrMaxDist)) {
-        target = { x: targetOrMaxDist.x, y: targetOrMaxDist.y, z: targetOrMaxDist.z }
-        if (typeof maxDistOrMessage === 'number')
-          maxDist = maxDistOrMessage
-        if (typeof maybeMessage === 'string')
-          message = maybeMessage
-      }
-      else {
-        if (typeof targetOrMaxDist === 'number')
-          maxDist = targetOrMaxDist
-        if (typeof maxDistOrMessage === 'string')
-          message = maxDistOrMessage
-      }
-
-      let distance: number | null = null
-      if (target) {
-        const endPos = isCoord(telemetry?.endPos) ? telemetry.endPos : null
-        if (!endPos) {
-          throw new Error('Expectation failed: expectNear(target) requires last action result with endPos telemetry')
-        }
-
-        const dx = endPos.x - target.x
-        const dy = endPos.y - target.y
-        const dz = endPos.z - target.z
-        distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
-      }
-      else if (typeof telemetry?.distanceToTargetAfter === 'number') {
-        distance = telemetry.distanceToTargetAfter
-      }
-
-      if (distance === null) {
-        throw new Error('Expectation failed: expectNear() requires target argument or last action distanceToTargetAfter telemetry')
-      }
-
-      if (distance <= maxDist)
-        return true
-
-      const detail = message ?? `Expected distance <= ${maxDist}, got ${distance}`
-      throw new Error(`Expectation failed: ${detail}`)
-    })
-    this.defineGlobalValue('mem', {})
+    return {
+      actionQueue: copyForIsolate(globals.actionQueue ?? null),
+      currentInput: copyForIsolate(globals.currentInput ?? null),
+      errorBurstGuard: copyForIsolate(globals.errorBurstGuard ?? null),
+      event: copyForIsolate(globals.event),
+      historySeed: {
+        conversationHistory: this.buildConversationHistorySeed(llmInput?.conversationHistory),
+        currentTurn: this.readCurrentTurn(globals.history),
+        llmLogEntries,
+      },
+      lastAction: copyForIsolate(this.persistedLastAction),
+      llmInput,
+      llmLogEntries,
+      mem: copyForIsolate(this.persistedMem),
+      noActionBudget: copyForIsolate(globals.noActionBudget ?? null),
+      prevRun: copyForIsolate(this.persistedLastRun),
+      querySeed: this.buildQuerySeedSafely(globals.mineflayer ?? null),
+      snapshot: copyForIsolate(globals.snapshot),
+    }
   }
 
-  private getLastActionResultRecord(): Record<string, unknown> | null {
-    const lastAction = this.sandbox.lastAction
-    if (!isRecord(lastAction))
+  private buildConversationHistorySeed(messages: unknown): Array<{ role: string, content: string }> {
+    if (!Array.isArray(messages))
+      return []
+
+    return copyForIsolate(messages.map((message) => {
+      const role = isRecord(message) && typeof message.role === 'string' ? message.role : 'unknown'
+      const content = isRecord(message) && 'content' in message
+        ? typeof message.content === 'string'
+          ? message.content
+          : String(message.content)
+        : ''
+
+      return { role, content }
+    }))
+  }
+
+  private buildLlmLogSeed(llmLog: unknown): Array<Record<string, unknown>> {
+    if (!llmLog || typeof llmLog !== 'object')
+      return []
+
+    const entries = (llmLog as { entries?: unknown }).entries
+    if (!Array.isArray(entries))
+      return []
+
+    return copyForIsolate(
+      entries.filter(isRecord).map(entry => ({ ...entry })),
+    )
+  }
+
+  private readCurrentTurn(history: unknown): number {
+    if (!history || typeof history !== 'object')
+      return 0
+
+    const currentTurn = (history as { currentTurn?: unknown }).currentTurn
+    if (typeof currentTurn !== 'function')
+      return 0
+
+    try {
+      const value = currentTurn()
+      return typeof value === 'number' ? value : 0
+    }
+    catch {
+      return 0
+    }
+  }
+
+  private buildQuerySeedSafely(mineflayer: Mineflayer | null): QuerySeed | null {
+    if (!mineflayer)
       return null
 
-    const result = lastAction.result
-    return isRecord(result) ? result : null
-  }
-
-  private installActionTools(availableActions: Action[]): void {
-    for (const action of availableActions) {
-      const existing = Object.getOwnPropertyDescriptor(this.sandbox, action.name)
-      if (existing && existing.configurable === false)
-        continue
-
-      this.defineUpdatableGlobal(action.name, async (...args: unknown[]) => {
-        const params = this.mapArgsToParams(action, args)
-        return this.runAction(action.name, params)
-      })
+    try {
+      return this.buildQuerySeed(mineflayer)
+    }
+    catch {
+      return null
     }
   }
 
-  private bindRuntimeGlobals(globals: RuntimeGlobals, run: ActivePlannerRun): void {
-    const snapshot = deepFreeze(toStructuredClone(globals.snapshot))
-    const event = deepFreeze(toStructuredClone(globals.event))
-    const llmInput = deepFreeze(toStructuredClone(globals.llmInput ?? null))
-    const currentInput = deepFreeze(toStructuredClone(globals.currentInput ?? null))
-    const actionQueue = deepFreeze(toStructuredClone(globals.actionQueue ?? null))
-    const noActionBudget = deepFreeze(toStructuredClone(globals.noActionBudget ?? null))
-    const errorBurstGuard = deepFreeze(toStructuredClone(globals.errorBurstGuard ?? null))
-    const query = globals.mineflayer ? createQueryRuntime(globals.mineflayer) : undefined
+  private buildQuerySeed(mineflayer: Mineflayer): QuerySeed {
+    const query = createQueryRuntime(mineflayer)
+    return copyForIsolate({
+      self: query.self() as unknown as Record<string, unknown>,
+      blocks: query.blocks().within(64).limit(500).list() as unknown as Array<Record<string, unknown>>,
+      entities: query.entities().within(128).limit(500).list() as unknown as Array<Record<string, unknown>>,
+      inventory: query.inventory().list() as unknown as Array<Record<string, unknown>>,
+      craftable: query.craftable().uniq().list(),
+      gaze: query.gaze({ range: 32 }) as unknown[],
+    })
+  }
 
-    this.sandbox.prevRun = this.sandbox.lastRun ?? null
-    this.sandbox.snapshot = snapshot
-    this.sandbox.event = event
-    this.sandbox.now = Date.now()
-    this.sandbox.self = snapshot.self
-    this.sandbox.environment = snapshot.environment
-    this.sandbox.social = snapshot.social
-    this.sandbox.threat = snapshot.threat
-    this.sandbox.attention = snapshot.attention
-    this.sandbox.autonomy = snapshot.autonomy
-    this.sandbox.llmInput = llmInput
-    this.sandbox.currentInput = currentInput
-    this.sandbox.llmLog = globals.llmLog ?? null
-    this.sandbox.actionQueue = actionQueue
-    this.sandbox.noActionBudget = noActionBudget
-    this.sandbox.errorBurstGuard = errorBurstGuard
-    this.sandbox.setNoActionBudget = globals.setNoActionBudget ?? null
-    this.sandbox.getNoActionBudget = globals.getNoActionBudget ?? null
-    this.sandbox.forget_conversation = globals.forgetConversation ?? null
-    this.sandbox.enterContext = globals.enterContext ?? null
-    this.sandbox.exitContext = globals.exitContext ?? null
-    this.sandbox.history = globals.history ?? null
-    this.sandbox.llmMessages = llmInput?.messages ?? []
-    this.sandbox.llmSystemPrompt = llmInput?.systemPrompt ?? ''
-    this.sandbox.llmUserMessage = llmInput?.userMessage ?? ''
-    this.sandbox.llmConversationHistory = llmInput?.conversationHistory ?? []
-    this.sandbox.query = query
-    this.sandbox.patterns = globals.patterns ?? null
-    this.sandbox.bot = globals.bot ?? globals.mineflayer?.bot ?? null
-    this.sandbox.mineflayer = globals.mineflayer ?? null
-    this.sandbox.lastRun = {
-      actions: run.executed,
-      logs: run.logs,
-      returnRaw: undefined,
+  private buildBootstrapScript(): string {
+    return `;(() => {
+${QUERY_BOOTSTRAP}
+const __plannerBridgeRef = __plannerBridge
+const __plannerActionNames = __plannerBootstrapActionNames
+const __plannerAvailability = __plannerBridgeAvailability
+const __plannerLogRef = __plannerLog
+const __plannerReadBridgeValue = payload => {
+  const parsed = JSON.parse(payload)
+  return parsed?.isUndefined ? undefined : parsed?.value
+}
+const __plannerCallBridge = (method, args = []) =>
+  __plannerReadBridgeValue(__plannerBridgeRef.applySyncPromise(undefined, [method, args], {
+    arguments: { copy: true },
+  }))
+const __plannerQueryBlockAt = __plannerAvailability.queryBlockAt
+  ? position => __plannerCallBridge('query.blockAt', [position])
+  : null
+const __plannerQueryMap = __plannerAvailability.queryMap
+  ? options => __plannerCallBridge('query.map', [options])
+  : null
+const __plannerPatternsAvailable = __plannerAvailability.patternGet
+  || __plannerAvailability.patternFind
+  || __plannerAvailability.patternIds
+  || __plannerAvailability.patternList
+
+globalThis.llmLog = __plannerCreateLlmLogRuntime(globalThis.llmLogSeed)
+globalThis.history = __plannerCreateHistoryRuntime(globalThis.historySeed)
+globalThis.query = __plannerCreateQueryRuntime(globalThis.querySeed)
+globalThis.patterns = __plannerPatternsAvailable
+  ? {
+      get: id => __plannerCallBridge('patterns.get', [id]),
+      find: (query, limit = 10) => __plannerCallBridge('patterns.find', [query, limit]),
+      ids: () => __plannerCallBridge('patterns.ids', []),
+      list: (limit = 10) => __plannerCallBridge('patterns.list', [limit]),
     }
+  : null
+
+globalThis.log = (...args) => {
+  const rendered = __plannerLogRef(...args)
+  globalThis.lastRun.logs.push(rendered)
+  return rendered
+}
+
+globalThis.expect = (condition, message) => {
+  if (condition)
+    return true
+  throw new Error(
+    'Expectation failed: ' + __plannerExpectationDetail(message, 'Condition evaluated to false'),
+  )
+}
+
+globalThis.expectMoved = (minBlocks, message) => {
+  const threshold = typeof minBlocks === 'number' ? minBlocks : 0.5
+  const movedDistance = typeof globalThis.lastAction?.result?.movedDistance === 'number'
+    ? globalThis.lastAction.result.movedDistance
+    : null
+
+  if (movedDistance === null) {
+    throw new Error('Expectation failed: expectMoved() requires last action result with movedDistance telemetry')
+  }
+
+  if (movedDistance >= threshold)
+    return true
+
+  throw new Error(
+    'Expectation failed: ' + __plannerExpectationDetail(message, 'Expected movedDistance >= ' + threshold + ', got ' + movedDistance),
+  )
+}
+
+globalThis.expectNear = (targetOrMaxDist, maxDistOrMessage, maybeMessage) => {
+  let target = null
+  let maxDist = 2
+  let message
+
+  if (targetOrMaxDist && typeof targetOrMaxDist === 'object' && typeof targetOrMaxDist.x === 'number' && typeof targetOrMaxDist.y === 'number' && typeof targetOrMaxDist.z === 'number') {
+    target = { x: targetOrMaxDist.x, y: targetOrMaxDist.y, z: targetOrMaxDist.z }
+    if (typeof maxDistOrMessage === 'number')
+      maxDist = maxDistOrMessage
+    if (typeof maybeMessage === 'string')
+      message = maybeMessage
+  }
+  else {
+    if (typeof targetOrMaxDist === 'number')
+      maxDist = targetOrMaxDist
+    if (typeof maxDistOrMessage === 'string')
+      message = maxDistOrMessage
+  }
+
+  let distance = null
+  if (target) {
+    const endPos = globalThis.lastAction?.result?.endPos
+    if (!endPos || typeof endPos.x !== 'number' || typeof endPos.y !== 'number' || typeof endPos.z !== 'number') {
+      throw new Error('Expectation failed: expectNear(target) requires last action result with endPos telemetry')
+    }
+
+    const dx = endPos.x - target.x
+    const dy = endPos.y - target.y
+    const dz = endPos.z - target.z
+    distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
+  }
+  else if (typeof globalThis.lastAction?.result?.distanceToTargetAfter === 'number') {
+    distance = globalThis.lastAction.result.distanceToTargetAfter
+  }
+
+  if (distance === null) {
+    throw new Error('Expectation failed: expectNear() requires target argument or last action distanceToTargetAfter telemetry')
+  }
+
+  if (distance <= maxDist)
+    return true
+
+  throw new Error(
+    'Expectation failed: ' + __plannerExpectationDetail(message, 'Expected distance <= ' + maxDist + ', got ' + distance),
+  )
+}
+
+globalThis.use = (toolName, params = {}) => {
+  if (typeof toolName !== 'string' || toolName.length === 0)
+    throw new Error('use(toolName, params) requires a non-empty string toolName')
+
+  const invocationArgs = params && typeof params === 'object' && !Array.isArray(params) ? [params] : [{}]
+  const runtimeResult = __plannerCallBridge('tool', [toolName, invocationArgs])
+  globalThis.lastAction = runtimeResult
+  globalThis.lastRun.actions.push(runtimeResult)
+  return runtimeResult
+}
+
+globalThis.skip = () => globalThis.use('skip', {})
+
+for (const toolName of __plannerActionNames) {
+  if (toolName === 'skip')
+    continue
+
+  globalThis[toolName] = (...args) => {
+    const runtimeResult = __plannerCallBridge('tool', [toolName, args])
+    globalThis.lastAction = runtimeResult
+    globalThis.lastRun.actions.push(runtimeResult)
+    return runtimeResult
+  }
+}
+
+globalThis.setNoActionBudget = __plannerAvailability.setNoActionBudget
+  ? value => __plannerCallBridge('setNoActionBudget', [value])
+  : null
+globalThis.getNoActionBudget = __plannerAvailability.getNoActionBudget
+  ? () => __plannerCallBridge('getNoActionBudget', [])
+  : null
+globalThis.forget_conversation = __plannerAvailability.forgetConversation
+  ? () => __plannerCallBridge('forgetConversation', [])
+  : null
+globalThis.notifyAiri = __plannerAvailability.notifyAiri
+  ? (headline, note, urgency) => __plannerCallBridge('notifyAiri', [headline, note, urgency])
+  : null
+globalThis.updateAiriContext = __plannerAvailability.updateAiriContext
+  ? (text, hints, lane) => __plannerCallBridge('updateAiriContext', [text, hints, lane])
+  : null
+
+delete globalThis.querySeed
+delete globalThis.llmLogSeed
+delete globalThis.historySeed
+delete globalThis.__plannerBridge
+delete globalThis.__plannerBridgeAvailability
+delete globalThis.__plannerBootstrapActionNames
+delete globalThis.__plannerLog
+})()
+`
+  }
+
+  private mapToolArgs(tool: string, args: unknown[]): Record<string, unknown> {
+    if (!this.activeRun)
+      throw new Error('Tool calls are only allowed during REPL evaluation')
+
+    if (tool === 'skip')
+      return {}
+
+    const action = this.activeRun.actionsByName.get(tool)
+    if (!action)
+      throw new Error(`Unknown tool: ${tool}`)
+
+    return this.mapArgsToParams(action, args)
+  }
+
+  private async runActionFromSandbox(tool: string, args: unknown[]): Promise<ActionRuntimeResult> {
+    return this.runAction(tool, this.mapToolArgs(tool, args))
   }
 
   private mapArgsToParams(action: Action, args: unknown[]): Record<string, unknown> {
@@ -512,21 +1199,17 @@ export class JavaScriptPlanner {
   }
 
   private async runAction(tool: string, params: Record<string, unknown>): Promise<ActionRuntimeResult> {
-    if (!this.activeRun) {
+    if (!this.activeRun)
       throw new Error('Tool calls are only allowed during REPL evaluation')
-    }
 
-    if (this.activeRun.sawSkip && tool !== 'skip') {
+    if (this.activeRun.sawSkip && tool !== 'skip')
       throw new Error('skip() cannot be mixed with other tool calls in the same script')
-    }
 
-    if (this.activeRun.actionCount >= this.maxActionsPerTurn) {
+    if (this.activeRun.actionCount >= this.maxActionsPerTurn)
       throw new Error(`Action limit exceeded: max ${this.maxActionsPerTurn} actions per turn`)
-    }
 
-    if (tool === 'skip') {
+    if (tool === 'skip')
       this.activeRun.sawSkip = true
-    }
 
     this.activeRun.actionCount++
 
@@ -538,7 +1221,6 @@ export class JavaScriptPlanner {
         result: 'Skipped turn',
       }
       this.activeRun.executed.push(runtimeResult)
-      this.sandbox.lastAction = runtimeResult
       return runtimeResult
     }
 
@@ -550,9 +1232,9 @@ export class JavaScriptPlanner {
         error: validation.error ?? `Invalid tool parameters for ${tool}`,
       }
       this.activeRun.executed.push(runtimeResult)
-      this.sandbox.lastAction = runtimeResult
       return runtimeResult
     }
+
     const action = validation.action
 
     try {
@@ -563,17 +1245,15 @@ export class JavaScriptPlanner {
         result,
       }
       this.activeRun.executed.push(runtimeResult)
-      this.sandbox.lastAction = runtimeResult
       return runtimeResult
     }
     catch (error) {
       const runtimeResult: ActionRuntimeResult = {
         action,
         ok: false,
-        error: error instanceof Error ? error.message : String(error),
+        error: errorMessageFrom(error) ?? 'Unknown action error',
       }
       this.activeRun.executed.push(runtimeResult)
-      this.sandbox.lastAction = runtimeResult
       return runtimeResult
     }
   }
@@ -599,34 +1279,6 @@ export class JavaScriptPlanner {
     return { action: { tool, params: parsed.data } }
   }
 
-  private defineGlobalTool(name: string, fn: (...args: unknown[]) => unknown): void {
-    this.defineGlobalValue(name, fn)
-  }
-
-  private defineGlobalValue(name: string, value: unknown): void {
-    if (Object.hasOwn(this.sandbox, name))
-      return
-
-    Object.defineProperty(this.sandbox, name, {
-      value,
-      configurable: false,
-      enumerable: true,
-      writable: false,
-    })
-  }
-
-  // NOTICE: Action tools must be updatable because the set of available actions
-  // can change at runtime. Unlike builtins (which are immutable), action tool
-  // globals use configurable: true so they can be redefined on each evaluate().
-  private defineUpdatableGlobal(name: string, value: unknown): void {
-    Object.defineProperty(this.sandbox, name, {
-      value,
-      configurable: true,
-      enumerable: true,
-      writable: false,
-    })
-  }
-
   private previewValue(value: unknown): string {
     if (value === null)
       return 'null'
diff --git a/services/minecraft/src/cognitive/conscious/prompts/brain-prompt.md b/services/minecraft/src/cognitive/conscious/prompts/brain-prompt.md
index 4be320edb..d4911dae8 100644
--- a/services/minecraft/src/cognitive/conscious/prompts/brain-prompt.md
+++ b/services/minecraft/src/cognitive/conscious/prompts/brain-prompt.md
@@ -1,7 +1,7 @@
 # Role Definition
 You are an autonomous agent playing Minecraft.
 ## Self-Knowledge & Capabilities
-1. **Stateful Existence**: You maintain a memory of the conversation organized into **task contexts**. Completed task contexts are summarized and archived; only the active context messages appear in your conversation history.
+1. **Stateful Existence**: You maintain a memory of the conversation in ordinary chronological history. Recent turns remain available until conversation trimming removes the oldest entries.
 3. **Interruption**: The world is real-time. Events (chat, damage, etc.) may happen *while* you are performing an action.
    - If a new critical event occurs, you may need to change your plans.
    - Do not assume one feedback per tool call. For control actions, use `actionQueue` for live status.
@@ -19,11 +19,11 @@ You are an autonomous agent playing Minecraft.
    - Use `await` on tool calls when later logic depends on the result.
    - Globals refreshed every turn: `snapshot`, `self`, `environment`, `social`, `threat`, `attention`, `autonomy`, `event`, `now`, `query`, `patterns`, `bot`, `mineflayer`, `currentInput`, `llmLog`, `actionQueue`, `noActionBudget`, `errorBurstGuard`, `history`.
    - Persistent globals: `mem` (cross-turn memory), `lastRun` (this run), `prevRun` (previous run), `lastAction` (latest action result), `log(...)`.
-   - Context management: `enterContext(label)`, `exitContext(summary?)` — see **Context Management** section below.
-   - History query: `history.recent(n)`, `history.search(query)`, `history.playerChats(n)`, `history.turns(n)`, `history.contexts()`, `history.context(label)`.
+   - AIRI communication: `notifyAiri(headline, note?, urgency?)`, `updateAiriContext(text, hints?, lane?)` — see **AIRI Communication** section below.
+   - History query: `history.recent(n)`, `history.search(query)`, `history.playerChats(n)`, `history.turns(n)`.
    - Budget helpers: `setNoActionBudget(n)` and `getNoActionBudget()` control/inspect eval-only no-action follow-up budget.
    - Cross-turn result access: use `prevRun.returnRaw` for typed values (arrays/objects). If you need text output, stringify `returnRaw` explicitly.
-   - `forget_conversation()` clears all conversation memory (history, context archives, snapshots) for full reset.
+   - `forget_conversation()` clears all conversation memory and snapshots for full reset.
    - Last script outcome is also echoed in the next turn as `[SCRIPT]` context (return value, action stats, and logs).
    - Maximum tool calls per turn: 5.
    - Global control-action queue capacity: 5 total (`1 executing + 4 pending`).
@@ -197,73 +197,66 @@ Common patterns:
 - Pathfinding has an **ETA-based timeout** (2× estimated travel time + grace). The ETA accounts for digging, block placement, parkour, and walking speed.
 - If navigation fails with `reason: 'timeout'` or `reason: 'stagnation'`, try a closer intermediate waypoint, a different route, or `giveUp`.
 - If navigation fails with `reason: 'noPath'`, the destination is unreachable from the current position.
-## Context Management (Mandatory)
-You MUST use context boundaries to manage your conversation history. Without them, old messages accumulate and degrade your reasoning quality.
+## AIRI Communication
+You are connected to AIRI, an overseeing character. Two functions let you push information up to AIRI; they are fire-and-forget and never block your turn.
 
-**Rules:**
-1. When a player gives you a task (collect, craft, build, go somewhere, etc.), your FIRST line of code MUST be `enterContext('short task label')`.
-2. When a task is done, failed, or interrupted, call `exitContext('brief outcome summary')` in the SAME turn as the final action.
-3. For casual chat (greetings, questions, small talk) with NO multi-turn task, you do NOT need context boundaries.
-4. If a new task arrives while you are mid-task, call `exitContext('interrupted: <reason>')` THEN `enterContext('new task label')` in the same turn.
+### Receiving instructions from AIRI
+When `event.payload?.sourceId === 'airi'`, the instruction came from AIRI via a high-level command. Treat it as authoritative intent and begin executing it immediately. The instruction text is in `event.payload.description`.
 
-**What happens:**
-- `enterContext(label)`: marks the start of a task. All subsequent messages belong to this context.
-- `exitContext(summary)`: archives the current context's messages into a compact summary. They disappear from your conversation history and become a one-line entry in `[CONTEXT_HISTORY]`.
-- After `exitContext`, only the summary remains — you lose access to individual messages from that context.
+### `notifyAiri(headline, note?, urgency?)`
+Push an episodic alert to AIRI. Use for significant, non-routine events only.
 
-**exitContext summary guidelines:**
-- Include: what was requested, what you did, the outcome (success/failure/partial).
-- Keep it under 2 sentences.
-- Examples:
-  - `exitContext('Collected 5 oak logs for laggy_magpie and delivered them.')`
-  - `exitContext('Failed to craft iron pickaxe — no iron ingots available.')`
-  - `exitContext('Interrupted stone collection — player asked me to follow instead.')`
+**Call this for:**
+- Near-death or death (`self.health <= 4`)
+- A task is blocked and you cannot resolve it alone
+- A player interaction that AIRI should be aware of (e.g. a player is being hostile, or asks about AIRI directly)
+- A major discovery (found a dungeon, village, rare ore vein)
+- A long-running task just completed
 
-**Do NOT call exitContext:**
-- In the middle of a multi-turn task (you need the history to reason).
-- After a single trivial chat reply with no ongoing task.
+**Do NOT call this for:**
+- Routine progress steps (each block mined, each step of navigation)
+- Every chat message from every player
+- Anything that resolves within the same turn
 
-**Retrieving archived context (via `history` global):**
-- `history.contexts()` — list all archived context summaries.
-- `history.search('keyword')` — text search across all history (archived + active).
-- `history.recent(5)` — last 5 message pairs from the active context.
-- `history.playerChats(3)` — last 3 player chat messages.
-- `history.turns(10)` — last 10 turn summaries.
+`urgency` values: `'immediate'` (danger/blocking), `'soon'` (important, default), `'later'` (informational).
 
-**Safety limits:** Active context auto-trims at 30 messages; context summaries collapse at 10 entries. Use `exitContext` proactively to avoid these.
-
-**Example — task lifecycle:**
 ```js
-// Turn 1: Player says 'get me some stone'
-enterContext('collect stone for player')
-const inv = query.inventory().summary()
-inv
+// Example — low health
+if (self.health <= 4) {
+  notifyAiri('Under attack and low health', `Health: ${self.health}. Retreating.`, 'immediate')
+  await goToCoordinate({ x: mem.safeSpot.x, y: mem.safeSpot.y, z: mem.safeSpot.z, closeness: 2 })
+}
 
-// Turn 2: check for pickaxe, craft if needed...
-// Turn 3: collect stone...
-// Turn 4: deliver and close context
-await giveToPlayer({ player_name: 'Alex', item_name: 'stone', num: 4 })
-exitContext('Collected 4 stone for Alex. Crafted wooden pickaxe first.')
-await chat({ message: 'Here you go!', feedback: false })
+// Example — task blocked
+notifyAiri('Cannot complete task', 'Missing iron ingots, no iron ore nearby.', 'soon')
+await giveUp({ reason: 'no iron available' })
 ```
 
-**Example — task interrupted:**
+### `updateAiriContext(text, hints?, lane?)`
+Push a persistent context update to AIRI. Use to keep AIRI's shared understanding current without triggering a reaction.
+
+**Call this for:**
+- Task completion summary (what you did, outcome, inventory changes)
+- Durable discoveries (base location, resource cache, important coordinates)
+- World state summaries after significant work
+
+**Do NOT call this for:**
+- Mid-task incremental progress
+- Anything already covered by `notifyAiri`
+
+`hints` is an optional array of short keyword tags. `lane` defaults to `'game'`.
+
 ```js
-// Player says 'actually, follow me instead' while you were collecting stone
-exitContext('Interrupted stone collection — player changed request.')
-enterContext('follow player')
-await goToPlayer({ player_name: 'Alex', closeness: 2 })
-await followPlayer({ player_name: 'Alex', follow_dist: 2 })
-exitContext('Following Alex as requested.')
+// Example — after collecting resources
+updateAiriContext(
+  'Collected 32 iron ore. Stored in chest at (12, 64, -5). Iron vein is depleted.',
+  ['iron', 'chest', 'resources'],
+)
+
+// Example — after completing a build
+updateAiriContext('Built a small shelter at spawn (0, 65, 0). Has a bed and crafting table.', ['shelter', 'spawn'])
 ```
 
-**Example — task failed:**
-```js
-// After several failed attempts
-exitContext('Failed to find diamonds — searched 3 cave branches with no results.')
-await giveUp({ reason: 'No diamonds found after extensive search' })
-await chat({ message: 'I searched everywhere nearby but couldn\'t find any diamonds.', feedback: false })
-```
 ## Usage Convention (Important)
 - Plan with `mem.plan`, execute in small steps, and verify each step before continuing.
 - Prefer deterministic scripts: no random branching unless needed.
@@ -283,6 +276,7 @@ await chat({ message: 'I searched everywhere nearby but couldn\'t find any diamo
 - Some relocation actions (for example `goToCoordinate`) automatically detach auto-follow so exploration does not keep snapping back.
 ## Rules
 - **Native Reasoning**: You can think before outputting your action.
+- **AIRI Instructions**: When `event.payload?.sourceId === 'airi'`, this is a directive from the overseeing AIRI character. Treat it as high-priority intent and begin executing it immediately.
 - **Strict JavaScript Output**: Output ONLY executable JavaScript. Comments are possible but discouraged and will be ignored.
 - **Handling Feedback**: Treat `actionQueue` as the source of truth for in-flight control actions. `[FEEDBACK]` is for terminal summaries/failures, not guaranteed per action.
 - **Tool Choice**: For read/query tasks, use `query` first. For world mutations, use dedicated action tools. Use direct `bot` only when necessary.
diff --git a/services/minecraft/src/cognitive/conscious/repl-code-normalizer.ts b/services/minecraft/src/cognitive/conscious/repl-code-normalizer.ts
index 10859d6d2..1b80dc023 100644
--- a/services/minecraft/src/cognitive/conscious/repl-code-normalizer.ts
+++ b/services/minecraft/src/cognitive/conscious/repl-code-normalizer.ts
@@ -77,7 +77,7 @@ export function normalizeReplScript(code: string): string {
   const hasTopLevelReturn = sourceFile.statements.some(statement => ts.isReturnStatement(statement))
   if (!hasTopLevelReturn && sourceFile.statements.length > 0) {
     const lastStatement = sourceFile.statements.at(-1)
-    if (ts.isExpressionStatement(lastStatement)) {
+    if (lastStatement && ts.isExpressionStatement(lastStatement)) {
       const expressionText = getNodeText(sourceFile, lastStatement.expression)
       replacements.push({
         start: lastStatement.getStart(sourceFile, false),
diff --git a/services/minecraft/src/cognitive/container.ts b/services/minecraft/src/cognitive/container.ts
index 6c9b83fc3..22008d59c 100644
--- a/services/minecraft/src/cognitive/container.ts
+++ b/services/minecraft/src/cognitive/container.ts
@@ -1,11 +1,16 @@
 import type { Logg } from '@guiiai/logg'
+import type { Client } from '@proj-airi/server-sdk'
 
+import type { AiriBridge } from '../airi/airi-bridge'
+import type { MinecraftContextService } from '../airi/minecraft-context-service'
 import type { EventBus } from './event-bus'
 import type { RuleEngine } from './perception/rules'
 
 import { useLogg } from '@guiiai/logg'
-import { asClass, asFunction, createContainer, InjectionMode } from 'awilix'
+import { asClass, asFunction, asValue, createContainer, InjectionMode } from 'awilix'
 
+import { AiriBridge as AiriBridgeImpl } from '../airi/airi-bridge'
+import { MinecraftContextService as MinecraftContextServiceImpl } from '../airi/minecraft-context-service'
 import { config } from '../composables/config'
 import { TaskExecutor } from './action/task-executor'
 import { Brain } from './conscious/brain'
@@ -24,9 +29,12 @@ export interface ContainerServices {
   taskExecutor: TaskExecutor
   brain: Brain
   reflexManager: ReflexManager
+  airiClient: Client
+  airiBridge: AiriBridge
+  minecraftContextService: MinecraftContextService
 }
 
-export function createAgentContainer() {
+export function createAgentContainer(airiClient: Client) {
   const container = createContainer<ContainerServices>({
     injectionMode: InjectionMode.PROXY,
     strict: true,
@@ -34,6 +42,20 @@ export function createAgentContainer() {
 
   // Register services
   container.register({
+    airiClient: asValue(airiClient),
+
+    airiBridge: asFunction(({ eventBus }: { eventBus: EventBus }) =>
+      new AiriBridgeImpl(airiClient, eventBus),
+    ).singleton(),
+
+    minecraftContextService: asFunction(({ airiBridge }) =>
+      new MinecraftContextServiceImpl({
+        airiBridge,
+        serverHost: config.bot.host,
+        serverPort: config.bot.port,
+      }),
+    ).singleton(),
+
     // Create independent logger for each agent
     logger: asFunction(() => useLogg('agent').useGlobalConfig()).singleton(),
 
@@ -90,6 +112,8 @@ export function createAgentContainer() {
         reflexManager: c.resolve('reflexManager'),
         taskExecutor: c.resolve('taskExecutor'),
         logger: c.resolve('logger'),
+        airiBridge: c.resolve('airiBridge'),
+        minecraftContextService: c.resolve('minecraftContextService'),
       })),
 
     // Reflex Manager (Reactive Layer)
diff --git a/services/minecraft/src/cognitive/index.ts b/services/minecraft/src/cognitive/index.ts
index b4194ec6e..cbf4edeb2 100644
--- a/services/minecraft/src/cognitive/index.ts
+++ b/services/minecraft/src/cognitive/index.ts
@@ -13,20 +13,22 @@ export function CognitiveEngine(options: CognitiveEngineOptions): MineflayerPlug
   let mcpReplServer: McpReplServer | null = null
   let started = false
 
-  // Keep airiClient reference for future use
-  void options.airiClient
-
   return {
     async created(bot) {
       // Create container and get required services
-      container = createAgentContainer()
+      container = createAgentContainer(options.airiClient)
 
       const perceptionPipeline = container.resolve('perceptionPipeline')
       const brain = container.resolve('brain')
       const reflexManager = container.resolve('reflexManager')
       const taskExecutor = container.resolve('taskExecutor')
+      const airiBridge = container.resolve('airiBridge')
+      const minecraftContextService = container.resolve('minecraftContextService')
       const debugService = DebugService.getInstance()
 
+      airiBridge.init()
+      minecraftContextService.init()
+
       if (config.debug.mcp) {
         mcpReplServer = new McpReplServer(brain)
         mcpReplServer.start()
@@ -149,6 +151,12 @@ export function CognitiveEngine(options: CognitiveEngineOptions): MineflayerPlug
       }
 
       if (container) {
+        const minecraftContextService = container.resolve('minecraftContextService')
+        minecraftContextService.destroy()
+
+        const airiBridge = container.resolve('airiBridge')
+        airiBridge.destroy()
+
         const brain = container.resolve('brain')
         brain.destroy()
 
diff --git a/services/minecraft/src/cognitive/perception/rules/engine.ts b/services/minecraft/src/cognitive/perception/rules/engine.ts
index a7c713990..ad63dd7e9 100644
--- a/services/minecraft/src/cognitive/perception/rules/engine.ts
+++ b/services/minecraft/src/cognitive/perception/rules/engine.ts
@@ -227,18 +227,11 @@ export class RuleEngine {
       this.detectorDecisions.splice(0, this.detectorDecisions.length - MAX_DETECTOR_DECISIONS)
     }
 
-    if (snapshot.decision === 'ignored_out_of_order') {
-      this.deps.logger.withFields(snapshot).warn('RuleEngine: detector decision')
-      return
-    }
-
     // NOTICE: matched_not_fired is expected on high-frequency streams and would
     // dominate logs; keep it in snapshots/devtools and reserve default logs for fired.
     if (snapshot.decision === 'matched_not_fired') {
-      return
-    }
 
-    this.deps.logger.withFields(snapshot).log('RuleEngine: detector decision')
+    }
   }
 
   /**
diff --git a/services/minecraft/src/cognitive/perception/types/signals.ts b/services/minecraft/src/cognitive/perception/types/signals.ts
index 7e39b4d71..cef4564f7 100644
--- a/services/minecraft/src/cognitive/perception/types/signals.ts
+++ b/services/minecraft/src/cognitive/perception/types/signals.ts
@@ -6,6 +6,8 @@ export type PerceptionSignalType
     | 'social_gesture' // e.g. waving
     | 'social_presence'
     | 'system_message' // e.g. death messages, join/leave
+    | 'airi_command' // instruction from AIRI via spark:command
+    | 'airi_context' // context update from AIRI via context:update
 
 export interface PerceptionSignal {
   type: PerceptionSignalType
diff --git a/services/minecraft/src/composables/runtime-config.ts b/services/minecraft/src/composables/runtime-config.ts
new file mode 100644
index 000000000..b0b207847
--- /dev/null
+++ b/services/minecraft/src/composables/runtime-config.ts
@@ -0,0 +1,164 @@
+import type { Config } from './config'
+
+import path from 'node:path'
+import process from 'node:process'
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+
+import { z } from 'zod'
+
+const editableConfigSchema = z.object({
+  enabled: z.boolean(),
+  host: z.string().trim().min(1),
+  port: z.number().int().min(1).max(65535),
+  username: z.string().trim().min(1),
+})
+
+const savedConfigSchema = editableConfigSchema.partial().extend({
+  enabled: z.boolean().optional(),
+})
+
+export interface MinecraftEditableConfig {
+  enabled: boolean
+  host: string
+  port: number
+  username: string
+}
+
+export interface MinecraftRuntimeConfigSnapshot {
+  editableConfig: MinecraftEditableConfig
+  effectiveBotConfig: Config['bot']
+}
+
+function parseEnvFile(filepath: string): Record<string, string> {
+  if (!existsSync(filepath))
+    return {}
+
+  const raw = readFileSync(filepath, 'utf8')
+  return raw
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(line => line && !line.startsWith('#'))
+    .reduce<Record<string, string>>((acc, line) => {
+      const separatorIndex = line.indexOf('=')
+      if (separatorIndex < 0)
+        return acc
+
+      const key = line.slice(0, separatorIndex).trim()
+      const value = normalizeEnvValue(line.slice(separatorIndex + 1).trim())
+      if (key)
+        acc[key] = value
+
+      return acc
+    }, {})
+}
+
+function normalizeEnvValue(value: string) {
+  if (value.length >= 2) {
+    const first = value[0]
+    const last = value.at(-1)
+    if ((first === '\'' || first === '"') && first === last) {
+      return value.slice(1, -1)
+    }
+  }
+
+  return value
+}
+
+function readSavedConfig(filepath: string): Partial<MinecraftEditableConfig> {
+  if (!existsSync(filepath))
+    return {}
+
+  const parsed = JSON.parse(readFileSync(filepath, 'utf8'))
+  return savedConfigSchema.parse(parsed)
+}
+
+function normalizeOptionalString(value: string | undefined) {
+  if (value == null)
+    return undefined
+
+  return value === '' ? undefined : value
+}
+
+function resolveString(
+  key: string,
+  savedValue: string | undefined,
+  envValue: string | undefined,
+  localEnvValue: string | undefined,
+  fallback: string,
+) {
+  return normalizeOptionalString(localEnvValue)
+    ?? normalizeOptionalString(savedValue)
+    ?? normalizeOptionalString(envValue)
+    ?? normalizeOptionalString(process.env[key])
+    ?? fallback
+}
+
+function resolveNumber(
+  key: string,
+  savedValue: number | undefined,
+  envValue: string | undefined,
+  localEnvValue: string | undefined,
+  fallback: number,
+) {
+  const raw = localEnvValue ?? (savedValue != null ? String(savedValue) : undefined) ?? envValue ?? process.env[key]
+  const parsed = raw != null ? Number(raw) : fallback
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+function resolvePort(
+  key: string,
+  savedValue: number | undefined,
+  envValue: string | undefined,
+  localEnvValue: string | undefined,
+  fallback: number,
+) {
+  const resolved = resolveNumber(key, savedValue, envValue, localEnvValue, fallback)
+  return Number.isInteger(resolved) && resolved >= 1 && resolved <= 65535 ? resolved : fallback
+}
+
+export class MinecraftRuntimeConfigManager {
+  private readonly cwd: string
+  private readonly configFilePath: string
+
+  constructor(options: { cwd?: string, configFilePath?: string } = {}) {
+    this.cwd = options.cwd ?? process.cwd()
+    this.configFilePath = options.configFilePath ?? path.join(this.cwd, 'data', 'minecraft-config.json')
+  }
+
+  load(): MinecraftRuntimeConfigSnapshot {
+    const envConfig = parseEnvFile(path.join(this.cwd, '.env'))
+    const localEnvConfig = parseEnvFile(path.join(this.cwd, '.env.local'))
+    const savedConfig = readSavedConfig(this.configFilePath)
+
+    const editableConfig = editableConfigSchema.parse({
+      enabled: savedConfig.enabled ?? true,
+      host: resolveString('BOT_HOSTNAME', savedConfig.host, envConfig.BOT_HOSTNAME, undefined, 'localhost'),
+      port: resolvePort('BOT_PORT', savedConfig.port, envConfig.BOT_PORT, undefined, 25565),
+      username: resolveString('BOT_USERNAME', savedConfig.username, envConfig.BOT_USERNAME, undefined, 'airi-bot'),
+    })
+
+    return {
+      editableConfig,
+      effectiveBotConfig: {
+        host: resolveString('BOT_HOSTNAME', savedConfig.host, envConfig.BOT_HOSTNAME, localEnvConfig.BOT_HOSTNAME, 'localhost'),
+        port: resolvePort('BOT_PORT', savedConfig.port, envConfig.BOT_PORT, localEnvConfig.BOT_PORT, 25565),
+        username: resolveString('BOT_USERNAME', savedConfig.username, envConfig.BOT_USERNAME, localEnvConfig.BOT_USERNAME, 'airi-bot'),
+        version: resolveString('BOT_VERSION', undefined, envConfig.BOT_VERSION, localEnvConfig.BOT_VERSION, '1.20'),
+        auth: (normalizeOptionalString(localEnvConfig.BOT_AUTH)
+          ?? normalizeOptionalString(envConfig.BOT_AUTH)
+          ?? normalizeOptionalString(process.env.BOT_AUTH)) as Config['bot']['auth'] | undefined,
+        password: localEnvConfig.BOT_PASSWORD ?? envConfig.BOT_PASSWORD ?? process.env.BOT_PASSWORD ?? '',
+      },
+    }
+  }
+
+  save(config: MinecraftEditableConfig): MinecraftRuntimeConfigSnapshot {
+    const editableConfig = editableConfigSchema.parse(config)
+
+    mkdirSync(path.dirname(this.configFilePath), { recursive: true })
+    writeFileSync(this.configFilePath, JSON.stringify(editableConfig, null, 2))
+
+    return this.load()
+  }
+}
diff --git a/services/minecraft/src/debug/types.ts b/services/minecraft/src/debug/types.ts
index 56a6b5a3f..2355c69a5 100644
--- a/services/minecraft/src/debug/types.ts
+++ b/services/minecraft/src/debug/types.ts
@@ -98,16 +98,6 @@ export interface TraceBatchEvent {
   timestamp: number
 }
 
-/**
- * Archived context summary for the debug dashboard
- */
-export interface ContextBoundaryInfo {
-  label: string
-  summary: string
-  turns: number
-  archivedAt: number
-}
-
 /**
  * Live conversation state update from the brain
  */
@@ -115,18 +105,6 @@ export interface ConversationUpdateEvent {
   messages: Array<{ role: string, content: string, reasoning?: string }>
   isProcessing: boolean
   sessionBoundary?: boolean
-  /** Active context boundary state */
-  activeContext?: {
-    label: string | null
-    startTurnId: number
-    messageCount: number
-  }
-  /** Archived context summaries */
-  archivedContexts?: ContextBoundaryInfo[]
-  /** Index in messages where the active context starts */
-  activeContextStartIndex?: number
-  /** The [CONTEXT_HISTORY] prefix message content, if any */
-  contextHistoryMessage?: string | null
   timestamp: number
 }
 
diff --git a/services/minecraft/src/debug/web/app.js b/services/minecraft/src/debug/web/app.js
index dddeabfd0..65aff6714 100644
--- a/services/minecraft/src/debug/web/app.js
+++ b/services/minecraft/src/debug/web/app.js
@@ -599,7 +599,7 @@ function parseUserMessage(content) {
 class ConversationPanel {
   constructor(client) {
     this.client = client
-    this._mkSession = () => ({ messages: [], greyed: false, activeContext: null, archivedContexts: [], activeContextStartIndex: 0, contextHistoryMessage: null })
+    this._mkSession = () => ({ messages: [], greyed: false })
     this.sessions = [this._mkSession()]
     this.isProcessing = false
     this.autoScroll = true
@@ -651,10 +651,6 @@ class ConversationPanel {
       const cur = this.sessions.at(-1)
       if (cur) {
         cur.messages = data.messages || []
-        cur.activeContext = data.activeContext || null
-        cur.archivedContexts = data.archivedContexts || []
-        cur.activeContextStartIndex = data.activeContextStartIndex ?? 0
-        cur.contextHistoryMessage = data.contextHistoryMessage || null
       }
     }
     this.isProcessing = !!data.isProcessing
@@ -708,17 +704,12 @@ class ConversationPanel {
   // --- Session rendering ---
 
   renderSession(session) {
-    const { messages, activeContext, archivedContexts, contextHistoryMessage } = session
+    const { messages } = session
     if (!messages || messages.length === 0)
       return '<div class="empty-state">No messages yet</div>'
 
     const parts = []
 
-    // Context status bar
-    if (archivedContexts?.length > 0 || activeContext) {
-      parts.push(this.renderContextStatusBar(activeContext, archivedContexts, contextHistoryMessage))
-    }
-
     // Group messages into turns (user+assistant pairs)
     const turns = this.groupIntoTurns(messages)
     for (const turn of turns) {
@@ -758,7 +749,6 @@ class ConversationPanel {
     const n = this.turnCounter
     const userParsed = turn.user ? parseUserMessage(turn.user.content || '') : null
     const eventSection = userParsed?.sections.find(s => s.tag === 'EVENT' || s.tag === 'FEEDBACK')
-    const contextSection = userParsed?.sections.find(s => s.tag === 'CONTEXT')
 
     // Build a short summary for the turn header
     let summary = `Turn ${n}`
@@ -766,18 +756,6 @@ class ConversationPanel {
       summary = this.summarizeEvent(eventSection)
     }
 
-    // Detect context label from the [CONTEXT] section
-    let ctxBadge = ''
-    if (contextSection) {
-      const ctxMatch = contextSection.text.match(/active="([^"]+)"/)
-      if (ctxMatch) {
-        ctxBadge = `<span class="cv-ctx-badge cv-ctx-active">${escapeHtml(ctxMatch[1])}</span>`
-      }
-      else if (contextSection.text.includes('no active context')) {
-        ctxBadge = '<span class="cv-ctx-badge cv-ctx-none">no ctx</span>'
-      }
-    }
-
     const turnId = `cv-turn-${n}`
     const userHtml = turn.user ? this.renderParsedUserMessage(userParsed, n) : ''
     const assistantHtml = turn.assistant ? this.renderParsedAssistantMessage(turn.assistant, n) : ''
@@ -787,7 +765,6 @@ class ConversationPanel {
         <span class="cv-arrow">\u25B6</span>
         <span class="cv-turn-num">#${n}</span>
         <span class="cv-turn-summary">${escapeHtml(summary)}</span>
-        ${ctxBadge}
       </button>
       <div class="cv-turn-body" id="${turnId}">
         ${userHtml}
@@ -928,49 +905,6 @@ class ConversationPanel {
     return `<div class="cv-assistant">${parts.join('')}</div>`
   }
 
-  // --- Context status bar ---
-
-  renderContextStatusBar(activeContext, archivedContexts, contextHistoryMessage) {
-    const parts = []
-    // Active context indicator
-    if (activeContext?.label) {
-      parts.push(`<span class="cv-ctx-status-active"><span class="cv-ctx-dot"></span> ${escapeHtml(activeContext.label)} (${activeContext.messageCount} msgs)</span>`)
-    }
-    else {
-      parts.push('<span class="cv-ctx-status-idle"><span class="cv-ctx-dot cv-ctx-dot-idle"></span> No active context</span>')
-    }
-
-    // Archived count
-    if (archivedContexts?.length > 0) {
-      const archId = `cv-archived-${Math.random().toString(36).slice(2, 6)}`
-      const items = archivedContexts.map((ctx, i) => {
-        const time = new Date(ctx.archivedAt).toLocaleTimeString()
-        return `<div class="cv-arch-item">
-          <span class="cv-arch-idx">#${i + 1}</span>
-          <strong>${escapeHtml(ctx.label || 'unnamed')}</strong>
-          <span class="cv-arch-meta">${ctx.turns}t &middot; ${time}</span>
-          <div class="cv-arch-summary">${escapeHtml(ctx.summary)}</div>
-        </div>`
-      }).join('')
-      parts.push(`<button class="cv-ctx-arch-btn" data-toggle="${archId}">
-        <span class="cv-arrow">\u25B6</span> ${archivedContexts.length} archived
-      </button>`)
-      // Append the collapsible body after the status bar
-      parts.push(`<div class="cv-ctx-arch-body" id="${archId}">${items}</div>`)
-    }
-
-    // Context history prefix
-    if (contextHistoryMessage) {
-      const chId = `cv-ctxhist-${Math.random().toString(36).slice(2, 6)}`
-      parts.push(`<button class="cv-ctx-hist-btn" data-toggle="${chId}">
-        <span class="cv-arrow">\u25B6</span> prefix
-      </button>`)
-      parts.push(`<div class="cv-ctx-hist-body" id="${chId}"><pre class="cv-ctx-hist-content">${escapeHtml(contextHistoryMessage)}</pre></div>`)
-    }
-
-    return `<div class="cv-ctx-bar">${parts.join('')}</div>`
-  }
-
   // --- System message ---
 
   renderSystemMessage(msg) {
diff --git a/services/minecraft/src/main.ts b/services/minecraft/src/main.ts
index 66ac832a2..b7e716141 100644
--- a/services/minecraft/src/main.ts
+++ b/services/minecraft/src/main.ts
@@ -9,12 +9,14 @@ import { pathfinder as MineflayerPathfinder } from 'mineflayer-pathfinder'
 import { plugin as MineflayerPVP } from 'mineflayer-pvp'
 import { plugin as MineflayerTool } from 'mineflayer-tool'
 
+import { startAiriClientConnection } from './airi/start-background-client'
 import { CognitiveEngine } from './cognitive'
-import { initBot } from './composables/bot'
 import { config, initEnv } from './composables/config'
+import { MinecraftRuntimeConfigManager } from './composables/runtime-config'
 import { DebugService } from './debug'
 import { setupMineflayerViewer } from './debug/mineflayer-viewer'
-import { wrapPlugin } from './libs/mineflayer'
+import { Mineflayer, wrapPlugin } from './libs/mineflayer'
+import { MinecraftBotRuntime } from './minecraft-bot-runtime'
 import { initLogger, useLogger } from './utils/logger'
 
 // ...
@@ -22,9 +24,32 @@ import { initLogger, useLogger } from './utils/logger'
 async function main() {
   initLogger() // todo: save logs to file
   initEnv()
+  const logger = useLogger()
+
+  const runtimeConfigManager = new MinecraftRuntimeConfigManager()
+  const configManager = {
+    load: () => {
+      const snapshot = runtimeConfigManager.load()
+      config.bot = {
+        ...config.bot,
+        ...snapshot.effectiveBotConfig,
+      }
+      return snapshot
+    },
+    save: (editableConfig: Parameters<MinecraftRuntimeConfigManager['save']>[0]) => {
+      const snapshot = runtimeConfigManager.save(editableConfig)
+      config.bot = {
+        ...config.bot,
+        ...snapshot.effectiveBotConfig,
+      }
+      return snapshot
+    },
+  }
+
+  let runtimeSnapshot = configManager.load()
 
   if (config.debug.server || config.debug.viewer || config.debug.mcp) {
-    useLogger().warn(
+    logger.warn(
       [
         '==============================================================================',
         'SECURITY NOTICE:',
@@ -44,42 +69,122 @@ async function main() {
     DebugService.getInstance().start()
   }
 
-  const { bot } = await initBot({
-    botConfig: config.bot,
-    plugins: [
-      wrapPlugin(MineflayerArmorManager),
-      wrapPlugin(MineflayerAutoEat),
-      wrapPlugin(MineflayerCollectBlock),
-      wrapPlugin(MineflayerPathfinder),
-      wrapPlugin(MineflayerPVP),
-      wrapPlugin(MineflayerTool),
-    ],
-    reconnect: {
-      enabled: true,
-      maxRetries: 5,
-    },
-  })
-
-  if (config.debug.viewer) {
-    setupMineflayerViewer(bot, { port: 3007, firstPerson: true })
-  }
-
   // Connect airi server
+  let airiConnectionLifecycle: ReturnType<typeof startAiriClientConnection> | null = null
   const airiClient = new Client({
     name: config.airi.clientName,
     url: config.airi.wsBaseUrl,
+    possibleEvents: ['module:configure', 'module:announced', 'spark:command', 'context:update'],
+    autoConnect: false,
+    onError: error => airiConnectionLifecycle?.reportUnavailable(error),
+    onClose: () => airiConnectionLifecycle?.reportDisconnected(),
+  })
+  airiConnectionLifecycle = startAiriClientConnection(airiClient, {
+    logger,
+    url: config.airi.wsBaseUrl,
   })
 
-  // Load CognitiveEngine (LLM config is read from config internally)
-  await bot.loadPlugin(CognitiveEngine({ airiClient }))
+  let activeRuntime: MinecraftBotRuntime | null = null
+  let viewerInitialized = false
 
-  // Setup Tool Executor for Debug Dashboard
-  const { setupToolExecutor } = await import('./debug/tool-executor')
-  setupToolExecutor(bot)
+  async function createManagedBot(botConfig: typeof config.bot) {
+    const runtime = new MinecraftBotRuntime({
+      initialConfig: botConfig,
+      createBot: async (nextBotConfig) => {
+        config.bot = {
+          ...config.bot,
+          ...nextBotConfig,
+        }
+
+        const bot = await Mineflayer.asyncBuild({
+          botConfig: nextBotConfig,
+          plugins: [
+            wrapPlugin(MineflayerArmorManager),
+            wrapPlugin(MineflayerAutoEat),
+            wrapPlugin(MineflayerCollectBlock),
+            wrapPlugin(MineflayerPathfinder),
+            wrapPlugin(MineflayerPVP),
+            wrapPlugin(MineflayerTool),
+          ],
+          reconnect: {
+            enabled: true,
+            maxRetries: 5,
+          },
+        })
+
+        if (config.debug.viewer && !viewerInitialized) {
+          setupMineflayerViewer(bot, { port: 3007, firstPerson: true })
+          viewerInitialized = true
+        }
+
+        await bot.loadPlugin(CognitiveEngine({ airiClient }))
+
+        // Setup Tool Executor for Debug Dashboard
+        const { setupToolExecutor } = await import('./debug/tool-executor')
+        setupToolExecutor(bot)
+
+        return bot
+      },
+    })
+
+    await runtime.initialize()
+    activeRuntime = runtime
+
+    return runtime
+  }
+
+  async function ensureManagedBot() {
+    if (activeRuntime)
+      return
+
+    await createManagedBot(runtimeSnapshot.effectiveBotConfig)
+  }
+
+  async function applyConfiguredRuntime(nextConfig: unknown) {
+    runtimeSnapshot = configManager.save(nextConfig as Parameters<MinecraftRuntimeConfigManager['save']>[0])
+
+    if (!runtimeSnapshot.editableConfig.enabled) {
+      if (activeRuntime) {
+        await activeRuntime.stop()
+        activeRuntime = null
+      }
+      return
+    }
+
+    if (!activeRuntime) {
+      await ensureManagedBot()
+      return
+    }
+
+    await activeRuntime.updateBotConfig(runtimeSnapshot.effectiveBotConfig)
+  }
+
+  airiClient.onEvent('module:configure', async (event) => {
+    try {
+      await applyConfiguredRuntime(event.data.config)
+    }
+    catch {
+      // Keep failures local to the service process. Stage learns only from registry liveness
+      // and explicit bot-originated context pushes, not automated configure updates.
+    }
+  })
+
+  if (runtimeSnapshot.editableConfig.enabled) {
+    await ensureManagedBot()
+  }
 
   process.on('SIGINT', () => {
-    bot.stop()
-    exit(0)
+    Promise.resolve(activeRuntime?.stop())
+      .catch((err: Error) => {
+        logger.errorWithError('Failed to stop Minecraft runtime cleanly', err)
+      })
+      .finally(() => {
+        // TODO: Add an explicit AIRI-side deregistration path on shutdown instead of relying on
+        // websocket close / heartbeat expiry. Right now the Minecraft page can briefly sit in a
+        // stale state after the bot exits, which is annoying and easy to misread as still online.
+        airiClient.close()
+        exit(0)
+      })
   })
 }
 
diff --git a/services/minecraft/src/minecraft-bot-runtime.ts b/services/minecraft/src/minecraft-bot-runtime.ts
new file mode 100644
index 000000000..32cf7a1a8
--- /dev/null
+++ b/services/minecraft/src/minecraft-bot-runtime.ts
@@ -0,0 +1,85 @@
+import type { Config } from './composables/config'
+
+import EventEmitter from 'eventemitter3'
+
+interface BotLifecycleEvents {
+  'bot:connected': () => void
+  'bot:disconnected': (reason?: string) => void
+  'bot:error': (error: Error) => void
+}
+
+interface BotWithLifecycle {
+  bot: {
+    on: (event: 'spawn' | 'end' | 'error' | 'kicked', listener: (...args: any[]) => void) => void
+    off?: (event: 'spawn' | 'end' | 'error' | 'kicked', listener: (...args: any[]) => void) => void
+  }
+  stop: () => Promise<void>
+}
+
+export class MinecraftBotRuntime extends EventEmitter<BotLifecycleEvents> {
+  private bot: BotWithLifecycle | null = null
+  private currentConfig: Config['bot']
+
+  private readonly onSpawn = () => {
+    this.emit('bot:connected')
+  }
+
+  private readonly onEnd = (reason?: string) => {
+    this.emit('bot:disconnected', reason)
+  }
+
+  private readonly onError = (error: Error) => {
+    this.emit('bot:error', error)
+  }
+
+  constructor(private readonly deps: {
+    createBot: (config: Config['bot']) => Promise<BotWithLifecycle>
+    initialConfig: Config['bot']
+  }) {
+    super()
+    this.currentConfig = deps.initialConfig
+  }
+
+  async initialize() {
+    this.bot = await this.deps.createBot(this.currentConfig)
+    this.attachLifecycle(this.bot)
+  }
+
+  async updateBotConfig(config: Config['bot']) {
+    const previousBot = this.bot
+    if (previousBot) {
+      this.detachLifecycle(previousBot)
+      await previousBot.stop()
+    }
+
+    this.currentConfig = config
+    this.bot = await this.deps.createBot(this.currentConfig)
+    this.attachLifecycle(this.bot)
+  }
+
+  async stop() {
+    if (!this.bot)
+      return
+
+    const activeBot = this.bot
+    this.detachLifecycle(activeBot)
+    this.bot = null
+    await activeBot.stop()
+  }
+
+  private attachLifecycle(bot: BotWithLifecycle) {
+    const lifecycleSource = bot.bot
+    lifecycleSource.on('spawn', this.onSpawn)
+    lifecycleSource.on('end', this.onEnd)
+    lifecycleSource.on('kicked', this.onEnd)
+    lifecycleSource.on('error', this.onError)
+  }
+
+  private detachLifecycle(bot: BotWithLifecycle) {
+    const lifecycleSource = bot.bot
+    lifecycleSource.off?.('spawn', this.onSpawn)
+    lifecycleSource.off?.('end', this.onEnd)
+    lifecycleSource.off?.('kicked', this.onEnd)
+    lifecycleSource.off?.('error', this.onError)
+  }
+}