diff --git a/.env.example b/.env.example
index cadea20..00e569e 100644
--- a/.env.example
+++ b/.env.example
@@ -20,6 +20,13 @@ H5_PUBLIC_BASE_URL=http://127.0.0.1:5173
 # MEMIND_ANALYTICS_ID_SECRET=<local-only pseudonymization secret>
 # MEMIND_ANALYTICS_DOMAINS=127.0.0.1,localhost
 
+# Local Rybbit analytics (same-origin /rybbit proxy to rybbit.tkmind.cn).
+# Create a Rybbit Site for localhost / 127.0.0.1, then set its numeric site_id.
+# MEMIND_RYBBIT_ENABLED=true
+# MEMIND_RYBBIT_URL=https://rybbit.tkmind.cn
+# MEMIND_RYBBIT_SITE_ID=<numeric site id>
+# MEMIND_RYBBIT_ID_SECRET=<local-only pseudonymization secret>
+
 # 生产 H5 public base 当前临时切到 https://mm.tkmind.cn。
 # 后续公网 H5 不再依赖 105 转发链路；m.tkmind.cn 仅作为 legacy/rollback 记录处理。
 # H5_PUBLIC_BASE_URL=https://mm.tkmind.cn
@@ -49,6 +56,9 @@ H5_PUBLIC_BASE_URL=http://127.0.0.1:5173
 # MEMIND_AGENT_RUN_WORKER_BATCH_SIZE=1
 # MEMIND_AGENT_RUN_HEARTBEAT_MS=30000
 # MEMIND_AGENT_RUN_HEARTBEAT_STALE_MS=90000
+# MEMIND_AGENT_RUN_RECOVERY_INTERVAL_MS=30000
+# MEMIND_RUNTIME_BUILD_ID=<release-or-build-id>
+# MEMIND_AGENT_RUN_WORKER_ID=<optional-instance-id>
 # MEMIND_AGENT_RUN_WORKER_EXPECT_RUNNING=0
 
 # Runtime SLO 日报（默认每日 23:55 写 reports/runtime-slo）。
diff --git a/admin-bootstrap.mjs b/admin-bootstrap.mjs
index 4119660..5f6803e 100644
--- a/admin-bootstrap.mjs
+++ b/admin-bootstrap.mjs
@@ -19,6 +19,8 @@ import { createLlmProviderService } from './llm-providers.mjs';
 import { createAssetGatewayConfigService } from './asset-gateway.mjs';
 import { createImageMakeAdminConfigService } from './image-make-admin-config.mjs';
 import { createMemoryV2AdminConfigService } from './memory-v2-admin-config.mjs';
+import { createOrchestratorAdminConfigService } from './services/orchestrator/admin-config.mjs';
+import { createOrchestratorObservabilityService } from './services/orchestrator/observability.mjs';
 import { createSkillRuntimeAdminConfigService } from './skill-runtime-admin-config.mjs';
 import { createSystemDisclosurePolicyService } from './system-disclosure-policy.mjs';
 import { createAgentCodeRunAdminConfigService } from './agent-code-run-admin-config.mjs';
@@ -110,6 +112,12 @@ export async function createAdminServices(env = {}) {
   });
   await imageMakeAdminConfigService.ensureSchema();
   const memoryV2ConfigService = createMemoryV2AdminConfigService(pool);
+  const orchestratorConfigService = createOrchestratorAdminConfigService(pool);
+  await orchestratorConfigService.ensureSchema();
+  const orchestratorObservabilityService = createOrchestratorObservabilityService({
+    pool,
+    configService: orchestratorConfigService,
+  });
   const mindSearchConfigService = createMindSearchConfigService(pool);
   await mindSearchConfigService.ensureSchema();
   const skillRuntimeConfigService = createSkillRuntimeAdminConfigService(pool, { h5Root });
@@ -157,6 +165,8 @@ export async function createAdminServices(env = {}) {
     assetGatewayConfigService,
     imageMakeAdminConfigService,
     memoryV2ConfigService,
+    orchestratorConfigService,
+    orchestratorObservabilityService,
     mindSearchConfigService,
     skillRuntimeConfigService,
     systemDisclosurePolicyService,
diff --git a/admin-routes.mjs b/admin-routes.mjs
index f8f3489..42ceead 100644
--- a/admin-routes.mjs
+++ b/admin-routes.mjs
@@ -31,6 +31,8 @@ function plazaRouteError(res, req, error) {
  * @param {object} deps.userAuth
  * @param {object|null} deps.llmProviderService
  * @param {object|null} deps.memoryV2ConfigService
+ * @param {object|null} deps.orchestratorConfigService
+ * @param {object|null} deps.orchestratorObservabilityService
  * @param {object|null} deps.skillRuntimeConfigService
  * @param {object|null} deps.systemDisclosurePolicyService
  * @param {object|null} deps.agentCodeRunPolicyService
@@ -48,6 +50,8 @@ export function createAdminApi({
   assetGatewayConfigService,
   imageMakeAdminConfigService,
   memoryV2ConfigService,
+  orchestratorConfigService,
+  orchestratorObservabilityService,
   mindSearchConfigService,
   skillRuntimeConfigService,
   systemDisclosurePolicyService,
@@ -227,6 +231,72 @@ export function createAdminApi({
     return res.json(result);
   });
 
+  adminApi.get('/orchestrator/config', requireAdmin, async (_req, res) => {
+    if (!orchestratorConfigService?.getAdminConfig) {
+      return res.status(503).json({ message: 'Orchestrator 配置服务未启用' });
+    }
+    return res.json(await orchestratorConfigService.getAdminConfig());
+  });
+
+  const updateOrchestratorConfig = async (req, res) => {
+    if (!orchestratorConfigService?.updateAdminConfig) {
+      return res.status(503).json({ message: 'Orchestrator 配置服务未启用' });
+    }
+    const result = await orchestratorConfigService.updateAdminConfig(
+      req.body?.config ?? req.body ?? {},
+      { updatedBy: req.currentUser.id },
+    );
+    return res.json(result);
+  };
+
+  adminApi.put('/orchestrator/config', requireAdmin, updateOrchestratorConfig);
+  adminApi.patch('/orchestrator/config', requireAdmin, updateOrchestratorConfig);
+
+  adminApi.get('/orchestrator/runtime', requireAdmin, async (_req, res) => {
+    if (!orchestratorConfigService?.getRuntimeState) {
+      return res.status(503).json({ message: 'Orchestrator 配置服务未启用' });
+    }
+    return res.json(await orchestratorConfigService.getRuntimeState({ probe: true }));
+  });
+
+  adminApi.get('/orchestrator/shadow-runs', requireAdmin, async (req, res) => {
+    if (!orchestratorObservabilityService?.listShadowRuns) {
+      return res.status(503).json({ message: 'Orchestrator 观测服务未启用' });
+    }
+    return res.json(await orchestratorObservabilityService.listShadowRuns({
+      hours: req.query.hours,
+      limit: req.query.limit,
+      status: req.query.status,
+    }));
+  });
+
+  adminApi.get('/orchestrator/execution-plans', requireAdmin, async (req, res) => {
+    if (!orchestratorObservabilityService?.listExecutionPlans) {
+      return res.status(503).json({ message: 'Orchestrator Dry-run 观测服务未启用' });
+    }
+    return res.json(await orchestratorObservabilityService.listExecutionPlans({
+      hours: req.query.hours,
+      limit: req.query.limit,
+      selection: req.query.selection,
+    }));
+  });
+
+  adminApi.get('/orchestrator/canary-readiness', requireAdmin, async (_req, res) => {
+    if (!orchestratorObservabilityService?.getCanaryReadiness) {
+      return res.status(503).json({ message: 'Orchestrator 观测服务未启用' });
+    }
+    return res.json(await orchestratorObservabilityService.getCanaryReadiness());
+  });
+
+  adminApi.get('/orchestrator/shadow-runs/:runId', requireAdmin, async (req, res) => {
+    if (!orchestratorObservabilityService?.getShadowRun) {
+      return res.status(503).json({ message: 'Orchestrator 观测服务未启用' });
+    }
+    const result = await orchestratorObservabilityService.getShadowRun(req.params.runId);
+    if (!result) return res.status(404).json({ message: 'Shadow run 不存在' });
+    return res.json(result);
+  });
+
   adminApi.get('/skill-runtime/config', requireAdmin, async (_req, res) => {
     if (!skillRuntimeConfigService?.getAdminConfig) {
       return res.status(503).json({ message: 'Skill Runtime 配置服务未启用' });
diff --git a/admin-routes.test.mjs b/admin-routes.test.mjs
index 18c0b90..bd84f0f 100644
--- a/admin-routes.test.mjs
+++ b/admin-routes.test.mjs
@@ -90,6 +90,162 @@ test('admin memory-v2 config routes expose config and runtime state', async () =
   }
 });
 
+test('admin orchestrator routes expose a versioned plug-in control plane', async () => {
+  const updates = [];
+  const state = {
+    config: {
+      mode: 'off',
+      primaryEngine: 'langgraph',
+      fallbackEngine: 'native',
+      serviceUrl: '',
+      requestTimeoutMs: 5000,
+      rolloutPercent: 0,
+      userAllowlist: [],
+      workflowAllowlist: ['code-run-v1'],
+      fallbackToNative: true,
+      requireHealthy: true,
+    },
+    configVersion: 1,
+    runtime: { effective: false, reason: 'mode_off' },
+    engines: [{ id: 'native', configured: true }, { id: 'langgraph', configured: false }],
+  };
+  const router = createAdminApi({
+    jsonBody: express.json(),
+    getToken() {
+      return 'token-admin';
+    },
+    userAuth: {
+      async getMe() {
+        return { id: 'admin-1', role: 'admin' };
+      },
+    },
+    llmProviderService: null,
+    memoryV2ConfigService: null,
+    orchestratorConfigService: {
+      async getAdminConfig() {
+        return state;
+      },
+      async updateAdminConfig(config, context) {
+        updates.push({ config, context });
+        return { ...state, config: { ...state.config, ...config }, configVersion: 2 };
+      },
+      async getRuntimeState(options) {
+        assert.deepEqual(options, { probe: true });
+        return {
+          ...state,
+          source: 'admin-db',
+          serviceHealth: { ok: true, status: 'healthy' },
+        };
+      },
+    },
+    orchestratorObservabilityService: {
+      async listExecutionPlans(options) {
+        assert.deepEqual(options, {
+          hours: '24',
+          limit: '50',
+          selection: 'candidate',
+        });
+        return {
+          metrics: { decisions: 3, candidateSelections: 2 },
+          plans: [{ runId: 'run-plan-1', candidateEngine: 'langgraph' }],
+        };
+      },
+      async getCanaryReadiness() {
+        return {
+          ready: false,
+          recommendation: 'keep_shadow',
+          blockers: ['sample_volume'],
+          samples: { eligibleObservations: 1 },
+        };
+      },
+      async listShadowRuns(options) {
+        assert.deepEqual(options, { hours: '12', limit: '25', status: 'failed' });
+        return {
+          metrics: { observations: 1, successes: 0, failures: 1 },
+          runs: [{ runId: 'run-shadow-1', shadowStatus: 'failed' }],
+        };
+      },
+      async getShadowRun(runId) {
+        assert.equal(runId, 'run-shadow-1');
+        return {
+          native: { runId, status: 'succeeded' },
+          remote: { available: true, events: [{ type: 'workflow_validated' }] },
+        };
+      },
+    },
+    plazaPosts: null,
+    plazaOps: null,
+    wechatAdmin: null,
+    subscriptionService: null,
+  });
+
+  const server = await startTestServer(router);
+  try {
+    const configResponse = await fetch(`${server.baseUrl}/admin-api/orchestrator/config`, {
+      headers: { cookie: 'h5_user_session=token-admin' },
+    });
+    assert.equal(configResponse.status, 200);
+    assert.equal((await configResponse.json()).config.mode, 'off');
+
+    const updateResponse = await fetch(`${server.baseUrl}/admin-api/orchestrator/config`, {
+      method: 'PATCH',
+      headers: {
+        'content-type': 'application/json',
+        cookie: 'h5_user_session=token-admin',
+      },
+      body: JSON.stringify({ config: { mode: 'shadow', serviceUrl: 'http://127.0.0.1:8093' } }),
+    });
+    assert.equal(updateResponse.status, 200);
+    assert.equal((await updateResponse.json()).configVersion, 2);
+    assert.deepEqual(updates, [{
+      config: { mode: 'shadow', serviceUrl: 'http://127.0.0.1:8093' },
+      context: { updatedBy: 'admin-1' },
+    }]);
+
+    const runtimeResponse = await fetch(`${server.baseUrl}/admin-api/orchestrator/runtime`, {
+      headers: { cookie: 'h5_user_session=token-admin' },
+    });
+    assert.equal(runtimeResponse.status, 200);
+    const runtimeBody = await runtimeResponse.json();
+    assert.equal(runtimeBody.source, 'admin-db');
+    assert.equal(runtimeBody.serviceHealth.status, 'healthy');
+
+    const shadowRunsResponse = await fetch(
+      `${server.baseUrl}/admin-api/orchestrator/shadow-runs?hours=12&limit=25&status=failed`,
+      { headers: { cookie: 'h5_user_session=token-admin' } },
+    );
+    assert.equal(shadowRunsResponse.status, 200);
+    assert.equal((await shadowRunsResponse.json()).metrics.failures, 1);
+
+    const executionPlansResponse = await fetch(
+      `${server.baseUrl}/admin-api/orchestrator/execution-plans?hours=24&limit=50&selection=candidate`,
+      { headers: { cookie: 'h5_user_session=token-admin' } },
+    );
+    assert.equal(executionPlansResponse.status, 200);
+    const executionPlansBody = await executionPlansResponse.json();
+    assert.equal(executionPlansBody.metrics.decisions, 3);
+    assert.equal(executionPlansBody.plans[0].candidateEngine, 'langgraph');
+
+    const readinessResponse = await fetch(
+      `${server.baseUrl}/admin-api/orchestrator/canary-readiness`,
+      { headers: { cookie: 'h5_user_session=token-admin' } },
+    );
+    assert.equal(readinessResponse.status, 200);
+    const readinessBody = await readinessResponse.json();
+    assert.equal(readinessBody.ready, false);
+    assert.deepEqual(readinessBody.blockers, ['sample_volume']);
+
+    const shadowRunResponse = await fetch(
+      `${server.baseUrl}/admin-api/orchestrator/shadow-runs/run-shadow-1`,
+      { headers: { cookie: 'h5_user_session=token-admin' } },
+    );
+    assert.equal(shadowRunResponse.status, 200);
+    assert.equal((await shadowRunResponse.json()).remote.available, true);
+  } finally {
+    await server.close();
+  }
+});
+
 test('admin system disclosure policy routes version config through the injected control-plane service', async () => {
   const updates = [];
   const config = {
diff --git a/admin-server.mjs b/admin-server.mjs
index 3f5960b..e3e4320 100644
--- a/admin-server.mjs
+++ b/admin-server.mjs
@@ -79,6 +79,8 @@ const CONSOLES = {
         assetGatewayConfigService: services.assetGatewayConfigService,
         imageMakeAdminConfigService: services.imageMakeAdminConfigService,
         memoryV2ConfigService: services.memoryV2ConfigService,
+        orchestratorConfigService: services.orchestratorConfigService,
+        orchestratorObservabilityService: services.orchestratorObservabilityService,
         mindSearchConfigService: services.mindSearchConfigService,
         skillRuntimeConfigService: services.skillRuntimeConfigService,
         systemDisclosurePolicyService: services.systemDisclosurePolicyService,
diff --git a/agent-run-gateway.mjs b/agent-run-gateway.mjs
index c68fd93..f696eb7 100644
--- a/agent-run-gateway.mjs
+++ b/agent-run-gateway.mjs
@@ -187,6 +187,24 @@ function positiveInteger(value, fallback) {
   return Math.floor(n);
 }
 
+export function normalizeAgentRunWorkerIdentity(identity = {}) {
+  const runtimeRoot = path.resolve(
+    String(identity.runtimeRoot ?? process.cwd()).trim() || process.cwd(),
+  );
+  const buildId =
+    String(
+      identity.buildId
+      ?? process.env.MEMIND_RUNTIME_BUILD_ID
+      ?? process.env.MEMIND_RELEASE_ID
+      ?? process.env.GIT_COMMIT
+      ?? 'dev',
+    ).trim() || 'dev';
+  const workerId =
+    String(identity.workerId ?? '').trim()
+    || `${process.pid}:${crypto.randomUUID()}`;
+  return Object.freeze({ workerId, runtimeRoot, buildId });
+}
+
 function timeoutError(ms) {
   const err = new Error(`agent run timed out after ${ms}ms`);
   err.code = 'AGENT_RUN_TIMEOUT';
@@ -377,8 +395,10 @@ export function createAgentRunGateway({
   conversationMemoryService = null,
   syncUserPagesOnSuccess = null,
   observePersonalMemoryOnSuccess = null,
+  observeWorkflowRun = null,
   isSessionExternallyBusy = null,
   validateRunDeliverables = null,
+  quiesceSessionOnTerminal = null,
   retryDelaysMs = DEFAULT_RUN_RETRY_DELAYS_MS,
   autoDispatch = envFlag(process.env.MEMIND_AGENT_RUN_AUTODISPATCH, true),
   maxConcurrentRuns = positiveInteger(
@@ -393,7 +413,9 @@ export function createAgentRunGateway({
     process.env.MEMIND_AGENT_RUN_HEARTBEAT_MS,
     DEFAULT_RUN_HEARTBEAT_MS,
   ),
+  workerIdentity = null,
 }) {
+  const worker = normalizeAgentRunWorkerIdentity(workerIdentity ?? {});
   const sessionStore = resolveSessionAccess({ userAuth, sessionAccess });
   const inFlight = new Set();
   const queuedDispatches = [];
@@ -426,6 +448,105 @@ export function createAgentRunGateway({
     );
   }
 
+  async function quiesceTerminalSession(runId, {
+    userId,
+    sessionId,
+    requestId = null,
+    status,
+  }) {
+    if (!sessionId || typeof quiesceSessionOnTerminal !== 'function') return;
+    try {
+      const result = await quiesceSessionOnTerminal({
+        runId,
+        userId,
+        sessionId,
+        requestId,
+        status,
+      });
+      await appendEvent(runId, 'session_extensions_quiesced', {
+        sessionId,
+        status,
+        removed: result?.removed ?? [],
+        skipped: Boolean(result?.skipped),
+        cancellation: result?.cancellation ?? null,
+      });
+    } catch (err) {
+      await appendEvent(runId, 'session_extension_quiesce_failed', {
+        sessionId,
+        status,
+        error: err instanceof Error ? err.message : String(err),
+      }).catch(() => {});
+      console.warn(
+        `[AgentRun] failed to quiesce session ${sessionId}:`,
+        err instanceof Error ? err.message : err,
+      );
+    }
+  }
+
+  async function appendExecutionPlanEvent(input, source) {
+    const executionPlan = source?.executionPlan;
+    if (!executionPlan?.dryRun) return;
+    await appendEvent(input.runId, 'workflow_execution_planned', {
+      version: executionPlan.version ?? 'workflow-execution-decision-v1',
+      mode: source.mode ?? null,
+      candidateEngine: executionPlan.candidateEngine ?? null,
+      effectiveEngine: executionPlan.effectiveEngine ?? 'native',
+      fallbackEngine: executionPlan.fallbackEngine ?? 'native',
+      reason: executionPlan.reason ?? 'execution_gate_disabled',
+      candidateReason: executionPlan.candidateReason ?? null,
+      configVersion: executionPlan.configVersion ?? null,
+      bucket: executionPlan.bucket ?? null,
+      taskType: executionPlan.taskType ?? input.taskType ?? null,
+      dryRun: true,
+      handoffAllowed: false,
+    }).catch((error) => {
+      console.warn(
+        '[AgentRun] workflow execution plan event skipped:',
+        error instanceof Error ? error.message : error,
+      );
+    });
+  }
+
+  function dispatchShadowObservation(input) {
+    if (typeof observeWorkflowRun !== 'function' || input.toolMode !== 'code') return;
+    setImmediate(() => {
+      const observationStartedAt = nowMs();
+      void Promise.resolve()
+        .then(() => observeWorkflowRun(input))
+        .then(async (result) => {
+          await appendExecutionPlanEvent(input, result);
+          if (!result?.observed) return;
+          await appendEvent(input.runId, 'workflow_shadow_completed', {
+            engine: result.engine ?? 'langgraph',
+            mode: result.mode ?? 'shadow',
+            configVersion: result.configVersion ?? null,
+            status: result.shadowRun?.status ?? null,
+            phase: result.shadowRun?.phase ?? null,
+            taskType: result.shadowRun?.plan?.taskType ?? input.taskType ?? null,
+            executorAdapter: result.shadowRun?.plan?.executorAdapter ?? null,
+            latencyMs: Math.max(0, nowMs() - observationStartedAt),
+          });
+        })
+        .catch(async (error) => {
+          await appendExecutionPlanEvent(input, error);
+          console.warn(
+            '[AgentRun] workflow shadow observation failed:',
+            error instanceof Error ? error.message : error,
+          );
+          await appendEvent(input.runId, 'workflow_shadow_failed', {
+            code: String(error?.code ?? 'WORKFLOW_SHADOW_FAILED').slice(0, 128),
+            message: String(error instanceof Error ? error.message : error).slice(0, 1000),
+            latencyMs: Math.max(0, nowMs() - observationStartedAt),
+          }).catch((appendError) => {
+            console.warn(
+              '[AgentRun] workflow shadow failure event skipped:',
+              appendError instanceof Error ? appendError.message : appendError,
+            );
+          });
+        });
+    });
+  }
+
   async function appendRunSnapshot(runId) {
     if (!isRunStreamReplayEnabled()) return;
     const row = await getRunById(runId);
@@ -528,8 +649,11 @@ export function createAgentRunGateway({
     await pool.query(
       `INSERT INTO h5_agent_runs
          (id, user_id, agent_session_id, request_id, status, attempts,
-          user_message_json, error_message, created_at, updated_at, started_at, completed_at)
-       VALUES (?, ?, ?, ?, 'queued', 0, ?, NULL, ?, ?, NULL, NULL)`,
+          user_message_json, error_message, created_at, updated_at, started_at, completed_at,
+          required_runtime_root, required_build_id,
+          claimed_worker_id, claimed_runtime_root, claimed_build_id)
+       VALUES (?, ?, ?, ?, 'queued', 0, ?, NULL, ?, ?, NULL, NULL,
+               ?, ?, NULL, NULL, NULL)`,
       [
         runId,
         userId,
@@ -538,6 +662,8 @@ export function createAgentRunGateway({
         serializeMessage(runMessage),
         createdAt,
         createdAt,
+        worker.runtimeRoot,
+        worker.buildId,
       ],
     );
     await appendEvent(runId, 'queued', {
@@ -545,9 +671,22 @@ export function createAgentRunGateway({
       toolMode: normalizedToolMode,
       taskType: normalizedTaskType,
       forceDeepReasoning: Boolean(forceDeepReasoning),
+      requiredRuntimeRoot: worker.runtimeRoot,
+      requiredBuildId: worker.buildId,
+    });
+    const createdRun = projectRun(await getRunById(runId));
+    dispatchShadowObservation({
+      runId,
+      requestId: normalizedRequestId,
+      userId,
+      sessionId: sessionId || null,
+      workflowName: 'code-run-v1',
+      userMessage: runMessage,
+      toolMode: normalizedToolMode,
+      taskType: normalizedTaskType,
     });
     if (autoDispatch) dispatchRun(runId);
-    return projectRun(await getRunById(runId));
+    return createdRun;
   }
 
   async function prepareRunDeliverables({ userId, sessionId, runId, runStartedAtMs = null }) {
@@ -623,6 +762,9 @@ export function createAgentRunGateway({
           attempt,
           pid: process.pid,
           heartbeatMs,
+          workerId: worker.workerId,
+          runtimeRoot: worker.runtimeRoot,
+          buildId: worker.buildId,
         });
       } catch (err) {
         console.error('[AgentRun] worker heartbeat failed:', err instanceof Error ? err.message : err);
@@ -1188,12 +1330,32 @@ export function createAgentRunGateway({
     const nextAttempt = Number(row.attempts ?? 0) + 1;
     const [claim] = await pool.query(
       `UPDATE h5_agent_runs
-       SET status = 'running', attempts = ?, started_at = COALESCE(started_at, ?), updated_at = ?, error_message = NULL
-       WHERE id = ? AND status IN ('queued', 'retryable')`,
-      [nextAttempt, nowMs(), nowMs(), runId],
+       SET status = 'running', attempts = ?, started_at = COALESCE(started_at, ?),
+           updated_at = ?, error_message = NULL,
+           claimed_worker_id = ?, claimed_runtime_root = ?, claimed_build_id = ?
+       WHERE id = ?
+         AND status IN ('queued', 'retryable')
+         AND (required_runtime_root IS NULL OR required_runtime_root = ?)
+         AND (required_build_id IS NULL OR required_build_id = ?)`,
+      [
+        nextAttempt,
+        nowMs(),
+        nowMs(),
+        worker.workerId,
+        worker.runtimeRoot,
+        worker.buildId,
+        runId,
+        worker.runtimeRoot,
+        worker.buildId,
+      ],
     );
     if (Number(claim?.affectedRows ?? 0) === 0) return;
-    await appendEvent(runId, 'running', { attempt: nextAttempt });
+    await appendEvent(runId, 'running', {
+      attempt: nextAttempt,
+      workerId: worker.workerId,
+      runtimeRoot: worker.runtimeRoot,
+      buildId: worker.buildId,
+    });
     const stopHeartbeat = startRunHeartbeat(runId, { attempt: nextAttempt });
 
     try {
@@ -1221,12 +1383,28 @@ export function createAgentRunGateway({
       await markRun(runId, retryable ? 'retryable' : 'failed', {
         error_message: message,
         completed_at: retryable ? null : nowMs(),
+        ...(retryable
+          ? {
+              claimed_worker_id: null,
+              claimed_runtime_root: null,
+              claimed_build_id: null,
+            }
+          : {}),
       }, { expectedStatus: 'running' });
       if (retryable && autoDispatch) {
         setTimeout(() => dispatchRun(runId), retryDelaysMs[nextAttempt - 1]);
       }
     } finally {
       stopHeartbeat();
+      const terminalRun = await getRunById(runId).catch(() => null);
+      if (terminalRun && TERMINAL_STATUSES.has(terminalRun.status)) {
+        await quiesceTerminalSession(runId, {
+          userId: terminalRun.user_id ?? row.user_id,
+          sessionId: terminalRun.agent_session_id ?? row.agent_session_id ?? null,
+          requestId: terminalRun.request_id ?? row.request_id ?? null,
+          status: terminalRun.status,
+        });
+      }
     }
   }
 
@@ -1439,6 +1617,12 @@ export function createAgentRunGateway({
           if (!marked) continue;
           item.status = 'succeeded';
           item.recoveredAs = 'deliverables';
+          await quiesceTerminalSession(row.id, {
+            userId: row.user_id,
+            sessionId: row.agent_session_id ?? null,
+            requestId: row.request_id ?? null,
+            status: 'succeeded',
+          });
           recovered.push(item);
           continue;
         }
@@ -1486,6 +1670,12 @@ export function createAgentRunGateway({
           error: message,
         });
         item.status = 'failed';
+        await quiesceTerminalSession(row.id, {
+          userId: row.user_id,
+          sessionId: row.agent_session_id ?? null,
+          requestId: row.request_id ?? null,
+          status: 'failed',
+        });
       }
       recovered.push(item);
     }
@@ -1522,9 +1712,11 @@ export function createAgentRunGateway({
       `SELECT id
        FROM h5_agent_runs
        WHERE status IN ('queued', 'retryable')
+         AND (required_runtime_root IS NULL OR required_runtime_root = ?)
+         AND (required_build_id IS NULL OR required_build_id = ?)
        ORDER BY updated_at ASC
        LIMIT ?`,
-      [take],
+      [worker.runtimeRoot, worker.buildId, take],
     );
     for (const row of rows) {
       dispatchRun(row.id);
diff --git a/agent-run-gateway.test.mjs b/agent-run-gateway.test.mjs
index 78fb062..8525bff 100644
--- a/agent-run-gateway.test.mjs
+++ b/agent-run-gateway.test.mjs
@@ -7,6 +7,7 @@ import test from 'node:test';
 import {
   assertRequiredImageGenerationCompleted,
   createAgentRunGateway,
+  normalizeAgentRunWorkerIdentity,
 } from './agent-run-gateway.mjs';
 
 test('required image generation cannot succeed without a verified raster image_make result', () => {
@@ -32,6 +33,21 @@ test('required image generation cannot succeed without a verified raster image_m
   }));
 });
 
+test('normalizeAgentRunWorkerIdentity creates a stable normalized runtime boundary', () => {
+  assert.deepEqual(
+    normalizeAgentRunWorkerIdentity({
+      workerId: 'worker-a',
+      runtimeRoot: '/tmp/runtime/../runtime/current',
+      buildId: 'build-123',
+    }),
+    {
+      workerId: 'worker-a',
+      runtimeRoot: '/tmp/runtime/current',
+      buildId: 'build-123',
+    },
+  );
+});
+
 function createFakePool({ sessionDeliverables = {}, workspaceDeliverables = {} } = {}) {
   const runs = new Map();
   const events = [];
@@ -164,9 +180,16 @@ function createFakePool({ sessionDeliverables = {}, workspaceDeliverables = {} }
           }))];
       }
       if (sql.includes('SELECT id') && sql.includes("status IN ('queued', 'retryable')")) {
-        const limit = Number(params[0] ?? 1);
+        const [runtimeRoot, buildId, rawLimit = 1] = params;
+        const limit = Number(rawLimit);
         return [[...runs.values()]
-          .filter((row) => ['queued', 'retryable'].includes(row.status))
+          .filter((row) => (
+            ['queued', 'retryable'].includes(row.status) &&
+            (row.required_runtime_root == null ||
+              row.required_runtime_root === runtimeRoot) &&
+            (row.required_build_id == null ||
+              row.required_build_id === buildId)
+          ))
           .sort((a, b) => Number(a.updated_at) - Number(b.updated_at))
           .slice(0, limit)
           .map((row) => ({ id: row.id }))];
@@ -180,6 +203,8 @@ function createFakePool({ sessionDeliverables = {}, workspaceDeliverables = {} }
           userMessageJson,
           createdAt,
           updatedAt,
+          requiredRuntimeRoot,
+          requiredBuildId,
         ] = params;
         runs.set(id, {
           id,
@@ -194,6 +219,11 @@ function createFakePool({ sessionDeliverables = {}, workspaceDeliverables = {} }
           updated_at: updatedAt,
           started_at: null,
           completed_at: null,
+          required_runtime_root: requiredRuntimeRoot,
+          required_build_id: requiredBuildId,
+          claimed_worker_id: null,
+          claimed_runtime_root: null,
+          claimed_build_id: null,
         });
         return [{ affectedRows: 1 }];
       }
@@ -232,9 +262,26 @@ function createFakePool({ sessionDeliverables = {}, workspaceDeliverables = {} }
         return [filtered.slice(0, limit)];
       }
       if (sql.includes("SET status = 'running'")) {
-        const [attempts, startedAt, updatedAt, id] = params;
+        const [
+          attempts,
+          startedAt,
+          updatedAt,
+          workerId,
+          runtimeRoot,
+          buildId,
+          id,
+          requiredRuntimeRoot,
+          requiredBuildId,
+        ] = params;
         const row = runs.get(id);
-        if (!row || !['queued', 'retryable'].includes(row.status)) {
+        if (
+          !row ||
+          !['queued', 'retryable'].includes(row.status) ||
+          (row.required_runtime_root != null &&
+            row.required_runtime_root !== requiredRuntimeRoot) ||
+          (row.required_build_id != null &&
+            row.required_build_id !== requiredBuildId)
+        ) {
           return [{ affectedRows: 0 }];
         }
         Object.assign(row, {
@@ -243,6 +290,9 @@ function createFakePool({ sessionDeliverables = {}, workspaceDeliverables = {} }
           started_at: row.started_at ?? startedAt,
           updated_at: updatedAt,
           error_message: null,
+          claimed_worker_id: workerId,
+          claimed_runtime_root: runtimeRoot,
+          claimed_build_id: buildId,
         });
         return [{ affectedRows: 1 }];
       }
@@ -561,6 +611,53 @@ test('agent run awaits session Finish before succeeding when proxy supports it',
   assert.equal(finishEvents.length, 1);
 });
 
+test('terminal agent run quiesces session extensions after preserving Finish', async () => {
+  const pool = createFakePool();
+  const quiesced = [];
+  const gateway = createAgentRunGateway({
+    pool,
+    userAuth: {},
+    tkmindProxy: {
+      async startSessionForUser() {
+        return { id: 'session-quiesce-1' };
+      },
+      async submitSessionReplyAndAwaitFinishForUser() {
+        return { ok: true, finishEvent: { type: 'Finish' } };
+      },
+    },
+    quiesceSessionOnTerminal: async (input) => {
+      quiesced.push(input);
+      return { removed: ['sandbox-fs'], skipped: false };
+    },
+    retryDelaysMs: [],
+  });
+
+  const run = await gateway.createRun('user-1', {
+    requestId: 'req-quiesce-1',
+    userMessage: {
+      role: 'user',
+      content: [{ type: 'text', text: 'hello' }],
+    },
+  });
+
+  await waitFor(() =>
+    pool.events.some(
+      (event) =>
+        event.runId === run.id &&
+        event.eventType === 'session_extensions_quiesced',
+    ));
+  assert.equal(pool.runs.get(run.id).status, 'succeeded');
+  assert.deepEqual(quiesced, [
+    {
+      runId: run.id,
+      userId: 'user-1',
+      sessionId: 'session-quiesce-1',
+      requestId: 'req-quiesce-1',
+      status: 'succeeded',
+    },
+  ]);
+});
+
 test('agent run replaces poisoned Goose session and retries with visible context', async () => {
   const pool = createFakePool();
   const submitted = [];
diff --git a/capabilities.mjs b/capabilities.mjs
index 7fafc3e..8b0cbe3 100644
--- a/capabilities.mjs
+++ b/capabilities.mjs
@@ -87,6 +87,48 @@ export function resolveSandboxMcpUserDataPgUrl({
   }
 }
 
+export function resolveSandboxMcpControlDbEnv(
+  sourceEnv = {},
+  {
+    containerized = false,
+    hostGateway = 'host.docker.internal',
+  } = {},
+) {
+  const resolved = {};
+  for (const key of [
+    'DATABASE_URL',
+    'MYSQL_HOST',
+    'MYSQL_PORT',
+    'MYSQL_USER',
+    'MYSQL_PASSWORD',
+    'MYSQL_DATABASE',
+    'PRIVATE_DATA_MAX_BYTES',
+  ]) {
+    if (sourceEnv[key]) resolved[key] = String(sourceEnv[key]);
+  }
+  if (!containerized) return resolved;
+
+  const gateway = String(hostGateway || 'host.docker.internal').trim();
+  if (
+    resolved.MYSQL_HOST &&
+    LOOPBACK_PG_HOSTS.has(resolved.MYSQL_HOST.trim())
+  ) {
+    resolved.MYSQL_HOST = gateway;
+  }
+  if (resolved.DATABASE_URL) {
+    try {
+      const parsed = new URL(resolved.DATABASE_URL);
+      if (LOOPBACK_PG_HOSTS.has(parsed.hostname)) {
+        parsed.hostname = gateway;
+        resolved.DATABASE_URL = parsed.toString();
+      }
+    } catch {
+      // Keep the configured value so the MCP reports the real parse error.
+    }
+  }
+  return resolved;
+}
+
 export function resolveMindSearchMcpServerPath(overridePath, runtimeRoot) {
   return resolveBundledMcpServerPath(
     'tkmind-search-mcp.mjs',
@@ -454,17 +496,16 @@ function sandboxMcpEnvs(sandboxMcp, mcpTools) {
       envs.MINDSPACE_USERDATA_AUTO_PROVISION = String(autoProvision).trim();
     }
   }
-  for (const key of [
-    'DATABASE_URL',
-    'MYSQL_HOST',
-    'MYSQL_PORT',
-    'MYSQL_USER',
-    'MYSQL_PASSWORD',
-    'MYSQL_DATABASE',
-    'PRIVATE_DATA_MAX_BYTES',
-  ]) {
-    if (process.env[key]) envs[key] = process.env[key];
-  }
+  Object.assign(
+    envs,
+    resolveSandboxMcpControlDbEnv(process.env, {
+      containerized: Boolean(sandboxMcp.containerized),
+      hostGateway:
+        sandboxMcp.controlDbHostGateway ??
+        process.env.MINDSPACE_CONTROL_DB_MCP_HOST ??
+        'host.docker.internal',
+    }),
+  );
   return envs;
 }
 
diff --git a/capabilities.test.mjs b/capabilities.test.mjs
index d167b84..94ba67d 100644
--- a/capabilities.test.mjs
+++ b/capabilities.test.mjs
@@ -14,11 +14,51 @@ import {
   resolveSandboxMcpNodeExecPath,
   resolveSandboxMcpServerPath,
   resolveSandboxMcpUserDataPgUrl,
+  resolveSandboxMcpControlDbEnv,
   sandboxDeveloperTools,
   sandboxMcpTools,
 } from './capabilities.mjs';
 import { applyPoliciesToCapabilities } from './policies.mjs';
 
+test('resolveSandboxMcpControlDbEnv rewrites loopback MySQL endpoints for container MCP', () => {
+  const resolved = resolveSandboxMcpControlDbEnv(
+    {
+      DATABASE_URL: 'mysql://portal:secret@127.0.0.1:3306/memind',
+      MYSQL_HOST: 'localhost',
+      MYSQL_PORT: '3306',
+      MYSQL_DATABASE: 'memind',
+    },
+    {
+      containerized: true,
+      hostGateway: 'host.docker.internal',
+    },
+  );
+
+  assert.equal(
+    resolved.DATABASE_URL,
+    'mysql://portal:secret@host.docker.internal:3306/memind',
+  );
+  assert.equal(resolved.MYSQL_HOST, 'host.docker.internal');
+  assert.equal(resolved.MYSQL_PORT, '3306');
+  assert.equal(resolved.MYSQL_DATABASE, 'memind');
+});
+
+test('resolveSandboxMcpControlDbEnv preserves native-process database endpoints', () => {
+  assert.deepEqual(
+    resolveSandboxMcpControlDbEnv(
+      {
+        DATABASE_URL: 'mysql://portal:secret@127.0.0.1:3306/memind',
+        MYSQL_HOST: '127.0.0.1',
+      },
+      { containerized: false },
+    ),
+    {
+      DATABASE_URL: 'mysql://portal:secret@127.0.0.1:3306/memind',
+      MYSQL_HOST: '127.0.0.1',
+    },
+  );
+});
+
 test('resolveSandboxMcpServerPath resolves to an existing MCP entry file', () => {
   const serverPath = resolveSandboxMcpServerPath();
   assert.match(serverPath, /mindspace-sandbox-mcp\.mjs$/);
diff --git a/chat-intent-router.test.mjs b/chat-intent-router.test.mjs
index d4fac3f..345cc2f 100644
--- a/chat-intent-router.test.mjs
+++ b/chat-intent-router.test.mjs
@@ -128,6 +128,20 @@ test('classifyWithRules routes page data collection to page-data-collect', () =>
   assert.equal(result.suggestedSkill, 'page-data-collect');
 });
 
+test('classifyWithRules routes storefront ordering with product admin to page-data-collect', () => {
+  const text = '我要做一个页面，里面可以下单，后台可以上架产品';
+  const result = classifyWithRules({
+    text,
+    userMessage: {
+      role: 'user',
+      content: [{ type: 'text', text }],
+      metadata: { displayText: text },
+    },
+  });
+  assert.equal(result.route, CHAT_INTENT_ROUTE.AGENT);
+  assert.equal(result.suggestedSkill, 'page-data-collect');
+});
+
 test('classifyWithRules routes ordinary household ledger language to page-data-collect', () => {
   const text = '帮我做一个家庭记账页面，我每天可以记录日期、收入、支出、分类和备注，日期默认当天。再做一个管理页面，可以查看所有记录和收支汇总。';
   const result = classifyWithRules({
diff --git a/chat-skills.mjs b/chat-skills.mjs
index 3c64f67..8eacfa2 100644
--- a/chat-skills.mjs
+++ b/chat-skills.mjs
@@ -49,6 +49,8 @@ const PAGE_DATA_INTENT_PATTERNS = [
   /(?:记账|账本|收支|流水|日记|习惯打卡|每日打卡).{0,40}(?:页面|记录|管理|汇总|统计)/u,
   /(?:管理页面|管理页).{0,30}(?:查看|记录|汇总|统计|明细|删除|修改)/u,
   /(?:页面|网页|H5|h5).{0,80}(?:每天|每日|新增|添加|填写|记录).{0,80}(?:所有记录|历史记录|管理|汇总|统计)/u,
+  /(?:页面|网页|商城|店铺).{0,80}(?:下单|订单|购物车).{0,80}(?:后台|管理|上架|商品|产品|库存)/u,
+  /(?:后台|管理).{0,80}(?:上架|下架|商品|产品|库存).{0,80}(?:下单|订单|购物车|页面|网页|商城|店铺)/u,
 ];
 
 const INTERACTIVE_PAGE_DATA_SUBJECT_PATTERN = /(?:便签|便利贴|备忘录|待办|清单)/u;
diff --git a/chat-skills.test.mjs b/chat-skills.test.mjs
index 6a7c741..f7309e7 100644
--- a/chat-skills.test.mjs
+++ b/chat-skills.test.mjs
@@ -150,6 +150,17 @@ test('isPageDataIntent matches survey and backend keywords', () => {
   assert.equal(isPageDataIntent('帮我做一个苏州攻略页面'), false);
 });
 
+test('isPageDataIntent treats storefront ordering plus product administration as Page Data', () => {
+  assert.equal(
+    isPageDataIntent('我要做一个页面，里面可以下单，后台可以上架产品'),
+    true,
+  );
+  assert.equal(
+    isPageDataIntent('做一个后台上架和管理库存的商城，顾客可以购物车下单'),
+    true,
+  );
+});
+
 test('isPageDataIntent matches implicit interactive sticky-note app requests', () => {
   const text = '帮我设计一个便签提醒，可以写便签提交，时间轴来显示';
   assert.equal(isPageDataIntent(text), true);
diff --git a/db.mjs b/db.mjs
index 9e7fcfa..d1e430b 100644
--- a/db.mjs
+++ b/db.mjs
@@ -335,13 +335,67 @@ export async function migrateSchema(pool) {
       updated_at BIGINT NOT NULL,
       started_at BIGINT NULL,
       completed_at BIGINT NULL,
+      required_runtime_root VARCHAR(1024) NULL,
+      required_build_id VARCHAR(128) NULL,
+      claimed_worker_id VARCHAR(255) NULL,
+      claimed_runtime_root VARCHAR(1024) NULL,
+      claimed_build_id VARCHAR(128) NULL,
       UNIQUE KEY uq_h5_agent_run_request (user_id, request_id),
       KEY idx_h5_agent_run_user_status (user_id, status, updated_at),
       KEY idx_h5_agent_run_session (agent_session_id, updated_at),
+      KEY idx_h5_agent_run_runtime_status (required_build_id, status, updated_at),
       CONSTRAINT fk_h5_agent_run_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE,
       CONSTRAINT fk_h5_agent_run_session FOREIGN KEY (agent_session_id) REFERENCES h5_user_sessions(agent_session_id) ON DELETE SET NULL
     ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
   `);
+  const agentRunRuntimeColumns = [
+    ['required_runtime_root', 'VARCHAR(1024) NULL AFTER completed_at'],
+    ['required_build_id', 'VARCHAR(128) NULL AFTER required_runtime_root'],
+    ['claimed_worker_id', 'VARCHAR(255) NULL AFTER required_build_id'],
+    ['claimed_runtime_root', 'VARCHAR(1024) NULL AFTER claimed_worker_id'],
+    ['claimed_build_id', 'VARCHAR(128) NULL AFTER claimed_runtime_root'],
+  ];
+  for (const [column, definition] of agentRunRuntimeColumns) {
+    if (!(await columnExists(pool, 'h5_agent_runs', column))) {
+      await pool.query(`ALTER TABLE h5_agent_runs ADD COLUMN \`${column}\` ${definition}`);
+    }
+  }
+  if (!(await indexExists(pool, 'h5_agent_runs', 'idx_h5_agent_run_runtime_status'))) {
+    await pool.query(
+      `ALTER TABLE h5_agent_runs
+       ADD KEY idx_h5_agent_run_runtime_status (required_build_id, status, updated_at)`,
+    );
+  }
+  const [claimGuardRows] = await pool.query(
+    `SELECT 1
+     FROM information_schema.TRIGGERS
+     WHERE TRIGGER_SCHEMA = DATABASE()
+       AND TRIGGER_NAME = 'trg_h5_agent_runs_claim_identity'
+     LIMIT 1`,
+  );
+  if (claimGuardRows.length === 0) {
+    await pool.query(`
+      CREATE TRIGGER trg_h5_agent_runs_claim_identity
+      BEFORE UPDATE ON h5_agent_runs
+      FOR EACH ROW
+      BEGIN
+        IF NEW.status = 'running'
+           AND OLD.status IN ('queued', 'retryable')
+           AND NEW.required_runtime_root IS NOT NULL
+           AND (
+             NEW.claimed_worker_id IS NULL
+             OR NEW.claimed_runtime_root IS NULL
+             OR NEW.claimed_build_id IS NULL
+             OR NEW.claimed_runtime_root <> NEW.required_runtime_root
+             OR NEW.claimed_build_id <> NEW.required_build_id
+           )
+        THEN
+          SIGNAL SQLSTATE '45000'
+            SET MESSAGE_TEXT = 'agent run worker identity mismatch';
+        END IF;
+      END
+    `);
+  }
 
   await pool.query(`
     CREATE TABLE IF NOT EXISTS h5_agent_run_events (
@@ -351,9 +405,16 @@ export async function migrateSchema(pool) {
       data_json JSON NULL,
       created_at BIGINT NOT NULL,
       KEY idx_h5_agent_run_event_run (run_id, created_at),
+      KEY idx_h5_agent_run_event_type_time (event_type, created_at),
       CONSTRAINT fk_h5_agent_run_event_run FOREIGN KEY (run_id) REFERENCES h5_agent_runs(id) ON DELETE CASCADE
     ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
   `);
+  if (!(await indexExists(pool, 'h5_agent_run_events', 'idx_h5_agent_run_event_type_time'))) {
+    await pool.query(
+      `ALTER TABLE h5_agent_run_events
+       ADD KEY idx_h5_agent_run_event_type_time (event_type, created_at)`,
+    );
+  }
 
   // MindSpace conversation packages: additive provenance tables for grouping
   // images, files, pages, and publications created during a chat session.
diff --git a/deploy/orchestrator/.env.example b/deploy/orchestrator/.env.example
new file mode 100644
index 0000000..cfa4f8a
--- /dev/null
+++ b/deploy/orchestrator/.env.example
@@ -0,0 +1,15 @@
+ORCHESTRATOR_POSTGRES_PASSWORD=replace-with-a-long-random-password
+MEMIND_ORCHESTRATOR_SERVICE_TOKEN=replace-with-a-long-random-service-token
+MEMIND_ORCHESTRATOR_WORKER_TOKEN=replace-with-a-distinct-long-random-worker-token
+MEMIND_ORCHESTRATOR_PORT=8093
+
+# Closed by default. A local canary requires all three values plus the
+# goosed-worker Compose profile.
+MEMIND_ORCHESTRATOR_EXECUTION_ENABLED=0
+MEMIND_ORCHESTRATOR_ENABLED_EXECUTORS=
+MEMIND_ORCHESTRATOR_USER_ALLOWLIST=
+MEMIND_ORCHESTRATOR_TENANT_ALLOWLIST=
+MEMIND_EXECUTOR_GOOSED_URL=https://host.docker.internal:18006
+MEMIND_EXECUTOR_GOOSED_TOKEN=
+MEMIND_EXECUTOR_GOOSED_TLS_INSECURE=1
+MEMIND_EXECUTOR_WORKSPACE_ALIASES_JSON={}
diff --git a/deploy/orchestrator/compose.executor-workers.example.yaml b/deploy/orchestrator/compose.executor-workers.example.yaml
new file mode 100644
index 0000000..00bf170
--- /dev/null
+++ b/deploy/orchestrator/compose.executor-workers.example.yaml
@@ -0,0 +1,55 @@
+services:
+  worker-aider:
+    profiles: ["aider-worker"]
+    image: ${MEMIND_AIDER_WORKER_IMAGE:?set a dedicated image containing Node and Aider}
+    command: ["node", "/app/worker.mjs"]
+    restart: unless-stopped
+    environment:
+      MEMIND_ORCHESTRATOR_URL: http://orchestrator:8093
+      MEMIND_ORCHESTRATOR_SERVICE_TOKEN: ${MEMIND_ORCHESTRATOR_SERVICE_TOKEN:?set service token}
+      MEMIND_ORCHESTRATOR_WORKER_TOKEN: ${MEMIND_ORCHESTRATOR_WORKER_TOKEN:?set worker token}
+      MEMIND_EXECUTOR_WORKER_ID: aider-1
+      MEMIND_EXECUTOR_AIDER_COMMAND: /usr/local/bin/aider
+      MEMIND_EXECUTOR_WORKSPACE_ROOT: /workspaces
+      MEMIND_EXECUTOR_WORKSPACE_ALIASES_JSON: ${MEMIND_EXECUTOR_WORKSPACE_ALIASES_JSON:?use container paths below /workspaces}
+    volumes:
+      - ${MEMIND_EXECUTOR_HOST_WORKSPACE_ROOT:?set isolated host workspace root}:/workspaces:rw
+    read_only: true
+    tmpfs:
+      - /tmp:size=256m
+    cap_drop: [ALL]
+    security_opt: [no-new-privileges:true]
+    pids_limit: 256
+    mem_limit: 4g
+    cpus: 2
+    networks: [orchestrator_edge]
+
+  worker-openhands:
+    profiles: ["openhands-worker"]
+    image: ${MEMIND_OPENHANDS_WORKER_IMAGE:?set a dedicated image containing Node and OpenHands}
+    command: ["node", "/app/worker.mjs"]
+    restart: unless-stopped
+    environment:
+      MEMIND_ORCHESTRATOR_URL: http://orchestrator:8093
+      MEMIND_ORCHESTRATOR_SERVICE_TOKEN: ${MEMIND_ORCHESTRATOR_SERVICE_TOKEN:?set service token}
+      MEMIND_ORCHESTRATOR_WORKER_TOKEN: ${MEMIND_ORCHESTRATOR_WORKER_TOKEN:?set worker token}
+      MEMIND_EXECUTOR_WORKER_ID: openhands-1
+      MEMIND_EXECUTOR_OPENHANDS_COMMAND: /usr/local/bin/openhands
+      MEMIND_EXECUTOR_WORKSPACE_ROOT: /workspaces
+      MEMIND_EXECUTOR_WORKSPACE_ALIASES_JSON: ${MEMIND_EXECUTOR_WORKSPACE_ALIASES_JSON:?use container paths below /workspaces}
+    volumes:
+      - ${MEMIND_EXECUTOR_HOST_WORKSPACE_ROOT:?set isolated host workspace root}:/workspaces:rw
+    read_only: true
+    tmpfs:
+      - /tmp:size=512m
+    cap_drop: [ALL]
+    security_opt: [no-new-privileges:true]
+    pids_limit: 512
+    mem_limit: 8g
+    cpus: 4
+    networks: [orchestrator_edge]
+
+networks:
+  orchestrator_edge:
+    external: true
+    name: orchestrator_orchestrator_edge
diff --git a/deploy/orchestrator/compose.yaml b/deploy/orchestrator/compose.yaml
new file mode 100644
index 0000000..58880eb
--- /dev/null
+++ b/deploy/orchestrator/compose.yaml
@@ -0,0 +1,90 @@
+services:
+  postgres:
+    image: postgres:16-alpine
+    restart: unless-stopped
+    environment:
+      POSTGRES_DB: memind_orchestrator
+      POSTGRES_USER: memind_orchestrator
+      POSTGRES_PASSWORD: ${ORCHESTRATOR_POSTGRES_PASSWORD:?set ORCHESTRATOR_POSTGRES_PASSWORD}
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U memind_orchestrator -d memind_orchestrator"]
+      interval: 5s
+      timeout: 3s
+      retries: 20
+    volumes:
+      - orchestrator_postgres_data:/var/lib/postgresql/data
+    networks:
+      - orchestrator_internal
+
+  orchestrator:
+    image: memind/workflow-orchestrator:local
+    build:
+      context: ../../services/orchestrator
+      dockerfile: Dockerfile
+    restart: unless-stopped
+    depends_on:
+      postgres:
+        condition: service_healthy
+    environment:
+      MEMIND_ORCHESTRATOR_HOST: 0.0.0.0
+      MEMIND_ORCHESTRATOR_PORT: 8093
+      MEMIND_ORCHESTRATOR_CHECKPOINT_MODE: postgres
+      MEMIND_ORCHESTRATOR_DATABASE_URL: postgresql://memind_orchestrator:${ORCHESTRATOR_POSTGRES_PASSWORD}@postgres:5432/memind_orchestrator
+      MEMIND_ORCHESTRATOR_DATABASE_SCHEMA: memind_orchestrator
+      MEMIND_ORCHESTRATOR_SERVICE_TOKEN: ${MEMIND_ORCHESTRATOR_SERVICE_TOKEN:?set MEMIND_ORCHESTRATOR_SERVICE_TOKEN}
+      MEMIND_ORCHESTRATOR_WORKER_TOKEN: ${MEMIND_ORCHESTRATOR_WORKER_TOKEN:-local-worker-disabled}
+      MEMIND_ORCHESTRATOR_EXECUTION_ENABLED: ${MEMIND_ORCHESTRATOR_EXECUTION_ENABLED:-0}
+      MEMIND_ORCHESTRATOR_ENABLED_EXECUTORS: ${MEMIND_ORCHESTRATOR_ENABLED_EXECUTORS:-}
+      MEMIND_ORCHESTRATOR_TENANT_ALLOWLIST: ${MEMIND_ORCHESTRATOR_TENANT_ALLOWLIST:-}
+      MEMIND_ORCHESTRATOR_USER_ALLOWLIST: ${MEMIND_ORCHESTRATOR_USER_ALLOWLIST:-}
+      MEMIND_ORCHESTRATOR_WORKSPACE_KIND_ALLOWLIST: ${MEMIND_ORCHESTRATOR_WORKSPACE_KIND_ALLOWLIST:-workspace-alias}
+      MEMIND_ORCHESTRATOR_MAX_GLOBAL_ACTIVE: ${MEMIND_ORCHESTRATOR_MAX_GLOBAL_ACTIVE:-20}
+      MEMIND_ORCHESTRATOR_MAX_TENANT_ACTIVE: ${MEMIND_ORCHESTRATOR_MAX_TENANT_ACTIVE:-5}
+      MEMIND_ORCHESTRATOR_MAX_USER_ACTIVE: ${MEMIND_ORCHESTRATOR_MAX_USER_ACTIVE:-2}
+      MEMIND_ORCHESTRATOR_MAX_TENANT_PER_MINUTE: ${MEMIND_ORCHESTRATOR_MAX_TENANT_PER_MINUTE:-30}
+      MEMIND_ORCHESTRATOR_MAX_USER_PER_MINUTE: ${MEMIND_ORCHESTRATOR_MAX_USER_PER_MINUTE:-10}
+    ports:
+      - "127.0.0.1:${MEMIND_ORCHESTRATOR_PORT:-8093}:8093"
+    networks:
+      - orchestrator_internal
+      - orchestrator_edge
+
+  worker-goosed:
+    profiles: ["goosed-worker"]
+    image: memind/workflow-orchestrator:local
+    restart: unless-stopped
+    command: ["node", "worker.mjs"]
+    depends_on:
+      orchestrator:
+        condition: service_started
+    environment:
+      MEMIND_ORCHESTRATOR_URL: http://orchestrator:8093
+      MEMIND_ORCHESTRATOR_SERVICE_TOKEN: ${MEMIND_ORCHESTRATOR_SERVICE_TOKEN:?set MEMIND_ORCHESTRATOR_SERVICE_TOKEN}
+      MEMIND_ORCHESTRATOR_WORKER_TOKEN: ${MEMIND_ORCHESTRATOR_WORKER_TOKEN:-local-worker-disabled}
+      MEMIND_EXECUTOR_WORKER_ID: ${MEMIND_EXECUTOR_GOOSED_WORKER_ID:-colima-goosed-1}
+      MEMIND_EXECUTOR_GOOSED_URL: ${MEMIND_EXECUTOR_GOOSED_URL:-https://host.docker.internal:18006}
+      MEMIND_EXECUTOR_GOOSED_TOKEN: ${MEMIND_EXECUTOR_GOOSED_TOKEN:-}
+      MEMIND_EXECUTOR_ALLOW_REMOTE_GOOSED: "1"
+      MEMIND_EXECUTOR_GOOSED_TLS_INSECURE: ${MEMIND_EXECUTOR_GOOSED_TLS_INSECURE:-1}
+      MEMIND_EXECUTOR_WORKSPACE_ALIASES_JSON: ${MEMIND_EXECUTOR_WORKSPACE_ALIASES_JSON:-{}}
+      MEMIND_EXECUTOR_POLL_MS: ${MEMIND_EXECUTOR_POLL_MS:-1000}
+      MEMIND_EXECUTOR_HEARTBEAT_MS: ${MEMIND_EXECUTOR_HEARTBEAT_MS:-10000}
+      MEMIND_EXECUTOR_LEASE_MS: ${MEMIND_EXECUTOR_LEASE_MS:-30000}
+    read_only: true
+    tmpfs:
+      - /tmp:size=64m
+    cap_drop:
+      - ALL
+    security_opt:
+      - no-new-privileges:true
+    pids_limit: 128
+    networks:
+      - orchestrator_edge
+
+networks:
+  orchestrator_internal:
+    internal: true
+  orchestrator_edge:
+
+volumes:
+  orchestrator_postgres_data:
diff --git a/docker-compose.local.yml b/docker-compose.local.yml
index ffa4e71..d7d6719 100644
--- a/docker-compose.local.yml
+++ b/docker-compose.local.yml
@@ -23,6 +23,12 @@ services:
       timeout: 5s
       retries: 3
       start_period: 20s
+    # Each active session owns several stdio MCP pipes. Keep enough descriptor
+    # headroom for local soak tests; lifecycle cleanup is still required.
+    ulimits:
+      nofile:
+        soft: 65536
+        hard: 65536
     restart: unless-stopped
     networks:
       - local-dev
@@ -48,6 +54,10 @@ services:
       timeout: 5s
       retries: 3
       start_period: 20s
+    ulimits:
+      nofile:
+        soft: 65536
+        hard: 65536
     restart: unless-stopped
     networks:
       - local-dev
diff --git a/docs/architecture/memind-orchestrator-boundary.md b/docs/architecture/memind-orchestrator-boundary.md
new file mode 100644
index 0000000..d9c6960
--- /dev/null
+++ b/docs/architecture/memind-orchestrator-boundary.md
@@ -0,0 +1,237 @@
+# Memind Workflow Orchestrator Boundary
+
+## Decision
+
+The Orchestrator starts in the Memind repository but is designed as an
+independently deployable bounded context. Source colocation does not authorize
+in-process execution inside Portal.
+
+The stable boundary is:
+
+```text
+Memind Control Plane
+  -> versioned Orchestrator API / events
+Workflow Orchestrator
+  -> versioned Executor Gateway
+Executor adapters
+  -> Goosed / Aider / OpenHands
+```
+
+LangGraph remains an internal workflow engine implementation. Memind must not
+depend on LangGraph graph, checkpoint, command, or interrupt types.
+
+## Ownership
+
+| Data | Owner |
+|---|---|
+| User, authorization, billing, product run | Memind |
+| Workflow node state, checkpoint, interrupt | Orchestrator |
+| Goosed session | Goosed plus Session Broker mapping |
+| Executor job | Executor Gateway / executor adapter |
+| Workspace and deliverable | Workspace / Artifact / MindSpace services |
+| User-visible progress and audit | Memind run-event projection |
+
+The Orchestrator must not read or write Memind user, billing, capability, or
+provider-key tables. A shared PostgreSQL instance is acceptable during the
+single-host phase, but the Orchestrator must use its own database and database
+credentials.
+
+## Runtime modes
+
+memindadm owns the versioned routing configuration:
+
+| Mode | Behavior |
+|---|---|
+| `off` | Native Agent Run only |
+| `shadow` | Native executes; LangGraph observes and compares decisions |
+| `canary` | Explicit users and deterministic percentage may use LangGraph |
+| `active` | Workflow-allowlisted tasks use the primary engine |
+
+All modes support an explicit Native fallback. The environment kill switch
+`MEMIND_ORCHESTRATOR_KILL_SWITCH=1` overrides admin configuration and forces
+Native selection.
+
+The initial workflow allowlist contains only `code-run-v1`. Ordinary chat and
+existing Goosed session traffic remain outside the Orchestrator path.
+
+Phase 2 implemented only the `off` and `shadow` execution semantics. Canary and
+Active were initially planning-only so an administrative configuration mistake
+could not create two task executors.
+
+Phase 3 makes that restriction explicit in the contract. Routing returns both
+`candidateEngine` and `engine`: Canary or Active may nominate LangGraph, while
+`engine` remains Native. The decision is projected as
+`workflow_execution_planned` with `dryRun=true` and `handoffAllowed=false`.
+The execution adapter normalizes authorization, idempotency, timeout,
+cancellation, and fallback controls. Phase 5 can transfer ownership only when
+the memindadm switch, Portal environment gate, Orchestrator environment gate,
+adapter enablement, worker health, authorization, and admission policy all
+agree. Any missing gate keeps Native effective.
+
+The Dry-run projection records every code-run decision while the configured
+mode is Shadow, Canary, or Active, including `canary_not_selected`. In Shadow,
+the same allowlist and deterministic percentage are evaluated in parallel with
+the remote observation, so collecting routing evidence does not interrupt
+Shadow readiness samples. This prevents a selected-only dataset from reporting
+a meaningless 100% candidate rate. The Memind control plane joins each decision
+to the Native run terminal state and aggregates candidate rate, selection
+reasons, task types, session coverage, and Native terminal coverage without
+querying LangGraph.
+
+## Protocol
+
+The framework-neutral contracts are:
+
+- `orchestrator-run-v1`
+- `orchestrator-event-v1`
+- `workflow-execution-request-v1`
+- `workflow-execution-decision-v1`
+- `executor-job-request-v1`
+- `executor-job-state-v1`
+- `executor-dispatch-decision-v1`
+
+The Phase 3.2 Executor Gateway owns the adapter registry and executor job state
+transition boundary. Requests contain workspace/artifact references,
+authorization and side-effect policy, timeout, cancellation, fallback, and an
+idempotency key. The store interface requires atomic create-if-absent semantics
+so retries return the original job and conflicting payloads fail closed.
+
+Goosed, Aider, and OpenHands began as disabled `contract-only` adapters. The
+reference in-memory store remains non-durable and is not a deployment backend.
+In the current Phase 5 implementation the dispatch capability exists, but
+execution and every adapter remain disabled by default. Shadow jobs still record
+terminal `blocked` state without launching a process or touching a workspace.
+
+Phase 3.3 persists that state in the Orchestrator-owned PostgreSQL database.
+LangGraph checkpoint tables and `executor_jobs` share the isolated
+`memind_orchestrator` schema and credentials, but remain behind separate
+storage interfaces and readiness probes. This is a deployment simplification,
+not a domain ownership leak: neither store can access Memind business tables,
+and the Executor Job Store can move to a separate database without changing
+the graph or the Memind-facing protocol.
+
+The `build_plan` node creates the deterministic preview job
+`<runId>:executor-preview` with idempotency key
+`<runId>:build_plan:v1`. The stored result is terminal `blocked` state with
+`executor_dispatch_not_implemented`; it is a durable audit and recovery
+boundary, not an execution claim. If the run identifier is unsafe or would
+overflow the 128-character Job id boundary, the graph substitutes a stable
+SHA-256-derived opaque prefix.
+
+Phase 3.4 adds the append-only `executor-job-event-v1` contract. Job snapshots
+remain in `executor_jobs`, while cursor-addressable events live in
+`executor_job_events`. A transaction commits the initial snapshot and event
+together; later state transitions lock the job row and commit the updated
+snapshot and next event together. This prevents a visible state transition
+without its corresponding audit event.
+
+The read boundary is deliberately narrower than an execution control API:
+
+```text
+GET /v1/executor-jobs/:jobId
+GET /v1/executor-jobs/:jobId/events?after=<cursor>&limit=<limit>
+```
+
+Phase 3.4 had no HTTP submit, retry, claim, or executor cancel endpoint.
+Phase 3.5 adds a separately authenticated worker protocol. The control-plane
+read projection still contains no task instruction, secret, absolute path, lease
+token, or executor SDK object; only a successful worker claim receives the
+normalized request and lease token.
+
+The implemented internal API is:
+
+```text
+POST /v1/runs
+GET /v1/runs/:id
+POST /v1/runs/:id/resume
+POST /v1/runs/:id/cancel
+GET /v1/runs/:id/events?after=<cursor>
+GET /v1/executor-jobs/:jobId
+GET /v1/executor-jobs/:jobId/events?after=<cursor>&limit=<limit>
+```
+
+External state changes must use an idempotency key derived from run, graph
+version, node, and attempt. Graph state stores resource references and decisions,
+not API keys, large logs, binary artifacts, or absolute production paths.
+
+The graph keeps three deterministic control-plane nodes:
+
+```text
+validate_run -> build_plan -> finalize_run
+```
+
+Observe-only runs require `sideEffectsAllowed=false`, project the Native
+boundary, and persist a blocked Executor Job. Explicit active runs require
+`sideEffectsAllowed=true` plus every execution gate; they queue a job and enter
+`waiting` until the worker-owned job reaches a terminal state. LangGraph never
+mounts a workspace or imports an executor SDK.
+
+## Phase 5 worker and loop boundary
+
+The task loop is split across durable owners:
+
+```text
+LangGraph run: validate -> queue -> wait -> project terminal
+Executor Job: queued -> leased -> running -> terminal/retryable
+Worker: claim -> heartbeat -> adapter -> artifact references
+```
+
+PostgreSQL row locks and lease tokens fence duplicate claims and late worker
+updates. Expired leases recover to `retryable` until `maxAttempts` is exhausted,
+then become `timed_out`. Worker heartbeats are persisted independently of job
+heartbeats so readiness and autoscaling signals also work while the queue is
+empty.
+
+Goosed is a remote HTTP/SSE adapter. Aider and OpenHands are process adapters
+intended to run in separate worker containers with workspace aliases, an
+allowlisted writable root, no shell, bounded environment/output, resource
+limits, and no Docker socket. All adapter outputs cross the boundary as bounded
+events and artifact references.
+
+Admission is defense in depth: tenant/user/workspace allowlists, global and
+per-subject concurrency, and per-minute limits are evaluated before queueing.
+The public metrics endpoint exposes queue states, claimable jobs, expired
+leases, worker health, and execution-gate state without task contents.
+
+## Failure isolation
+
+Portal invokes Shadow only after the product run and its `queued` event have
+been committed. The observation is scheduled without awaiting it. A timeout or
+failure:
+
+1. cannot reject or delay `createRun`;
+2. cannot mutate the Native run status;
+3. is projected as `workflow_shadow_failed`;
+4. remains removable by deleting the observer wiring and changing only the
+   service URL boundary.
+
+Successful observations are projected as `workflow_shadow_completed`; graph
+checkpoints and blocked Executor Jobs stay in the Orchestrator-owned PostgreSQL
+database.
+
+Both terminal projection events contain bounded observation latency. The
+Memind-owned observability service aggregates those events and may join them to
+the product run status. Only per-run detail calls cross the service boundary to
+read LangGraph checkpoint state and node events.
+
+Canary readiness is also a Memind control-plane projection. It excludes
+synthetic smoke runs and evaluates operational health, durable checkpoint state,
+durable Executor Job storage, sample volume, session coverage, success rate,
+latency coverage, P95 latency, Native terminal coverage, and sample freshness.
+The result is advisory:
+`manual_canary_review` never mutates routing configuration or transfers
+execution ownership.
+
+## Deployment evolution
+
+1. Local native Orchestrator process with an explicit MemorySaver for debugging.
+2. Colima Compose with an isolated PostgreSQL checkpoint database.
+3. Approved server-side shadow service; no production task claim.
+4. User-allowlisted code-run canary with Native rollback.
+5. Isolated Aider/OpenHands executor workers.
+6. Move the same service contract to Linux or Kubernetes when horizontal scaling
+   or independent ownership becomes necessary.
+
+The Orchestrator must not share the Goosed Compose lifecycle or mount the Docker
+socket. It calls MindSpace through its service API and calls Goosed through the
+existing proxy boundary.
diff --git a/docs/local-analytics.md b/docs/local-analytics.md
index 5d659a7..e053b6e 100644
--- a/docs/local-analytics.md
+++ b/docs/local-analytics.md
@@ -1,37 +1,51 @@
-# Local Memind + Umami analytics
+# Local Memind analytics (Umami + Rybbit)
 
-The integration is local-only by default. Memind proxies `/analytics/*` to the
-local Umami service at `http://127.0.0.1:3100`; it does not contact 103/105.
+## Umami (optional)
 
-1. Start `/Users/john/Project/memind-analytics` and verify:
+Memind can still proxy `/analytics/*` to a local Umami service at
+`http://127.0.0.1:3100`.
 
-   ```bash
-   curl --fail http://127.0.0.1:3100/api/heartbeat
-   ```
+```dotenv
+MEMIND_ANALYTICS_ENABLED=true
+MEMIND_ANALYTICS_URL=http://127.0.0.1:3100
+MEMIND_ANALYTICS_WEBSITE_ID=<website-id>
+MEMIND_ANALYTICS_ID_SECRET=<random-local-secret>
+MEMIND_ANALYTICS_DOMAINS=127.0.0.1,localhost
+```
 
-2. Create one Umami Website for the local generated-page host. Do not create a
-   Website per page or per user.
+## Rybbit (recommended for behavior analytics)
 
-3. Put the Website ID and a local-only pseudonymization secret in Memind's
-   `.env`:
+Rybbit runs on 105 as `https://rybbit.tkmind.cn`. Local Memind does not talk to
+103 for analytics. It proxies same-origin `/rybbit/*` to Rybbit `/api/*` so the
+browser script stays first-party:
+
+```text
+Generated Page
+  -> /rybbit/script.js  -> https://rybbit.tkmind.cn/api/script.js
+  -> /rybbit/track      -> https://rybbit.tkmind.cn/api/track
+```
+
+1. In Rybbit, create one Site for the local host you use (`127.0.0.1` or
+   `localhost`). Do not create a Site per page or per user.
+2. Put the numeric Site ID and a local pseudonymization secret in Memind `.env`:
 
    ```dotenv
-   MEMIND_ANALYTICS_ENABLED=true
-   MEMIND_ANALYTICS_URL=http://127.0.0.1:3100
-   MEMIND_ANALYTICS_WEBSITE_ID=<website-id>
-   MEMIND_ANALYTICS_ID_SECRET=<random-local-secret>
-   MEMIND_ANALYTICS_DOMAINS=127.0.0.1,localhost
+   MEMIND_RYBBIT_ENABLED=true
+   MEMIND_RYBBIT_URL=https://rybbit.tkmind.cn
+   MEMIND_RYBBIT_SITE_ID=2
+   MEMIND_RYBBIT_ID_SECRET=<random-local-secret>
    ```
 
-4. Restart the local Memind server. Full generated HTML pages will receive a
-   same-origin `/analytics/script.js` tracker. The tracker identifies the
-   visitor with a stable pseudonymous owner ID before sending a standard Umami
-   page view, so Users and Pageviews are populated. The Identify properties
-   include the readable Memind username and current public page URL for
-   operational analytics. Click, form, scroll, and engagement events retain the
-   pseudonymous `owner_id`, `page_id`, and `channel` dimensions.
+3. Restart the local Memind server. Full generated HTML pages receive a
+   same-origin `/rybbit/script.js` tracker. The tracker identifies the visitor
+   with a stable pseudonymous owner ID, then records engagement events such as
+   `page_click`, scroll depth, and dwell time. Initial pageviews come from
+   Rybbit's site setting `trackInitialPageView`.
 
-The integration is fail-open: missing configuration, disabled analytics, or a
-down Umami service leaves page generation and page delivery unchanged. User
-facing analytics must be queried through a future Memind API that filters by
-the authenticated owner; do not expose the Umami dashboard directly to users.
+4. Open Rybbit from local `memind_adm` → Analytics 配置 →「打开 Rybbit 分析后台」
+   (SSO). That path requires matching `MEMIND_RYBBIT_SSO_SECRET` /
+   `RYBBIT_SSO_EMAIL` with the 105 Rybbit deployment.
+
+Both integrations are fail-open: missing configuration or a down analytics
+service leaves page generation and page delivery unchanged. Do not expose the
+Rybbit or Umami dashboards directly to end users.
diff --git a/docs/orchestrator-phase5-runbook.md b/docs/orchestrator-phase5-runbook.md
new file mode 100644
index 0000000..ff25f89
--- /dev/null
+++ b/docs/orchestrator-phase5-runbook.md
@@ -0,0 +1,131 @@
+# Workflow Orchestrator Phase 5 Runbook
+
+## Scope
+
+Phase 5 makes the LangGraph control plane operationally deployable without
+making it the default executor. The default remains:
+
+```text
+memindadm executionEnabled=false
+Portal MEMIND_ORCHESTRATOR_EXECUTION_HANDOFF_ENABLED=0
+Orchestrator MEMIND_ORCHESTRATOR_EXECUTION_ENABLED=0
+enabled executor list empty
+Native Agent Run owns execution
+```
+
+An execution handoff requires all gates to agree: memindadm mode and explicit
+execution switch, Portal environment gate, deterministic user/workflow rollout,
+healthy Orchestrator storage, Orchestrator execution gate, enabled adapter,
+authorization, workspace alias policy, quota admission, and a healthy worker.
+
+## Local Colima canary
+
+1. Copy `deploy/orchestrator/.env.example` to the ignored local `.env`.
+2. Set distinct PostgreSQL, service, and worker secrets.
+3. Keep execution disabled and start the durable control plane:
+
+```bash
+docker compose -f deploy/orchestrator/compose.yaml up -d --build
+curl -fsS http://127.0.0.1:8093/ready
+curl -fsS http://127.0.0.1:8093/metrics
+```
+
+4. Configure a workspace alias understood by the target Goosed instance.
+5. Enable only Goosed for a single local user and start the worker profile:
+
+```text
+MEMIND_ORCHESTRATOR_EXECUTION_ENABLED=1
+MEMIND_ORCHESTRATOR_ENABLED_EXECUTORS=goosed
+MEMIND_ORCHESTRATOR_USER_ALLOWLIST=<local-user-id>
+MEMIND_EXECUTOR_WORKSPACE_ALIASES_JSON={"canary":"/absolute/canary/path"}
+```
+
+```bash
+docker compose -f deploy/orchestrator/compose.yaml --profile goosed-worker up -d
+```
+
+The Orchestrator `/ready` endpoint intentionally fails while execution is
+enabled and no non-stale worker heartbeat exists.
+
+## Rollout order
+
+1. `off`: verify storage, metrics, backup, and worker registration.
+2. `shadow`: collect Native versus LangGraph planning evidence.
+3. `canary`, execution switch off: verify selection denominator and readiness.
+4. `canary`, execution switch on: one explicit user, one workspace alias, zero
+   percentage rollout.
+5. Increase percentage only after success rate, timeout, expired lease, queue
+   age, fallback, and Native rollback signals remain within the approved SLO.
+6. `active` remains workflow-allowlisted and requires a separate release
+   approval.
+
+Never enable Aider or OpenHands in the Orchestrator service until its dedicated
+worker is registered and healthy. Use the example worker Compose overlay as a
+template; each tool gets a separate image, resource limits, writable workspace
+root, read-only container root, no Docker socket, dropped capabilities, and a
+distinct worker identity.
+
+## Immediate rollback
+
+Use any one of these independent controls:
+
+1. Set `MEMIND_ORCHESTRATOR_KILL_SWITCH=1` on Portal.
+2. Clear the memindadm execution switch or set mode to `off`.
+3. Set Portal `MEMIND_ORCHESTRATOR_EXECUTION_HANDOFF_ENABLED=0`.
+4. Set Orchestrator `MEMIND_ORCHESTRATOR_EXECUTION_ENABLED=0`.
+5. Remove an executor from `MEMIND_ORCHESTRATOR_ENABLED_EXECUTORS`.
+6. Drain a worker by stopping it gracefully; the worker records `draining=true`.
+
+Queued jobs stay durable. Running jobs stop receiving heartbeats, and lease
+recovery moves them to `retryable` or `timed_out` according to attempt limits.
+Native fallback remains a Portal decision; the Orchestrator never launches a
+second Native run by itself.
+
+## Monitoring
+
+Scrape `/metrics` and alert on:
+
+- `memind_orchestrator_executor_expired_leases > 0`;
+- claimable jobs increasing while healthy workers are zero;
+- repeated `retryable`, `failed`, or `timed_out` states;
+- worker heartbeat age beyond 60 seconds;
+- any execution-enabled interval without durable PostgreSQL readiness.
+
+Executor events contain bounded metadata and artifact references. They must not
+contain provider keys, absolute host paths, full stdout/stderr, or binary data.
+
+## Backup and disaster recovery
+
+Create and verify a PostgreSQL custom-format backup:
+
+```bash
+node scripts/orchestrator-dr.mjs backup --output /safe/path/orchestrator.dump
+node scripts/orchestrator-dr.mjs verify --input /safe/path/orchestrator.dump
+```
+
+Restore only into a confirmed empty target:
+
+```bash
+node scripts/orchestrator-dr.mjs restore \
+  --input /safe/path/orchestrator.dump \
+  --database-url postgresql://... \
+  --confirm-empty-target
+```
+
+The restore command never uses `--clean` and refuses remote targets unless
+`--allow-remote-target` is explicitly supplied. After restore, keep execution
+disabled, start one worker, verify checkpoints/jobs/events/worker heartbeats,
+then repeat the rollout order from `off`.
+
+## Production release gate
+
+This runbook does not authorize a production action. Before any server-side
+deployment, follow `ENGINEERING_WORKFLOW_RULES.md`,
+`PRODUCTION_RELEASE_RULES.md`, and run:
+
+```bash
+bash scripts/check-release-ready.sh
+```
+
+Production still requires a clean commit on complete `main`, passing CI, an
+explicit deployment approval, a current backup, and a tested rollback.
diff --git a/mindspace-public-page-context.mjs b/mindspace-public-page-context.mjs
index 1fdccd9..ba31976 100644
--- a/mindspace-public-page-context.mjs
+++ b/mindspace-public-page-context.mjs
@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { PUBLISH_KEY_UUID, PUBLISH_ROOT_DIR } from './user-publish.mjs';
 import { normalizeWorkspaceRelativePath } from './mindspace-pages.mjs';
+import { getPageDataPolicyIndexByWorkspacePath } from './page-data-policy-index.mjs';
 
 const LOCAL_HOST_PATTERN = /^(localhost|127\.0\.0\.1|\[::1\]|192\.168\.|10\.|100\.)/i;
 
@@ -102,6 +103,56 @@ export function injectPublishedPageDataContext(html, { pageSource = null, public
   });
 }
 
+export async function resolveMindSpacePageDataContext({
+  pool = null,
+  pageService = null,
+  userId,
+  relativePath,
+  logger = console,
+} = {}) {
+  const normalizedUserId = String(userId ?? '').trim().toLowerCase();
+  const normalizedRelativePath = normalizeWorkspaceRelativePath(relativePath);
+  if (!normalizedUserId || !normalizedRelativePath) return null;
+
+  // Page Data policy lives in the Portal control plane. In split-service mode the
+  // generic MindSpace page service is remote, so it may not see a local binding
+  // immediately. Resolve the local binding index first and retain the page service
+  // as the compatibility fallback for ordinary published pages.
+  const indexed = await getPageDataPolicyIndexByWorkspacePath(
+    pool,
+    normalizedUserId,
+    normalizedRelativePath,
+  ).catch((error) => {
+    logger?.warn?.(
+      `[MindSpace] failed to resolve local Page Data binding for ${normalizedUserId}/${normalizedRelativePath}: ${error?.message || error}`,
+    );
+    return null;
+  });
+  if (indexed?.pageId) {
+    return {
+      pageId: indexed.pageId,
+      accessMode: indexed.accessMode ?? null,
+      publicationId: indexed.publicationId ?? null,
+    };
+  }
+
+  if (typeof pageService?.findPageByRelativePath !== 'function') return null;
+  const page = await pageService
+    .findPageByRelativePath(normalizedUserId, normalizedRelativePath)
+    .catch((error) => {
+      logger?.warn?.(
+        `[MindSpace] failed to resolve remote page context for ${normalizedUserId}/${normalizedRelativePath}: ${error?.message || error}`,
+      );
+      return null;
+    });
+  if (!page?.id) return null;
+  return {
+    pageId: page.id,
+    accessMode: page.publicationAccessMode ?? null,
+    publicationId: page.currentPublishId ?? page.current_publish_id ?? null,
+  };
+}
+
 export const mindspacePublicPageContextInternals = {
   LOCAL_HOST_PATTERN,
 };
diff --git a/mindspace-public-page-context.test.mjs b/mindspace-public-page-context.test.mjs
index 5ac0233..35bfdbf 100644
--- a/mindspace-public-page-context.test.mjs
+++ b/mindspace-public-page-context.test.mjs
@@ -6,6 +6,7 @@ import {
   injectMindSpacePageDataContext,
   injectPublishedPageDataContext,
   parseMindSpacePublishFilePath,
+  resolveMindSpacePageDataContext,
 } from './mindspace-public-page-context.mjs';
 
 test('parseMindSpacePublishFilePath extracts userId and relative path', () => {
@@ -47,3 +48,65 @@ test('injectPublishedPageDataContext injects pageId from publication resolve res
   assert.match(next, /meta name="mindspace-page-data-page-id" content="2b201736-03ca-4172-affd-00f2a0f700b5"/);
   assert.match(next, /window\.__MINDSPACE_PAGE_DATA__=\{"pageId":"2b201736-03ca-4172-affd-00f2a0f700b5","accessMode":"public"\}/);
 });
+
+test('resolveMindSpacePageDataContext prefers the Portal policy index in split-service mode', async () => {
+  const pool = {
+    async query() {
+      return [[{
+        page_id: 'local-page',
+        owner_user_id: 'user-1',
+        access_mode: 'public',
+        dataset_count: 1,
+        scope_hash: 'scope',
+        updated_at: 123,
+        current_publish_id: 'local-publish',
+      }]];
+    },
+  };
+  let remoteCalls = 0;
+  const result = await resolveMindSpacePageDataContext({
+    pool,
+    pageService: {
+      async findPageByRelativePath() {
+        remoteCalls += 1;
+        return { id: 'remote-page', publicationAccessMode: 'password' };
+      },
+    },
+    userId: 'USER-1',
+    relativePath: 'public/storefront.html',
+  });
+  assert.deepEqual(result, {
+    pageId: 'local-page',
+    accessMode: 'public',
+    publicationId: 'local-publish',
+  });
+  assert.equal(remoteCalls, 0);
+});
+
+test('resolveMindSpacePageDataContext falls back to the MindSpace page service', async () => {
+  const result = await resolveMindSpacePageDataContext({
+    pool: {
+      async query() {
+        return [[]];
+      },
+    },
+    pageService: {
+      async findPageByRelativePath(userId, relativePath) {
+        assert.equal(userId, 'user-1');
+        assert.equal(relativePath, 'public/plain.html');
+        return {
+          id: 'remote-page',
+          publicationAccessMode: 'internal',
+          currentPublishId: 'remote-publish',
+        };
+      },
+    },
+    userId: 'USER-1',
+    relativePath: 'public/plain.html',
+  });
+  assert.deepEqual(result, {
+    pageId: 'remote-page',
+    accessMode: 'internal',
+    publicationId: 'remote-publish',
+  });
+});
diff --git a/mindspace-rybbit.mjs b/mindspace-rybbit.mjs
new file mode 100644
index 0000000..6b6f2de
--- /dev/null
+++ b/mindspace-rybbit.mjs
@@ -0,0 +1,114 @@
+import crypto from 'node:crypto';
+
+import {
+  pseudonymizeAnalyticsId,
+  resolveAnalyticsOwnerLabel,
+  resolveAnalyticsOwnerSegment,
+} from './mindspace-analytics.mjs';
+
+const RYBBIT_MARKER = 'data-memind-rybbit="1"';
+
+export function resolveMindSpaceRybbitConfig(env = process.env) {
+  const enabled = String(env.MEMIND_RYBBIT_ENABLED ?? '').toLowerCase() === 'true';
+  const siteId = String(env.MEMIND_RYBBIT_SITE_ID ?? '').trim();
+  const secret = String(env.MEMIND_RYBBIT_ID_SECRET ?? env.MEMIND_ANALYTICS_ID_SECRET ?? '').trim();
+  const rybbitUrl = String(env.MEMIND_RYBBIT_URL ?? env.RYBBIT_URL ?? 'https://rybbit.tkmind.cn').trim()
+    || 'https://rybbit.tkmind.cn';
+  return {
+    enabled: enabled && Boolean(siteId) && Boolean(secret),
+    siteId,
+    idSecret: secret,
+    rybbitUrl: rybbitUrl.replace(/\/$/, ''),
+    // Same-origin proxy path. Script auto-discovers host by splitting on /script.js,
+    // so /rybbit/script.js makes events go to /rybbit/track → proxied to /api/track.
+    scriptPath: String(env.MEMIND_RYBBIT_SCRIPT_PATH ?? '/rybbit/script.js').trim() || '/rybbit/script.js',
+    hostPath: String(env.MEMIND_RYBBIT_HOST_PATH ?? '/rybbit').trim() || '/rybbit',
+  };
+}
+
+export { resolveAnalyticsOwnerLabel, resolveAnalyticsOwnerSegment, pseudonymizeAnalyticsId };
+
+function jsonForInlineScript(value) {
+  return JSON.stringify(value)
+    .replaceAll('<', '\\u003c')
+    .replaceAll('>', '\\u003e')
+    .replaceAll('&', '\\u0026');
+}
+
+export function sendMindSpaceRybbitEvent({
+  config,
+  eventName,
+  ownerId,
+  pageId = '',
+  publicationId = '',
+  agentRunId = '',
+  channel = 'h5',
+  ownerSegment = 'unknown',
+  ownerLabel = '未命名用户',
+  url = '',
+} = {}) {
+  if (!config?.enabled || !config.siteId || !config.idSecret || !eventName) return Promise.resolve(false);
+  const owner = pseudonymizeAnalyticsId(ownerId, config.idSecret);
+  if (!owner) return Promise.resolve(false);
+  const endpoint = `${String(config.rybbitUrl || 'https://rybbit.tkmind.cn').replace(/\/$/, '')}/api/track`;
+  const payload = {
+    site_id: String(config.siteId),
+    type: 'custom_event',
+    event_name: String(eventName).slice(0, 256),
+    pathname: url || '/',
+    page_title: '',
+    referrer: '',
+    hostname: '127.0.0.1',
+    user_id: owner,
+    properties: JSON.stringify({
+      owner_id: owner,
+      page_id: String(pageId || ''),
+      publication_id: String(publicationId || ''),
+      agent_run_id: String(agentRunId || ''),
+      channel,
+      owner_segment: String(ownerSegment || 'unknown'),
+      owner_label: resolveAnalyticsOwnerLabel({ displayName: ownerLabel }),
+    }),
+  };
+  return fetch(endpoint, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', 'user-agent': 'Memind/local-rybbit' },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(1500),
+  }).then((response) => response.ok).catch(() => false);
+}
+
+export function injectMindSpaceRybbit(html, {
+  ownerId,
+  pageId = '',
+  publicationId = '',
+  ownerSegment = 'unknown',
+  ownerLabel = '未命名用户',
+  channel = 'h5',
+  config = resolveMindSpaceRybbitConfig(),
+} = {}) {
+  const source = String(html ?? '');
+  if (!config?.enabled || !config.siteId || !/^\s*(<!doctype html|<html\b)/i.test(source)) return source;
+  if (source.includes(RYBBIT_MARKER)) return source;
+  const owner = pseudonymizeAnalyticsId(ownerId, config.idSecret);
+  if (!owner) return source;
+
+  const metadata = {
+    owner_id: owner,
+    username: resolveAnalyticsOwnerLabel({ displayName: ownerLabel }),
+    owner_segment: String(ownerSegment || 'unknown'),
+    page_id: String(pageId || ''),
+    publication_id: String(publicationId || ''),
+    channel,
+  };
+  const attrs = [
+    RYBBIT_MARKER,
+    `data-site-id="${String(config.siteId).replaceAll('"', '&quot;')}"`,
+    'defer',
+    `src="${config.scriptPath}"`,
+  ];
+  // Manual identify + engagement events; keep initial pageview from Rybbit site settings.
+  const block = `<script ${attrs.join(' ')}></script><script ${RYBBIT_MARKER}>(function(){var d=${jsonForInlineScript(metadata)},seen={},tries=0;function api(){return window.rybbit;}function t(n,x){var r=api();if(!r||typeof r.event!=='function')return;var p=Object.assign({},d,{page_url:location.href,page_title:document.title},x||{});r.event(n,p);}function identify(){var r=api();if(!r||typeof r.identify!=='function')return;r.identify(d.owner_id,{username:d.username,memind_page_url:location.href,owner_segment:d.owner_segment,channel:d.channel,page_id:d.page_id,publication_id:d.publication_id});}function once(n,x){if(seen[n])return;seen[n]=1;t(n,x);}function wire(){identify();document.addEventListener('click',function(e){var el=e.target&&e.target.closest?e.target.closest('a,button,[role="button"],[data-rybbit-event],[data-umami-event]'):null;if(!el)return;var custom=el.getAttribute('data-rybbit-event')||el.getAttribute('data-umami-event');var href=el.tagName==='A'?el.getAttribute('href')||'':'';t(custom||'page_click',{element:el.tagName.toLowerCase(),element_id:el.id||'',event_label:(custom||el.getAttribute('aria-label')||'').slice(0,100),target_url:href.slice(0,500)});},{passive:true});document.addEventListener('submit',function(e){var form=e.target;t('page_form_submit',{form_id:form&&form.id||'',form_action:form&&form.getAttribute('action')||''});},{passive:true});var marks=[25,50,75,90];function scroll(){var h=document.documentElement.scrollHeight-window.innerHeight;if(h<=0){once('page_scroll_100');return;}var pct=Math.round(window.scrollY/h*100);marks.forEach(function(m){if(pct>=m)once('page_scroll_'+m);});}window.addEventListener('scroll',scroll,{passive:true});setTimeout(function(){once('page_engaged_10s');},10000);setTimeout(function(){once('page_engaged_30s');},30000);scroll();}function ready(){if(api()){wire();return;}if(tries++>40)return;setTimeout(ready,50);}if(document.readyState==='loading'){document.addEventListener('DOMContentLoaded',ready,{once:true});}else{ready();}})();</script>`;
+  if (/<\/head>/i.test(source)) return source.replace(/<\/head>/i, `${block}</head>`);
+  return source.replace(/<body\b/i, `${block}<body`);
+}
diff --git a/mindspace-rybbit.test.mjs b/mindspace-rybbit.test.mjs
new file mode 100644
index 0000000..fed0f98
--- /dev/null
+++ b/mindspace-rybbit.test.mjs
@@ -0,0 +1,104 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import vm from 'node:vm';
+
+import {
+  injectMindSpaceRybbit,
+  resolveMindSpaceRybbitConfig,
+} from './mindspace-rybbit.mjs';
+
+test('rybbit config is disabled unless explicitly enabled and configured', () => {
+  assert.equal(resolveMindSpaceRybbitConfig({ MEMIND_RYBBIT_ENABLED: 'true' }).enabled, false);
+  assert.equal(resolveMindSpaceRybbitConfig({
+    MEMIND_RYBBIT_ENABLED: 'true',
+    MEMIND_RYBBIT_SITE_ID: '2',
+  }).enabled, false);
+  const config = resolveMindSpaceRybbitConfig({
+    MEMIND_RYBBIT_ENABLED: 'true',
+    MEMIND_RYBBIT_SITE_ID: '2',
+    MEMIND_RYBBIT_ID_SECRET: 'local-secret',
+    MEMIND_RYBBIT_URL: 'https://rybbit.tkmind.cn',
+  });
+  assert.equal(config.enabled, true);
+  assert.equal(config.siteId, '2');
+  assert.equal(config.rybbitUrl, 'https://rybbit.tkmind.cn');
+  assert.equal(config.hostPath, '/rybbit');
+  assert.equal(config.scriptPath, '/rybbit/script.js');
+});
+
+test('injects one local same-origin rybbit tracker with page dimensions', () => {
+  const html = '<!doctype html><html><head><title>Demo</title></head><body><h1>Demo</h1></body></html>';
+  const out = injectMindSpaceRybbit(html, {
+    ownerId: 'user-123',
+    ownerLabel: '张三',
+    pageId: 'page-1',
+    publicationId: 'pub-1',
+    config: {
+      enabled: true,
+      siteId: '2',
+      idSecret: 'secret',
+      scriptPath: '/rybbit/script.js',
+      hostPath: '/rybbit',
+    },
+  });
+  assert.match(out, /src="\/rybbit\/script\.js"/);
+  assert.match(out, /data-site-id="2"/);
+  assert.match(out, /data-memind-rybbit="1"/);
+  assert.match(out, /r\.identify\(d\.owner_id,/);
+  assert.match(out, /r\.event\(n,p\)/);
+  assert.match(out, /page_click/);
+  assert.match(out, /page_form_submit/);
+  assert.match(out, /page_scroll_/);
+  assert.match(out, /page_engaged_10s/);
+  assert.match(out, /"username":"张三"/);
+  assert.doesNotMatch(out, /user-123/);
+  assert.equal(injectMindSpaceRybbit(out, {
+    ownerId: 'user-123',
+    config: { enabled: true, siteId: '2', idSecret: 'secret' },
+  }), out);
+});
+
+test('identifies the pseudonymous owner once rybbit is ready', () => {
+  const out = injectMindSpaceRybbit('<!doctype html><html><head></head><body></body></html>', {
+    ownerId: 'user-123',
+    ownerSegment: 'plan:pro',
+    ownerLabel: '张三',
+    channel: 'h5',
+    config: {
+      enabled: true,
+      siteId: '2',
+      idSecret: 'secret',
+      scriptPath: '/rybbit/script.js',
+      hostPath: '/rybbit',
+    },
+  });
+  const inlineScript = out.match(/<script data-memind-rybbit="1">([\s\S]*?)<\/script>/)?.[1];
+  assert.ok(inlineScript);
+
+  const calls = [];
+  const timers = [];
+  vm.runInNewContext(inlineScript, {
+    window: {
+      rybbit: {
+        identify: (...args) => calls.push(['identify', ...args]),
+        event: (...args) => calls.push(['event', ...args]),
+      },
+      innerHeight: 800,
+      scrollY: 0,
+      addEventListener: () => {},
+    },
+    document: {
+      readyState: 'complete',
+      title: 'Demo',
+      documentElement: { scrollHeight: 1600 },
+      addEventListener: () => {},
+    },
+    location: { href: 'http://127.0.0.1:8081/MindSpace/demo/public/page.html' },
+    setTimeout: (fn) => { timers.push(fn); },
+  });
+
+  assert.equal(calls[0]?.[0], 'identify');
+  assert.match(String(calls[0]?.[1] ?? ''), /^[a-f0-9]{32}$/);
+  assert.equal(calls[0]?.[2]?.username, '张三');
+  assert.equal(calls[0]?.[2]?.owner_segment, 'plan:pro');
+});
diff --git a/ops/src/App.tsx b/ops/src/App.tsx
index 4909db8..becefaf 100644
--- a/ops/src/App.tsx
+++ b/ops/src/App.tsx
@@ -14,6 +14,7 @@ import { BillingPage } from './pages/admin/BillingPage';
 import { AgentCodeRunPage } from './pages/admin/AgentCodeRunPage';
 import { WechatPage } from './pages/admin/WechatPage';
 import { SystemPolicyPage } from './pages/admin/SystemPolicyPage';
+import { OrchestratorPage } from './pages/admin/OrchestratorPage';
 
 export function App() {
   return (
@@ -48,6 +49,7 @@ export function App() {
         <Route path="agent-code-run" element={<AgentCodeRunPage />} />
         <Route path="wechat" element={<WechatPage />} />
         <Route path="policy" element={<SystemPolicyPage />} />
+        <Route path="orchestrator" element={<OrchestratorPage />} />
         <Route path="*" element={<Navigate to="/admin" replace />} />
       </Route>
 
diff --git a/ops/src/api/admin.ts b/ops/src/api/admin.ts
index 303d379..004c552 100644
--- a/ops/src/api/admin.ts
+++ b/ops/src/api/admin.ts
@@ -198,6 +198,290 @@ export type SystemDisclosurePolicyState = {
   lastRefreshError?: string | null;
 };
 
+export type OrchestratorMode = 'off' | 'shadow' | 'canary' | 'active';
+
+export type OrchestratorConfig = {
+  mode: OrchestratorMode;
+  primaryEngine: string;
+  fallbackEngine: string;
+  serviceUrl: string;
+  requestTimeoutMs: number;
+  rolloutPercent: number;
+  userAllowlist: string[];
+  workflowAllowlist: string[];
+  fallbackToNative: boolean;
+  requireHealthy: boolean;
+  executionEnabled: boolean;
+};
+
+export type OrchestratorRuntime = {
+  killSwitch: boolean;
+  configured: boolean;
+  effective: boolean;
+  reason: string | null;
+  executesLangGraph: boolean;
+  plansLangGraph: boolean;
+  shadowsLangGraph: boolean;
+  executionHandoff: {
+    implemented: boolean;
+    requested: boolean;
+    enabled: boolean;
+    reason: string | null;
+    environmentGate: boolean;
+  };
+};
+
+export type OrchestratorEngineDescriptor = {
+  id: string;
+  label: string;
+  kind: string;
+  configured: boolean;
+  capabilities: string[];
+};
+
+export type OrchestratorExecutorDescriptor = {
+  id: string;
+  label: string;
+  kind: string;
+  enabled: boolean;
+  dispatchImplemented: boolean;
+  status: string;
+  capabilities: string[];
+};
+
+export type OrchestratorConfigState = {
+  config: OrchestratorConfig;
+  configVersion: number;
+  updatedBy: string | null;
+  updatedAt: number | null;
+  source: string;
+  runtime: OrchestratorRuntime;
+  engines: OrchestratorEngineDescriptor[];
+  executors: OrchestratorExecutorDescriptor[];
+};
+
+export type OrchestratorServiceHealth = {
+  checkedAt: number;
+  ok: boolean;
+  status: 'healthy' | 'unhealthy' | 'unconfigured' | 'timeout' | 'unreachable' | 'fetch_unavailable';
+  latencyMs: number;
+  httpStatus: number | null;
+  details: {
+    service: string | null;
+    checkpoint: { kind?: string; durable?: boolean } | null;
+    execution: string | null;
+    executorGateway: {
+      dispatchImplemented: boolean;
+      executionEnabled: boolean;
+      store: { kind: string | null; durable: boolean } | null;
+    } | null;
+  } | null;
+};
+
+export type OrchestratorRuntimeState = OrchestratorConfigState & {
+  serviceHealth: OrchestratorServiceHealth;
+};
+
+export type OrchestratorShadowMetrics = {
+  observations: number;
+  successes: number;
+  failures: number;
+  successRate: number | null;
+  failureRate: number | null;
+  latencyP50Ms: number | null;
+  latencyP95Ms: number | null;
+  nativeSucceeded: number;
+  nativeFailed: number;
+  lastObservedAt: number | null;
+  sampled: boolean;
+};
+
+export type OrchestratorShadowRun = {
+  eventId: string;
+  runId: string;
+  requestId: string;
+  userId: string;
+  sessionId: string | null;
+  nativeStatus: string;
+  nativeAttempts: number;
+  shadowStatus: 'succeeded' | 'failed';
+  engine: string;
+  configVersion: number | null;
+  phase: string | null;
+  taskType: string | null;
+  synthetic: boolean;
+  executorAdapter: string | null;
+  latencyMs: number | null;
+  error: { code: string; message: string } | null;
+  observedAt: number;
+  nativeCompletedAt: number | null;
+};
+
+export type OrchestratorShadowRunList = {
+  generatedAt: number;
+  window: { hours: number; from: number };
+  metrics: OrchestratorShadowMetrics;
+  runs: OrchestratorShadowRun[];
+};
+
+export type OrchestratorExecutionPlan = {
+  eventId: string;
+  runId: string;
+  requestId: string;
+  userId: string;
+  sessionId: string | null;
+  nativeStatus: string;
+  nativeAttempts: number;
+  mode: string | null;
+  candidateEngine: string;
+  effectiveEngine: string;
+  fallbackEngine: string;
+  reason: string | null;
+  candidateReason: string | null;
+  configVersion: number | null;
+  bucket: number | null;
+  taskType: string | null;
+  dryRun: boolean;
+  handoffAllowed: boolean;
+  plannedAt: number;
+  nativeCompletedAt: number | null;
+};
+
+export type OrchestratorExecutionPlanMetrics = {
+  decisions: number;
+  candidateSelections: number;
+  candidateSelectionRate: number | null;
+  nativeSelections: number;
+  nativeSucceeded: number;
+  nativeFailed: number;
+  nativeSettledRate: number | null;
+  handoffAllowed: number;
+  distinctSessions: number;
+  lastPlannedAt: number | null;
+  candidateReasons: Array<{ value: string; count: number }>;
+  taskTypes: Array<{ value: string; count: number }>;
+  sampled: boolean;
+};
+
+export type OrchestratorExecutionPlanList = {
+  generatedAt: number;
+  window: { hours: number; from: number };
+  metrics: OrchestratorExecutionPlanMetrics;
+  plans: OrchestratorExecutionPlan[];
+};
+
+export type OrchestratorCanaryReadinessCheck = {
+  id: string;
+  passed: boolean;
+  actual: string | number | boolean | null;
+  target: string | number | boolean | null;
+};
+
+export type OrchestratorCanaryReadiness = {
+  generatedAt: number;
+  ready: boolean;
+  recommendation: 'keep_shadow' | 'manual_canary_review';
+  window: { hours: number; from: number };
+  thresholds: {
+    hours: number;
+    minObservations: number;
+    minSuccessRate: number;
+    maxP95LatencyMs: number;
+    minLatencyCoverageRate: number;
+    minNativeSettledRate: number;
+    minDistinctSessions: number;
+    maxHoursSinceLastObservation: number;
+  };
+  samples: {
+    totalObservations: number;
+    eligibleObservations: number;
+    excludedSynthetic: number;
+    successes: number;
+    failures: number;
+    successRate: number | null;
+    latencyCoverageRate: number | null;
+    latencyP95Ms: number | null;
+    nativeSettledRate: number | null;
+    distinctSessions: number;
+    lastObservedAt: number | null;
+    hoursSinceLastObservation: number | null;
+    sampled: boolean;
+  };
+  service: {
+    status: string | null;
+    latencyMs: number | null;
+    checkpointKind: string | null;
+    checkpointDurable: boolean | null;
+    executorJobStoreKind: string | null;
+    executorJobStoreDurable: boolean | null;
+    execution: string | null;
+  };
+  checks: OrchestratorCanaryReadinessCheck[];
+  blockers: string[];
+  failureCodes: Array<{ code: string; count: number }>;
+};
+
+export type OrchestratorShadowRunDetail = {
+  native: {
+    runId: string;
+    requestId: string;
+    userId: string;
+    sessionId: string | null;
+    status: string;
+    attempts: number;
+    error: string | null;
+    createdAt: number;
+    updatedAt: number;
+    startedAt: number | null;
+    completedAt: number | null;
+  };
+  localEvents: Array<{
+    eventId: string;
+    type: string;
+    data: Record<string, unknown> | null;
+    createdAt: number;
+  }>;
+  remote: {
+    available: boolean;
+    state: {
+      status?: string;
+      phase?: string;
+      plan?: Record<string, unknown>;
+      result?: Record<string, unknown>;
+    } | null;
+    events: Array<{
+      sequence?: number;
+      type?: string;
+      timestamp?: number;
+      data?: Record<string, unknown> | null;
+    }>;
+    error: { code: string; message: string } | null;
+    executorJob: {
+      available: boolean;
+      state: {
+        version?: string;
+        jobId?: string;
+        executor?: string;
+        status?: string;
+        reason?: string;
+        attempts?: number;
+        createdAt?: number;
+        updatedAt?: number;
+      } | null;
+      events: Array<{
+        version?: string;
+        eventId?: string;
+        jobId?: string;
+        sequence?: number;
+        type?: string;
+        timestamp?: number;
+        data?: Record<string, unknown> | null;
+      }>;
+      error: { code: string; message: string } | null;
+    };
+  };
+};
+
 // ─── Summary ──────────────────────────────────────────────────────────────────
 
 export async function fetchAdminSummary() {
@@ -217,6 +501,63 @@ export async function updateSystemDisclosurePolicy(config: SystemDisclosurePolic
   });
 }
 
+// ─── Workflow Orchestrator ───────────────────────────────────────────────────
+
+export async function fetchOrchestratorConfig() {
+  return adminFetch<OrchestratorConfigState>('/admin-api/orchestrator/config');
+}
+
+export async function updateOrchestratorConfig(config: OrchestratorConfig) {
+  return adminFetch<OrchestratorConfigState>('/admin-api/orchestrator/config', {
+    method: 'PUT',
+    body: JSON.stringify({ config }),
+  });
+}
+
+export async function fetchOrchestratorRuntime() {
+  return adminFetch<OrchestratorRuntimeState>('/admin-api/orchestrator/runtime');
+}
+
+export async function fetchOrchestratorShadowRuns(params: {
+  hours?: number;
+  limit?: number;
+  status?: 'all' | 'succeeded' | 'failed';
+} = {}) {
+  const query = new URLSearchParams();
+  if (params.hours) query.set('hours', String(params.hours));
+  if (params.limit) query.set('limit', String(params.limit));
+  if (params.status) query.set('status', params.status);
+  return adminFetch<OrchestratorShadowRunList>(
+    `/admin-api/orchestrator/shadow-runs?${query}`,
+  );
+}
+
+export async function fetchOrchestratorExecutionPlans(params: {
+  hours?: number;
+  limit?: number;
+  selection?: 'all' | 'candidate' | 'native';
+} = {}) {
+  const query = new URLSearchParams();
+  if (params.hours) query.set('hours', String(params.hours));
+  if (params.limit) query.set('limit', String(params.limit));
+  if (params.selection) query.set('selection', params.selection);
+  return adminFetch<OrchestratorExecutionPlanList>(
+    `/admin-api/orchestrator/execution-plans?${query}`,
+  );
+}
+
+export async function fetchOrchestratorCanaryReadiness() {
+  return adminFetch<OrchestratorCanaryReadiness>(
+    '/admin-api/orchestrator/canary-readiness',
+  );
+}
+
+export async function fetchOrchestratorShadowRun(runId: string) {
+  return adminFetch<OrchestratorShadowRunDetail>(
+    `/admin-api/orchestrator/shadow-runs/${encodeURIComponent(runId)}`,
+  );
+}
+
 // ─── Users ────────────────────────────────────────────────────────────────────
 
 export async function fetchAdminUsers(params: {
diff --git a/ops/src/components/AdminLayout.tsx b/ops/src/components/AdminLayout.tsx
index 593061e..715d963 100644
--- a/ops/src/components/AdminLayout.tsx
+++ b/ops/src/components/AdminLayout.tsx
@@ -7,6 +7,7 @@ const links = [
   { to: '/admin/wechat', label: '服务号管理' },
   { to: '/admin/agent-code-run', label: 'Code Run' },
   { to: '/admin/policy', label: '策略中心' },
+  { to: '/admin/orchestrator', label: '任务编排' },
 ];
 
 export function AdminLayout() {
@@ -14,7 +15,7 @@ export function AdminLayout() {
     <div className="layout">
       <header>
         <h1>超级管理后台</h1>
-        <p style={{ color: '#68716c' }}>用户、计费与服务号</p>
+        <p style={{ color: '#68716c' }}>用户、计费、策略与任务编排</p>
       </header>
       <nav className="nav">
         <NavLink
diff --git a/ops/src/pages/admin/OrchestratorExecutionPlanPanel.tsx b/ops/src/pages/admin/OrchestratorExecutionPlanPanel.tsx
new file mode 100644
index 0000000..8117870
--- /dev/null
+++ b/ops/src/pages/admin/OrchestratorExecutionPlanPanel.tsx
@@ -0,0 +1,205 @@
+import { useEffect, useState } from 'react';
+import {
+  fetchOrchestratorExecutionPlans,
+  type OrchestratorExecutionPlanList,
+} from '../../api/admin';
+
+function formatTime(value: number | null | undefined) {
+  return value ? new Date(value).toLocaleString('zh-CN', { hour12: false }) : '—';
+}
+
+function formatPercent(value: number | null) {
+  return value == null ? '—' : `${(value * 100).toFixed(1)}%`;
+}
+
+function shortId(value: string) {
+  return value.length > 16 ? `${value.slice(0, 8)}…${value.slice(-6)}` : value;
+}
+
+const metricCardStyle = {
+  border: '1px solid #e4e9e6',
+  borderRadius: 10,
+  padding: 12,
+  minWidth: 140,
+} as const;
+
+export function OrchestratorExecutionPlanPanel() {
+  const [hours, setHours] = useState(24);
+  const [selection, setSelection] = useState<'all' | 'candidate' | 'native'>('all');
+  const [data, setData] = useState<OrchestratorExecutionPlanList | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const load = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      setData(await fetchOrchestratorExecutionPlans({
+        hours,
+        selection,
+        limit: 100,
+      }));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Dry-run 决策加载失败');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    void load();
+  }, [hours, selection]);
+
+  const metrics = data?.metrics;
+
+  return (
+    <div className="card grid">
+      <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12, flexWrap: 'wrap' }}>
+        <div>
+          <h3 style={{ margin: 0 }}>执行路由 Dry-run</h3>
+          <p style={{ margin: '4px 0 0', color: '#68716c', fontSize: 13 }}>
+            Shadow 同时模拟 Canary 候选路由；所有记录的实际执行引擎仍必须是 Native。
+          </p>
+        </div>
+        <div style={{ display: 'flex', gap: 8, alignItems: 'center' }}>
+          <select value={hours} onChange={(event) => setHours(Number(event.target.value))}>
+            <option value={1}>最近 1 小时</option>
+            <option value={24}>最近 24 小时</option>
+            <option value={168}>最近 7 天</option>
+            <option value={720}>最近 30 天</option>
+          </select>
+          <select
+            value={selection}
+            onChange={(event) => setSelection(event.target.value as typeof selection)}
+          >
+            <option value="all">全部决策</option>
+            <option value="candidate">命中 LangGraph 候选</option>
+            <option value="native">未命中，保持 Native</option>
+          </select>
+          <button type="button" className="btn secondary" onClick={() => void load()} disabled={loading}>
+            {loading ? '刷新中…' : '刷新'}
+          </button>
+        </div>
+      </div>
+
+      {error ? <p className="alert">{error}</p> : null}
+      {(metrics?.handoffAllowed ?? 0) > 0 ? (
+        <p className="alert">
+          检测到 {metrics?.handoffAllowed} 条 handoffAllowed=true 记录，请立即检查执行闸门。
+        </p>
+      ) : null}
+
+      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(140px, 1fr))', gap: 10 }}>
+        <div style={metricCardStyle}>
+          <small>路由决策</small>
+          <div style={{ fontSize: 24, marginTop: 4 }}>{metrics?.decisions ?? '—'}</div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>候选命中率</small>
+          <div style={{ fontSize: 24, marginTop: 4 }}>
+            {formatPercent(metrics?.candidateSelectionRate ?? null)}
+          </div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>LangGraph / Native 候选</small>
+          <div style={{ fontSize: 20, marginTop: 7 }}>
+            {metrics ? `${metrics.candidateSelections} / ${metrics.nativeSelections}` : '—'}
+          </div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>Native 终态覆盖率</small>
+          <div style={{ fontSize: 24, marginTop: 4 }}>
+            {formatPercent(metrics?.nativeSettledRate ?? null)}
+          </div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>Native 成功 / 失败</small>
+          <div style={{ fontSize: 20, marginTop: 7 }}>
+            {metrics ? `${metrics.nativeSucceeded} / ${metrics.nativeFailed}` : '—'}
+          </div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>真实会话</small>
+          <div style={{ fontSize: 24, marginTop: 4 }}>{metrics?.distinctSessions ?? '—'}</div>
+        </div>
+      </div>
+
+      {metrics ? (
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(280px, 1fr))', gap: 12 }}>
+          <div>
+            <strong>选择原因</strong>
+            <p style={{ margin: '6px 0 0', color: '#68716c', fontSize: 13 }}>
+              {metrics.candidateReasons.length
+                ? metrics.candidateReasons.map((item) => `${item.value} × ${item.count}`).join('，')
+                : '暂无数据'}
+            </p>
+          </div>
+          <div>
+            <strong>任务类型</strong>
+            <p style={{ margin: '6px 0 0', color: '#68716c', fontSize: 13 }}>
+              {metrics.taskTypes.length
+                ? metrics.taskTypes.map((item) => `${item.value} × ${item.count}`).join('，')
+                : '暂无数据'}
+            </p>
+          </div>
+        </div>
+      ) : null}
+
+      {metrics?.sampled ? (
+        <p className="warn">当前指标基于最近 5000 条 Dry-run 决策采样。</p>
+      ) : null}
+
+      <div style={{ overflowX: 'auto' }}>
+        <table style={{ width: '100%', borderCollapse: 'collapse', minWidth: 980 }}>
+          <thead>
+            <tr style={{ textAlign: 'left', borderBottom: '1px solid #dce4df' }}>
+              <th style={{ padding: 8 }}>时间</th>
+              <th style={{ padding: 8 }}>Run</th>
+              <th style={{ padding: 8 }}>模式</th>
+              <th style={{ padding: 8 }}>候选 → 实际</th>
+              <th style={{ padding: 8 }}>原因 / Bucket</th>
+              <th style={{ padding: 8 }}>任务类型</th>
+              <th style={{ padding: 8 }}>Native</th>
+            </tr>
+          </thead>
+          <tbody>
+            {(data?.plans ?? []).map((plan) => (
+              <tr key={plan.eventId} style={{ borderBottom: '1px solid #edf1ef' }}>
+                <td style={{ padding: 8, whiteSpace: 'nowrap' }}>{formatTime(plan.plannedAt)}</td>
+                <td style={{ padding: 8 }} title={plan.runId}>{shortId(plan.runId)}</td>
+                <td style={{ padding: 8 }}>{plan.mode ?? '—'}</td>
+                <td style={{ padding: 8 }}>
+                  <strong style={{ color: plan.candidateEngine === 'native' ? '#68716c' : '#8a5a16' }}>
+                    {plan.candidateEngine}
+                  </strong>
+                  {' → '}
+                  {plan.effectiveEngine}
+                </td>
+                <td style={{ padding: 8 }}>
+                  {plan.candidateReason ?? plan.reason ?? '—'}
+                  <small style={{ display: 'block', color: '#68716c' }}>
+                    bucket {plan.bucket ?? '—'} · config v{plan.configVersion ?? '—'}
+                  </small>
+                </td>
+                <td style={{ padding: 8 }}>{plan.taskType ?? '—'}</td>
+                <td style={{ padding: 8 }}>
+                  {plan.nativeStatus}
+                  <small style={{ display: 'block', color: '#68716c' }}>
+                    attempts {plan.nativeAttempts}
+                  </small>
+                </td>
+              </tr>
+            ))}
+            {!loading && !data?.plans.length ? (
+              <tr>
+                <td colSpan={7} style={{ padding: 16, textAlign: 'center', color: '#68716c' }}>
+                  当前时间范围内没有 Dry-run 路由决策。
+                </td>
+              </tr>
+            ) : null}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  );
+}
diff --git a/ops/src/pages/admin/OrchestratorPage.tsx b/ops/src/pages/admin/OrchestratorPage.tsx
new file mode 100644
index 0000000..56f2a79
--- /dev/null
+++ b/ops/src/pages/admin/OrchestratorPage.tsx
@@ -0,0 +1,379 @@
+import { useEffect, useMemo, useState } from 'react';
+import {
+  fetchOrchestratorConfig,
+  fetchOrchestratorRuntime,
+  updateOrchestratorConfig,
+  type OrchestratorConfig,
+  type OrchestratorConfigState,
+  type OrchestratorServiceHealth,
+} from '../../api/admin';
+import { OrchestratorExecutionPlanPanel } from './OrchestratorExecutionPlanPanel';
+import { OrchestratorShadowPanel } from './OrchestratorShadowPanel';
+
+function listToText(values: string[]) {
+  return values.join('\n');
+}
+
+function textToList(value: string) {
+  return [...new Set(value.split(/\r?\n|,/).map((item) => item.trim()).filter(Boolean))];
+}
+
+function formatTime(value?: number | null) {
+  return value ? new Date(value).toLocaleString('zh-CN', { hour12: false }) : '尚未保存';
+}
+
+const RUNTIME_REASON: Record<string, string> = {
+  mode_off: '当前为关闭模式，所有任务继续由 Native Agent Run 执行。',
+  service_url_missing: '尚未配置 Orchestrator 服务地址，LangGraph 不会接管任务。',
+  kill_switch: '环境级紧急熔断已开启，强制回退 Native。',
+  execution_gate_disabled: 'Canary / Active 仅生成 Dry-run 候选决策；执行交接闸门仍被硬锁定，Native 是唯一执行者。',
+  environment_execution_gate_disabled: 'memindadm 已请求执行交接，但环境级执行闸门仍关闭；当前继续 Dry-run。',
+};
+
+export function OrchestratorPage() {
+  const [state, setState] = useState<OrchestratorConfigState | null>(null);
+  const [draft, setDraft] = useState<OrchestratorConfig | null>(null);
+  const [userAllowlist, setUserAllowlist] = useState('');
+  const [workflowAllowlist, setWorkflowAllowlist] = useState('');
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [checking, setChecking] = useState(false);
+  const [serviceHealth, setServiceHealth] = useState<OrchestratorServiceHealth | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [notice, setNotice] = useState<string | null>(null);
+
+  const load = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await fetchOrchestratorConfig();
+      setState(result);
+      setDraft(result.config);
+      setUserAllowlist(listToText(result.config.userAllowlist));
+      setWorkflowAllowlist(listToText(result.config.workflowAllowlist));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : '加载失败');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    void load();
+  }, []);
+
+  const checkService = async () => {
+    setChecking(true);
+    setError(null);
+    try {
+      const result = await fetchOrchestratorRuntime();
+      setServiceHealth(result.serviceHealth);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : '服务检查失败');
+    } finally {
+      setChecking(false);
+    }
+  };
+
+  const normalizedDraft = useMemo(() => draft ? {
+    ...draft,
+    userAllowlist: textToList(userAllowlist),
+    workflowAllowlist: textToList(workflowAllowlist),
+  } : null, [draft, userAllowlist, workflowAllowlist]);
+
+  const dirty = Boolean(
+    state && normalizedDraft && JSON.stringify(normalizedDraft) !== JSON.stringify(state.config),
+  );
+
+  const save = async () => {
+    if (!normalizedDraft) return;
+    if (
+      ['canary', 'active'].includes(normalizedDraft.mode)
+      && !normalizedDraft.serviceUrl
+    ) {
+      setError('Canary / Active 模式必须先配置 Orchestrator 服务地址。');
+      return;
+    }
+    if (
+      normalizedDraft.executionEnabled
+      && !window.confirm('确认请求执行交接？仅当环境级闸门、服务健康、用户/工作流灰度范围同时通过时才会生效。')
+    ) {
+      return;
+    }
+    setSaving(true);
+    setError(null);
+    setNotice(null);
+    try {
+      const result = await updateOrchestratorConfig(normalizedDraft);
+      setState(result);
+      setDraft(result.config);
+      setUserAllowlist(listToText(result.config.userAllowlist));
+      setWorkflowAllowlist(listToText(result.config.workflowAllowlist));
+      setNotice(`Orchestrator 配置 v${result.configVersion} 已保存。`);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : '保存失败');
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  if (loading) return <p>加载中…</p>;
+  if (!state || !draft) return <p className="alert">{error ?? 'Orchestrator 配置不可用'}</p>;
+
+  const runtimeMessage = state.runtime.reason
+    ? (RUNTIME_REASON[state.runtime.reason] ?? state.runtime.reason)
+    : state.runtime.shadowsLangGraph
+      ? 'Shadow 已生效：Native 继续执行，LangGraph 只观察和生成决策。'
+      : state.runtime.executesLangGraph
+        ? '执行交接已开启。'
+        : '配置有效。';
+
+  return (
+    <div className="grid">
+      <div className="card">
+        <h2 style={{ marginTop: 0 }}>Workflow Orchestrator</h2>
+        <p style={{ color: '#68716c', marginBottom: 0 }}>
+          LangGraph 通过通用 WorkflowEngine 协议接入。关闭和 Shadow 模式不会改变现有 Native Agent Run 执行路径。
+        </p>
+      </div>
+
+      {error ? <p className="alert">{error}</p> : null}
+      {notice ? <p style={{ color: '#2f6f57', fontSize: 13 }}>{notice}</p> : null}
+
+      <div className="card grid">
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(180px, 1fr))', gap: 12 }}>
+          <div>
+            <strong>配置版本</strong>
+            <p style={{ marginBottom: 0 }}>v{state.configVersion}</p>
+          </div>
+          <div>
+            <strong>运行状态</strong>
+            <p style={{ marginBottom: 0 }}>{state.runtime.effective ? '有效' : '安全回退'}</p>
+          </div>
+          <div>
+            <strong>配置来源</strong>
+            <p style={{ marginBottom: 0 }}>{state.source}</p>
+          </div>
+          <div>
+            <strong>更新时间</strong>
+            <p style={{ marginBottom: 0 }}>{formatTime(state.updatedAt)}</p>
+          </div>
+          <div>
+            <strong>执行交接</strong>
+            <p style={{ marginBottom: 0 }}>
+              {state.runtime.executionHandoff.enabled ? '已开启' : 'Dry-run 锁定'}
+            </p>
+          </div>
+        </div>
+        <p className={state.runtime.reason === 'kill_switch' ? 'alert' : 'warn'} style={{ marginBottom: 0 }}>
+          {runtimeMessage}
+        </p>
+      </div>
+
+      <div className="card grid">
+        <div>
+          <h3 style={{ margin: 0 }}>Executor Gateway</h3>
+          <p style={{ margin: '4px 0 0', color: '#68716c', fontSize: 13 }}>
+            Worker Queue 已支持租约、心跳、重试、取消和产物引用。执行器默认关闭，实际启用状态以服务健康检查为准。
+          </p>
+        </div>
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: 10 }}>
+          {(state.executors ?? []).map((executor) => (
+            <div
+              key={executor.id}
+              style={{ border: '1px solid #e4e9e6', borderRadius: 10, padding: 12 }}
+            >
+              <div style={{ display: 'flex', justifyContent: 'space-between', gap: 8 }}>
+                <strong>{executor.label}</strong>
+                <span style={{ color: executor.enabled ? '#2f6f57' : '#8a5a16', fontSize: 13 }}>
+                  {executor.status}
+                </span>
+              </div>
+              <p style={{ margin: '8px 0 0', color: '#68716c', fontSize: 13 }}>
+                {executor.capabilities.join(' · ') || '无能力声明'}
+              </p>
+              <small style={{ display: 'block', marginTop: 8 }}>
+                dispatch {executor.dispatchImplemented ? 'implemented' : 'disabled'}
+              </small>
+            </div>
+          ))}
+        </div>
+      </div>
+
+      <OrchestratorShadowPanel />
+
+      <OrchestratorExecutionPlanPanel />
+
+      <div className="card grid">
+        <h3 style={{ margin: 0 }}>路由模式</h3>
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: 16 }}>
+          <label>
+            <strong>运行模式</strong>
+            <select
+              value={draft.mode}
+              onChange={(event) => setDraft({
+                ...draft,
+                mode: event.target.value as OrchestratorConfig['mode'],
+              })}
+              style={{ marginTop: 8 }}
+            >
+              <option value="off">Off — Native only</option>
+              <option value="shadow">Shadow — Native 执行，LangGraph 观察</option>
+              <option value="canary">Canary — 白名单/百分比灰度</option>
+              <option value="active">Active — 工作流白名单接管</option>
+            </select>
+          </label>
+          <label>
+            <strong>主执行引擎</strong>
+            <select
+              value={draft.primaryEngine}
+              onChange={(event) => setDraft({ ...draft, primaryEngine: event.target.value })}
+              style={{ marginTop: 8 }}
+            >
+              {state.engines.map((engine) => (
+                <option key={engine.id} value={engine.id}>
+                  {engine.label}{engine.configured ? '' : '（未配置）'}
+                </option>
+              ))}
+            </select>
+          </label>
+          <label>
+            <strong>灰度百分比</strong>
+            <input
+              type="number"
+              min={0}
+              max={100}
+              value={draft.rolloutPercent}
+              onChange={(event) => setDraft({
+                ...draft,
+                rolloutPercent: Number(event.target.value),
+              })}
+              style={{ marginTop: 8 }}
+            />
+          </label>
+        </div>
+      </div>
+
+      <div className="card grid">
+        <h3 style={{ margin: 0 }}>服务连接</h3>
+        <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12 }}>
+          <span>
+            <strong>实时健康状态：</strong>
+            {serviceHealth
+              ? `${serviceHealth.ok ? '健康' : '不可用'}（${serviceHealth.status}，${serviceHealth.latencyMs} ms）`
+              : '尚未检查'}
+            {serviceHealth?.details?.checkpoint
+              ? ` · checkpoint ${serviceHealth.details.checkpoint.kind ?? 'unknown'}`
+              : ''}
+            {serviceHealth?.details?.executorGateway?.store
+              ? ` · executor jobs ${serviceHealth.details.executorGateway.store.kind ?? 'unknown'}`
+              : ''}
+          </span>
+          <button
+            type="button"
+            className="btn secondary"
+            onClick={() => void checkService()}
+            disabled={checking}
+          >
+            {checking ? '检查中…' : '测试连接'}
+          </button>
+        </div>
+        <label>
+          <strong>Orchestrator URL</strong>
+          <input
+            value={draft.serviceUrl}
+            placeholder="http://127.0.0.1:8093"
+            onChange={(event) => setDraft({ ...draft, serviceUrl: event.target.value })}
+            style={{ marginTop: 8 }}
+          />
+        </label>
+        <label>
+          <strong>请求超时（毫秒）</strong>
+          <input
+            type="number"
+            min={500}
+            max={60000}
+            value={draft.requestTimeoutMs}
+            onChange={(event) => setDraft({
+              ...draft,
+              requestTimeoutMs: Number(event.target.value),
+            })}
+            style={{ marginTop: 8 }}
+          />
+        </label>
+        <label style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+          <input
+            type="checkbox"
+            checked={draft.requireHealthy}
+            onChange={(event) => setDraft({ ...draft, requireHealthy: event.target.checked })}
+            style={{ width: 'auto' }}
+          />
+          接管任务前要求 Orchestrator 健康
+        </label>
+        <label style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+          <input
+            type="checkbox"
+            checked={draft.fallbackToNative}
+            onChange={(event) => setDraft({ ...draft, fallbackToNative: event.target.checked })}
+            style={{ width: 'auto' }}
+          />
+          Orchestrator 不可用时回退 Native
+        </label>
+        <label style={{
+          display: 'flex',
+          alignItems: 'center',
+          gap: 8,
+          border: '1px solid #e6c98f',
+          borderRadius: 8,
+          padding: 10,
+          background: '#fff9ed',
+        }}>
+          <input
+            type="checkbox"
+            checked={draft.executionEnabled}
+            onChange={(event) => setDraft({ ...draft, executionEnabled: event.target.checked })}
+            style={{ width: 'auto' }}
+          />
+          请求启用 LangGraph 执行交接（仍受环境闸门、Kill Switch、健康检查和灰度范围约束）
+        </label>
+      </div>
+
+      <div className="card grid">
+        <h3 style={{ margin: 0 }}>灰度范围</h3>
+        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 16 }}>
+          <label>
+            <strong>工作流白名单</strong>
+            <span style={{ display: 'block', color: '#68716c', fontSize: 12, margin: '4px 0 8px' }}>
+              每行一个。未来启用 Active 时也只接管这里列出的工作流。
+            </span>
+            <textarea
+              rows={8}
+              value={workflowAllowlist}
+              onChange={(event) => setWorkflowAllowlist(event.target.value)}
+            />
+          </label>
+          <label>
+            <strong>用户白名单</strong>
+            <span style={{ display: 'block', color: '#68716c', fontSize: 12, margin: '4px 0 8px' }}>
+              每行一个用户 ID；Canary 下优先于百分比。
+            </span>
+            <textarea
+              rows={8}
+              value={userAllowlist}
+              onChange={(event) => setUserAllowlist(event.target.value)}
+            />
+          </label>
+        </div>
+      </div>
+
+      <div style={{ display: 'flex', justifyContent: 'flex-end', gap: 8 }}>
+        <button type="button" className="btn secondary" onClick={() => void load()} disabled={saving}>
+          放弃修改
+        </button>
+        <button type="button" className="btn" onClick={() => void save()} disabled={saving || !dirty}>
+          {saving ? '保存中…' : '保存配置'}
+        </button>
+      </div>
+    </div>
+  );
+}
diff --git a/ops/src/pages/admin/OrchestratorShadowPanel.tsx b/ops/src/pages/admin/OrchestratorShadowPanel.tsx
new file mode 100644
index 0000000..4a9c5ea
--- /dev/null
+++ b/ops/src/pages/admin/OrchestratorShadowPanel.tsx
@@ -0,0 +1,355 @@
+import { useEffect, useState } from 'react';
+import {
+  fetchOrchestratorCanaryReadiness,
+  fetchOrchestratorShadowRun,
+  fetchOrchestratorShadowRuns,
+  type OrchestratorCanaryReadiness,
+  type OrchestratorCanaryReadinessCheck,
+  type OrchestratorShadowRunDetail,
+  type OrchestratorShadowRunList,
+} from '../../api/admin';
+
+function formatTime(value: number | null | undefined) {
+  return value ? new Date(value).toLocaleString('zh-CN', { hour12: false }) : '—';
+}
+
+function formatPercent(value: number | null) {
+  return value == null ? '—' : `${(value * 100).toFixed(1)}%`;
+}
+
+function formatLatency(value: number | null) {
+  return value == null ? '—' : `${value} ms`;
+}
+
+function shortId(value: string) {
+  return value.length > 16 ? `${value.slice(0, 8)}…${value.slice(-6)}` : value;
+}
+
+const readinessCheckLabels: Record<string, string> = {
+  shadow_mode: '当前保持 Shadow',
+  service_healthy: '服务健康',
+  durable_checkpoint: '持久化 checkpoint',
+  durable_executor_job_store: '持久化 Executor Job Store',
+  observe_only: '仅观察不执行',
+  sample_volume: '有效样本量',
+  shadow_success_rate: 'Shadow 成功率',
+  latency_coverage: '延迟数据覆盖率',
+  latency_p95: '延迟 P95',
+  native_settled_rate: 'Native 终态覆盖率',
+  session_coverage: '真实会话覆盖',
+  sample_freshness: '最近样本新鲜度',
+  complete_window: '统计窗口完整',
+};
+
+function formatReadinessValue(check: OrchestratorCanaryReadinessCheck) {
+  const value = check.actual;
+  if (value == null) return '无数据';
+  if (['shadow_success_rate', 'latency_coverage', 'native_settled_rate'].includes(check.id)) {
+    return formatPercent(Number(value));
+  }
+  if (check.id === 'latency_p95') return formatLatency(Number(value));
+  if (check.id === 'sample_freshness') return `${Number(value).toFixed(1)} 小时`;
+  if (typeof value === 'boolean') return value ? '是' : '否';
+  return String(value);
+}
+
+function formatReadinessTarget(check: OrchestratorCanaryReadinessCheck) {
+  const target = check.target;
+  if (target == null) return '';
+  if (['shadow_success_rate', 'latency_coverage', 'native_settled_rate'].includes(check.id)) {
+    return `≥ ${formatPercent(Number(target))}`;
+  }
+  if (check.id === 'latency_p95') return `≤ ${formatLatency(Number(target))}`;
+  if (check.id === 'sample_freshness') return `≤ ${target} 小时`;
+  if (['sample_volume', 'session_coverage'].includes(check.id)) return `≥ ${target}`;
+  if (typeof target === 'boolean') return target ? '= 是' : '= 否';
+  return `= ${target}`;
+}
+
+const metricCardStyle = {
+  border: '1px solid #e4e9e6',
+  borderRadius: 10,
+  padding: 12,
+  minWidth: 140,
+} as const;
+
+export function OrchestratorShadowPanel() {
+  const [hours, setHours] = useState(24);
+  const [status, setStatus] = useState<'all' | 'succeeded' | 'failed'>('all');
+  const [data, setData] = useState<OrchestratorShadowRunList | null>(null);
+  const [readiness, setReadiness] = useState<OrchestratorCanaryReadiness | null>(null);
+  const [selected, setSelected] = useState<OrchestratorShadowRunDetail | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [detailLoading, setDetailLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const load = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const [runs, canaryReadiness] = await Promise.all([
+        fetchOrchestratorShadowRuns({ hours, status, limit: 100 }),
+        fetchOrchestratorCanaryReadiness(),
+      ]);
+      setData(runs);
+      setReadiness(canaryReadiness);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Shadow 指标加载失败');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    void load();
+  }, [hours, status]);
+
+  const openDetail = async (runId: string) => {
+    setDetailLoading(true);
+    setError(null);
+    try {
+      setSelected(await fetchOrchestratorShadowRun(runId));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Shadow run 详情加载失败');
+    } finally {
+      setDetailLoading(false);
+    }
+  };
+
+  const metrics = data?.metrics;
+
+  return (
+    <div className="card grid">
+      <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12, flexWrap: 'wrap' }}>
+        <div>
+          <h3 style={{ margin: 0 }}>Shadow 运行观测</h3>
+          <p style={{ margin: '4px 0 0', color: '#68716c', fontSize: 13 }}>
+            Native 执行结果与 LangGraph 观察结果并排展示，不改变任务执行权。
+          </p>
+        </div>
+        <div style={{ display: 'flex', gap: 8, alignItems: 'center' }}>
+          <select value={hours} onChange={(event) => setHours(Number(event.target.value))}>
+            <option value={1}>最近 1 小时</option>
+            <option value={24}>最近 24 小时</option>
+            <option value={168}>最近 7 天</option>
+            <option value={720}>最近 30 天</option>
+          </select>
+          <select
+            value={status}
+            onChange={(event) => setStatus(event.target.value as typeof status)}
+          >
+            <option value="all">全部结果</option>
+            <option value="succeeded">仅成功</option>
+            <option value="failed">仅失败</option>
+          </select>
+          <button type="button" className="btn secondary" onClick={() => void load()} disabled={loading}>
+            {loading ? '刷新中…' : '刷新'}
+          </button>
+        </div>
+      </div>
+
+      {error ? <p className="alert">{error}</p> : null}
+
+      {readiness ? (
+        <div
+          style={{
+            border: `1px solid ${readiness.ready ? '#8bbda8' : '#e6c98f'}`,
+            background: readiness.ready ? '#f1f8f4' : '#fff9ed',
+            borderRadius: 10,
+            padding: 14,
+          }}
+        >
+          <div style={{ display: 'flex', justifyContent: 'space-between', gap: 12, flexWrap: 'wrap' }}>
+            <div>
+              <h4 style={{ margin: 0 }}>Canary 准入评估</h4>
+              <p style={{ margin: '5px 0 0', color: '#68716c', fontSize: 13 }}>
+                固定 7 天窗口；smoke 样本不计入准入，不会自动切换运行模式。
+              </p>
+            </div>
+            <strong style={{ color: readiness.ready ? '#2f6f57' : '#8a5a16' }}>
+              {readiness.ready ? '已达到门槛，等待人工审批' : '继续保持 Shadow'}
+            </strong>
+          </div>
+          <p style={{ margin: '10px 0' }}>
+            有效样本 {readiness.samples.eligibleObservations} / {readiness.thresholds.minObservations}
+            {' · '}
+            已排除 smoke {readiness.samples.excludedSynthetic}
+            {' · '}
+            真实会话 {readiness.samples.distinctSessions} / {readiness.thresholds.minDistinctSessions}
+          </p>
+          <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(210px, 1fr))', gap: 6 }}>
+            {readiness.checks.map((check) => (
+              <div key={check.id} style={{ fontSize: 13, color: check.passed ? '#2f6f57' : '#8a5a16' }}>
+                {check.passed ? '通过' : '阻塞'} · {readinessCheckLabels[check.id] ?? check.id}
+                ：{formatReadinessValue(check)}（目标 {formatReadinessTarget(check)}）
+              </div>
+            ))}
+          </div>
+          {readiness.failureCodes.length ? (
+            <p style={{ margin: '10px 0 0', fontSize: 13 }}>
+              主要失败：{readiness.failureCodes.map((item) => `${item.code} × ${item.count}`).join('，')}
+            </p>
+          ) : null}
+        </div>
+      ) : null}
+
+      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(140px, 1fr))', gap: 10 }}>
+        <div style={metricCardStyle}>
+          <small>观察请求</small>
+          <div style={{ fontSize: 24, marginTop: 4 }}>{metrics?.observations ?? '—'}</div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>Shadow 成功率</small>
+          <div style={{ fontSize: 24, marginTop: 4 }}>{formatPercent(metrics?.successRate ?? null)}</div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>失败数</small>
+          <div style={{ fontSize: 24, marginTop: 4 }}>{metrics?.failures ?? '—'}</div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>延迟 P50</small>
+          <div style={{ fontSize: 24, marginTop: 4 }}>{formatLatency(metrics?.latencyP50Ms ?? null)}</div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>延迟 P95</small>
+          <div style={{ fontSize: 24, marginTop: 4 }}>{formatLatency(metrics?.latencyP95Ms ?? null)}</div>
+        </div>
+        <div style={metricCardStyle}>
+          <small>Native 成功 / 失败</small>
+          <div style={{ fontSize: 20, marginTop: 7 }}>
+            {metrics ? `${metrics.nativeSucceeded} / ${metrics.nativeFailed}` : '—'}
+          </div>
+        </div>
+      </div>
+
+      {metrics?.sampled ? (
+        <p className="warn">当前指标基于最近 5000 条 Shadow 结果采样。</p>
+      ) : null}
+
+      <div style={{ overflowX: 'auto' }}>
+        <table style={{ width: '100%', borderCollapse: 'collapse', minWidth: 900 }}>
+          <thead>
+            <tr style={{ textAlign: 'left', borderBottom: '1px solid #dce4df' }}>
+              <th style={{ padding: 8 }}>时间</th>
+              <th style={{ padding: 8 }}>Run</th>
+              <th style={{ padding: 8 }}>Shadow</th>
+              <th style={{ padding: 8 }}>Native</th>
+              <th style={{ padding: 8 }}>延迟</th>
+              <th style={{ padding: 8 }}>任务 / Adapter</th>
+              <th style={{ padding: 8 }}>错误</th>
+            </tr>
+          </thead>
+          <tbody>
+            {(data?.runs ?? []).map((run) => (
+              <tr key={run.eventId} style={{ borderBottom: '1px solid #edf1ef' }}>
+                <td style={{ padding: 8, whiteSpace: 'nowrap' }}>{formatTime(run.observedAt)}</td>
+                <td style={{ padding: 8 }}>
+                  <button
+                    type="button"
+                    className="btn secondary"
+                    title={run.runId}
+                    onClick={() => void openDetail(run.runId)}
+                    disabled={detailLoading}
+                  >
+                    {shortId(run.runId)}
+                  </button>
+                </td>
+                <td style={{ padding: 8, color: run.shadowStatus === 'succeeded' ? '#2f6f57' : '#a23a32' }}>
+                  {run.shadowStatus}
+                </td>
+                <td style={{ padding: 8 }}>{run.nativeStatus}</td>
+                <td style={{ padding: 8 }}>{formatLatency(run.latencyMs)}</td>
+                <td style={{ padding: 8 }}>
+                  {run.taskType ?? '—'}
+                  {run.synthetic ? '（smoke）' : ''}
+                  <small style={{ display: 'block', color: '#68716c' }}>
+                    {run.executorAdapter ?? '—'}
+                  </small>
+                </td>
+                <td style={{ padding: 8, maxWidth: 260 }}>
+                  {run.error ? `${run.error.code}: ${run.error.message}` : '—'}
+                </td>
+              </tr>
+            ))}
+            {!loading && !data?.runs.length ? (
+              <tr>
+                <td colSpan={7} style={{ padding: 16, textAlign: 'center', color: '#68716c' }}>
+                  当前时间范围内没有 Shadow 结果。
+                </td>
+              </tr>
+            ) : null}
+          </tbody>
+        </table>
+      </div>
+
+      {selected ? (
+        <div style={{ borderTop: '1px solid #dce4df', paddingTop: 16 }}>
+          <div style={{ display: 'flex', justifyContent: 'space-between', gap: 12 }}>
+            <div>
+              <h4 style={{ margin: 0 }}>Run 详情：{selected.native.runId}</h4>
+              <p style={{ margin: '6px 0', color: '#68716c' }}>
+                Native {selected.native.status} · attempts {selected.native.attempts}
+                {' · '}
+                LangGraph {selected.remote.available ? (selected.remote.state?.status ?? 'available') : 'unavailable'}
+              </p>
+            </div>
+            <button type="button" className="btn secondary" onClick={() => setSelected(null)}>
+              关闭
+            </button>
+          </div>
+          {selected.remote.error ? (
+            <p className="alert">
+              {selected.remote.error.code}: {selected.remote.error.message}
+            </p>
+          ) : null}
+          {selected.remote.executorJob.error ? (
+            <p className="alert">
+              Executor Job：{selected.remote.executorJob.error.code}
+              {' '}
+              {selected.remote.executorJob.error.message}
+            </p>
+          ) : null}
+          <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(300px, 1fr))', gap: 12 }}>
+            <div>
+              <strong>LangGraph checkpoint</strong>
+              <pre style={{ whiteSpace: 'pre-wrap', overflowWrap: 'anywhere', fontSize: 12 }}>
+                {JSON.stringify(selected.remote.state, null, 2)}
+              </pre>
+            </div>
+            <div>
+              <strong>LangGraph 节点事件</strong>
+              <pre style={{ whiteSpace: 'pre-wrap', overflowWrap: 'anywhere', fontSize: 12 }}>
+                {JSON.stringify(selected.remote.events, null, 2)}
+              </pre>
+            </div>
+          </div>
+          {selected.remote.executorJob.available ? (
+            <div
+              style={{
+                borderTop: '1px solid #edf1ef',
+                marginTop: 12,
+                paddingTop: 12,
+                display: 'grid',
+                gridTemplateColumns: 'repeat(auto-fit, minmax(300px, 1fr))',
+                gap: 12,
+              }}
+            >
+              <div>
+                <strong>Executor Job 状态</strong>
+                <pre style={{ whiteSpace: 'pre-wrap', overflowWrap: 'anywhere', fontSize: 12 }}>
+                  {JSON.stringify(selected.remote.executorJob.state, null, 2)}
+                </pre>
+              </div>
+              <div>
+                <strong>Executor Job 事件</strong>
+                <pre style={{ whiteSpace: 'pre-wrap', overflowWrap: 'anywhere', fontSize: 12 }}>
+                  {JSON.stringify(selected.remote.executorJob.events, null, 2)}
+                </pre>
+              </div>
+            </div>
+          ) : null}
+        </div>
+      ) : null}
+    </div>
+  );
+}
diff --git a/package-lock.json b/package-lock.json
index 59b1c2f..682d4b0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,6 +8,9 @@
       "name": "tkmind-h5",
       "version": "0.1.0",
       "dependencies": {
+        "@langchain/core": "^1.2.3",
+        "@langchain/langgraph": "^1.4.8",
+        "@langchain/langgraph-checkpoint-postgres": "^1.0.4",
         "@node-rs/argon2": "^2.0.2",
         "@resvg/resvg-js": "^2.6.2",
         "debug": "^4.4.3",
@@ -320,6 +323,12 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@cfworker/json-schema": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/@cfworker/json-schema/-/json-schema-4.1.1.tgz",
+      "integrity": "sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og==",
+      "license": "MIT"
+    },
     "node_modules/@emnapi/core": {
       "version": "1.11.1",
       "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.1.tgz",
@@ -1432,6 +1441,144 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@langchain/core": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@langchain/core/-/core-1.2.3.tgz",
+      "integrity": "sha512-F+L5SsciykwDl7eDxacnhDTcWe1IF6jetzfkvI5PPfq6ogWHO7xcjU90SGh/3lqbbS0tgun+qF01KIqxawrCsA==",
+      "license": "MIT",
+      "dependencies": {
+        "@cfworker/json-schema": "^4.0.2",
+        "@standard-schema/spec": "^1.1.0",
+        "js-tiktoken": "^1.0.12",
+        "langsmith": ">=0.5.0 <1.0.0",
+        "mustache": "^4.2.0",
+        "p-queue": "^6.6.2",
+        "zod": "^3.25.76 || ^4"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@langchain/langgraph": {
+      "version": "1.4.8",
+      "resolved": "https://registry.npmjs.org/@langchain/langgraph/-/langgraph-1.4.8.tgz",
+      "integrity": "sha512-DN1Np1XefdBEbp1qBKlt39cwoL743AAGpR5Ipja0gY2YbWvsoQnOTIrjnj/orSAhaUYsdTKS8VSWdFzsHZo6Ig==",
+      "license": "MIT",
+      "dependencies": {
+        "@langchain/langgraph-checkpoint": "^1.1.3",
+        "@langchain/langgraph-sdk": "~1.9.26",
+        "@langchain/protocol": "^0.0.18",
+        "@standard-schema/spec": "1.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@langchain/core": "^1.1.48",
+        "zod": "^3.25.32 || ^4.2.0"
+      }
+    },
+    "node_modules/@langchain/langgraph-checkpoint": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@langchain/langgraph-checkpoint/-/langgraph-checkpoint-1.1.3.tgz",
+      "integrity": "sha512-wgzdQNeEsdw1e+4lvlj0tdq/RYR/k1vPin10g0ymGoehZDDgd9nvIllGXSXN4TFgF9sf5qQP/KTkOcLfeseIhA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@langchain/core": "^1.1.48"
+      }
+    },
+    "node_modules/@langchain/langgraph-checkpoint-postgres": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@langchain/langgraph-checkpoint-postgres/-/langgraph-checkpoint-postgres-1.0.4.tgz",
+      "integrity": "sha512-wuCPq7VVqwi0+nQC5GOmheoXGJHAybgXbkA9Nn0J8nYW61WFJ3uqb4wyMbLFhAlya99EaxNNsi3FzdzV2COSzw==",
+      "license": "MIT",
+      "dependencies": {
+        "pg": "^8.12.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@langchain/core": "^1.1.44",
+        "@langchain/langgraph-checkpoint": "^1.0.0"
+      }
+    },
+    "node_modules/@langchain/langgraph-sdk": {
+      "version": "1.9.28",
+      "resolved": "https://registry.npmjs.org/@langchain/langgraph-sdk/-/langgraph-sdk-1.9.28.tgz",
+      "integrity": "sha512-4j3XuM0PvtmAbL8mPfBS99ez3+ytRfgbOpAR/nOeaejTRF3Q9dNw2QnaGLGng8wLPtGLoSj+SYgUOVxy9Bv9vg==",
+      "license": "MIT",
+      "dependencies": {
+        "@langchain/protocol": "^0.0.18",
+        "@types/json-schema": "^7.0.15",
+        "p-queue": "^9.0.1",
+        "p-retry": "^7.1.1"
+      },
+      "peerDependencies": {
+        "@langchain/core": "^1.1.48",
+        "react": "^18 || ^19",
+        "react-dom": "^18 || ^19",
+        "svelte": "^4.0.0 || ^5.0.0",
+        "vue": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "react": {
+          "optional": true
+        },
+        "react-dom": {
+          "optional": true
+        },
+        "svelte": {
+          "optional": true
+        },
+        "vue": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@langchain/langgraph-sdk/node_modules/eventemitter3": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz",
+      "integrity": "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==",
+      "license": "MIT"
+    },
+    "node_modules/@langchain/langgraph-sdk/node_modules/p-queue": {
+      "version": "9.3.3",
+      "resolved": "https://registry.npmjs.org/p-queue/-/p-queue-9.3.3.tgz",
+      "integrity": "sha512-NXAOdnEe5FsZJfT4oK84lE1Y5cFFdWlRuOo5tww8DyNMxyRXwn39fIkUtNLKppcPC+UYU/bXujNCUGDv01y7CA==",
+      "license": "MIT",
+      "dependencies": {
+        "eventemitter3": "^5.0.4",
+        "p-timeout": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@langchain/langgraph-sdk/node_modules/p-timeout": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-7.0.1.tgz",
+      "integrity": "sha512-AxTM2wDGORHGEkPCt8yqxOTMgpfbEHqF51f/5fJCmwFC3C/zNcGT63SymH2ttOAaiIws2zVg4+izQCjrakcwHg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@langchain/protocol": {
+      "version": "0.0.18",
+      "resolved": "https://registry.npmjs.org/@langchain/protocol/-/protocol-0.0.18.tgz",
+      "integrity": "sha512-XW1egQtPfsGI41w2AMZNFZrUIwFSQHTjVMZs0OaTpCAvht/QLoaPN8FQcsysMVypOhupG28J29yOorrc70otBQ==",
+      "license": "MIT"
+    },
     "node_modules/@napi-rs/wasm-runtime": {
       "version": "0.2.12",
       "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
@@ -2330,6 +2477,12 @@
         "win32"
       ]
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "license": "MIT"
+    },
     "node_modules/@tybys/wasm-util": {
       "version": "0.10.2",
       "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.2.tgz",
@@ -2401,6 +2554,12 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "license": "MIT"
+    },
     "node_modules/@types/node": {
       "version": "25.9.2",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-25.9.2.tgz",
@@ -3902,6 +4061,18 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-network-error": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/is-network-error/-/is-network-error-1.3.2.tgz",
+      "integrity": "sha512-PhBY86zaxNZUuWP6h13Vu5oFe0XY6/UlKzQnYFELzGVHygP3MxmvTfYSG7GN3aIab/iWudSMgjSnG9Dq+nHrgA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/is-number": {
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
@@ -3932,6 +4103,15 @@
       "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
       "license": "MIT"
     },
+    "node_modules/js-tiktoken": {
+      "version": "1.0.21",
+      "resolved": "https://registry.npmjs.org/js-tiktoken/-/js-tiktoken-1.0.21.tgz",
+      "integrity": "sha512-biOj/6M5qdgx5TKjDnFT1ymSpM5tbd3ylwDtrQvFQSu0Z7bBYko2dF+W/aUkXUPuk6IVpRxk/3Q2sHOzGlS36g==",
+      "license": "MIT",
+      "dependencies": {
+        "base64-js": "^1.5.1"
+      }
+    },
     "node_modules/js-tokens": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@@ -4016,6 +4196,39 @@
         "safe-buffer": "~5.1.0"
       }
     },
+    "node_modules/langsmith": {
+      "version": "0.8.6",
+      "resolved": "https://registry.npmjs.org/langsmith/-/langsmith-0.8.6.tgz",
+      "integrity": "sha512-tl7cV79S/SkJNskCo7joRIVCYy+ljVLs4L1hgC2qT01x4CAWX+6IJzmfXGYAJcn1ecpaQr63WRjkLO9jefmOmQ==",
+      "license": "MIT",
+      "dependencies": {
+        "p-queue": "6.6.2"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "*",
+        "@opentelemetry/exporter-trace-otlp-proto": "*",
+        "@opentelemetry/sdk-trace-base": "*",
+        "openai": "*",
+        "ws": ">=7"
+      },
+      "peerDependenciesMeta": {
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@opentelemetry/exporter-trace-otlp-proto": {
+          "optional": true
+        },
+        "@opentelemetry/sdk-trace-base": {
+          "optional": true
+        },
+        "openai": {
+          "optional": true
+        },
+        "ws": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/lazystream": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz",
@@ -4340,6 +4553,15 @@
       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "license": "MIT"
     },
+    "node_modules/mustache": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/mustache/-/mustache-4.2.0.tgz",
+      "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==",
+      "license": "MIT",
+      "bin": {
+        "mustache": "bin/mustache"
+      }
+    },
     "node_modules/mysql2": {
       "version": "3.22.5",
       "resolved": "https://registry.npmjs.org/mysql2/-/mysql2-3.22.5.tgz",
@@ -4470,6 +4692,15 @@
         "wrappy": "1"
       }
     },
+    "node_modules/p-finally": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz",
+      "integrity": "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/p-limit": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
@@ -4497,6 +4728,49 @@
         "node": ">=8"
       }
     },
+    "node_modules/p-queue": {
+      "version": "6.6.2",
+      "resolved": "https://registry.npmjs.org/p-queue/-/p-queue-6.6.2.tgz",
+      "integrity": "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==",
+      "license": "MIT",
+      "dependencies": {
+        "eventemitter3": "^4.0.4",
+        "p-timeout": "^3.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-retry": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/p-retry/-/p-retry-7.1.1.tgz",
+      "integrity": "sha512-J5ApzjyRkkf601HpEeykoiCvzHQjWxPAHhyjFcEUP2SWq0+35NKh8TLhpLw+Dkq5TZBFvUM6UigdE9hIVYTl5w==",
+      "license": "MIT",
+      "dependencies": {
+        "is-network-error": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-timeout": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-3.2.0.tgz",
+      "integrity": "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==",
+      "license": "MIT",
+      "dependencies": {
+        "p-finally": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/p-try": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
@@ -5833,7 +6107,7 @@
       "version": "8.21.0",
       "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
       "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
-      "dev": true,
+      "devOptional": true,
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
@@ -5948,6 +6222,15 @@
       "engines": {
         "node": ">= 10"
       }
+    },
+    "node_modules/zod": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
     }
   }
 }
diff --git a/package.json b/package.json
index a3f22cb..ed02dc4 100644
--- a/package.json
+++ b/package.json
@@ -24,6 +24,7 @@
     "dev:server": "node server.mjs",
     "dev:adm": "node admin-server.mjs",
     "dev:deep-search": "node deep-search-server.mjs",
+    "dev:orchestrator": "node services/orchestrator/server.mjs",
     "dev:plaza-express": "node plaza-server.mjs",
     "dev:ops": "cd ops && npm run dev",
     "launch:executor": "node scripts/launch-executor.mjs",
@@ -64,7 +65,7 @@
     "ci:page-data-dev-loop-smoke": "node scripts/ci-page-data-dev-loop-smoke.mjs",
     "migrate:agent-code-run-config": "node scripts/migrate-agent-code-run-config-from-env.mjs",
     "test:scenario:john4-diet": "node scripts/run-scenario-test.mjs --scenario john4-children-hobby-diet-update",
-    "test": "node --test auth.test.mjs asr-proxy.test.mjs billing.test.mjs billing-token-state.test.mjs billing-recharge.test.mjs wechat-pay.test.mjs wechat-oauth.test.mjs wechat-mp.test.mjs wechat-media.test.mjs wechat/image-generation-policy.test.mjs wechat/verify/generated-thumbnail.test.mjs schedule-intent.test.mjs schedule-reminder-worker.test.mjs capabilities.test.mjs policies.test.mjs server/portal-api-auth-middleware.test.mjs server/portal-config-routes.test.mjs server/portal-plaza-discovery-routes.test.mjs server/portal-runtime-routes.test.mjs chat-skills.test.mjs chat-intent-router.test.mjs chat-finish-sync.test.mjs chat-agent-run-gate.test.mjs conversation-display.test.mjs user-publish.test.mjs user-memory-profile.test.mjs skills-registry.test.mjs skill-runtime-policy.test.mjs excel-analyst.test.mjs agent-run-gateway.test.mjs agent-run-routes.test.mjs session-broker.test.mjs sse-event-taxonomy.test.mjs goosed-proxy-boundary.test.mjs agent-run-stream.test.mjs mindspace-h5-html-finish-guard.test.mjs admin-routes.test.mjs image-make-admin-config.test.mjs asset-gateway.test.mjs image-make-client.test.mjs mindspace-image-generation.test.mjs mindspace-image-generation-routes.test.mjs mindspace-image-review.test.mjs mindspace-run-public-html-scope.test.mjs direct-chat-service.test.mjs tool-gateway.test.mjs mindspace.test.mjs mindspace-scan.test.mjs mindspace-assets.test.mjs mindspace-local-runtime-services.test.mjs mindspace-local-server-adapter.test.mjs mindspace-public-asset-token.test.mjs mindspace-remote-server-adapter.test.mjs mindspace-server-adapter.test.mjs mindspace-pages.test.mjs mindspace-page-sync-service.test.mjs public-site-bases.test.mjs mindspace-html-download-links.test.mjs mindspace-page-purge.test.mjs mindspace-public-delivery.test.mjs mindspace-public-page-context.test.mjs mindspace-published-page-csp.test.mjs mindspace-published-script-localize.test.mjs agent-run-deliverable-check.test.mjs mindspace-public-route.test.mjs mindspace-publications.test.mjs mindspace-public-links.test.mjs mindspace-chat-save.test.mjs mindspace-chat-docx-package.test.mjs mindspace-public-finish-sync.test.mjs mindspace-chat-context.test.mjs mindspace-canonical-url.test.mjs mindspace-conversation-package.test.mjs mindspace-conversation-package-backfill.test.mjs mindspace-conversation-package-public-html.test.mjs mindspace-conversation-package-verify.test.mjs mindspace-conversation-package-registry.test.mjs mindspace-conversation-package-routes.test.mjs mindspace-conversation-package-store.test.mjs mindspace-conversation-schema.test.mjs mindspace-runtime-config.test.mjs mindspace-config.test.mjs mindspace-analytics.test.mjs mindspace-service.test.mjs mindspace-storage-adapter.test.mjs mindspace-content-scan.test.mjs mindspace-html-localize.test.mjs mindspace-visual-editor.test.mjs mindspace-cleanup.test.mjs mindspace-thumbnails.test.mjs mindspace-workspace-thumbnails.test.mjs mindspace-workspace-sync.test.mjs mindspace-asset-preview.test.mjs mindspace-agent-jobs.test.mjs mindspace-agent-runner.test.mjs mindspace-sandbox-mcp.test.mjs mindspace-userdata-postgres.test.mjs postgres-user-data-space-service.test.mjs user-data-space-service.test.mjs page-data-routes.test.mjs page-access-policy.test.mjs page-access-visitor.test.mjs page-data-public-service.test.mjs page-data-integration.test.mjs page-data-log-store.test.mjs page-data-ops.test.mjs page-data-session-store.test.mjs page-data-browser-client.test.mjs page-data-policy-index.test.mjs message-stream.test.mjs mindspace-service/mindspace-rpc-server.test.mjs plaza-posts.test.mjs plaza-interactions.test.mjs plaza-algorithm.test.mjs plaza-seo.test.mjs plaza-ops.test.mjs user-auth.test.mjs llm-providers.test.mjs admin-guard.test.mjs user-feedback.test.mjs memory-v2.test.mjs memory-v2-admin-config.test.mjs memory-v2-lifecycle.test.mjs memory-v2-adapter-scaffold.test.mjs memory-v2-backend-contract.test.mjs memory-v2-health.test.mjs memory-v2-runtime.test.mjs memory-v2-plugin-backends.test.mjs memory-v2-pgvector.test.mjs memory-v2-pgvector-schema.test.mjs memory-v2-pgvector-backfill.test.mjs memory-v2-pgvector-smoke.test.mjs memory-v2-qdrant.test.mjs memory-v2-weaviate.test.mjs memory-v2-mem0.test.mjs memory-v2-letta.test.mjs memory-v2-external-adapters.test.mjs scripts/embed-memory-v2-local-hash.test.mjs scripts/check-memory-v2-app-canary.test.mjs scripts/check-memory-v2-config-gaps.test.mjs scripts/check-memory-v2-contracts.test.mjs scripts/check-memory-v2-health.test.mjs scripts/check-memory-v2-session-flow.test.mjs scripts/check-memory-v2-stack.test.mjs scripts/setup-memory-v2-pgvector-schema.test.mjs scripts/backfill-memory-v2-pgvector.test.mjs scripts/scaffold-memory-v2-backend.test.mjs scripts/smoke-memory-v2-pgvector.test.mjs scripts/smoke-memory-v2-qdrant.test.mjs scripts/smoke-memory-v2-external.test.mjs scripts/mock-memory-v2-services.test.mjs",
+    "test": "node --test auth.test.mjs asr-proxy.test.mjs billing.test.mjs billing-token-state.test.mjs billing-recharge.test.mjs wechat-pay.test.mjs wechat-oauth.test.mjs wechat-mp.test.mjs wechat-media.test.mjs wechat/image-generation-policy.test.mjs wechat/verify/generated-thumbnail.test.mjs schedule-intent.test.mjs schedule-reminder-worker.test.mjs capabilities.test.mjs policies.test.mjs server/portal-api-auth-middleware.test.mjs server/portal-config-routes.test.mjs server/portal-plaza-discovery-routes.test.mjs server/portal-runtime-routes.test.mjs chat-skills.test.mjs chat-intent-router.test.mjs chat-finish-sync.test.mjs chat-agent-run-gate.test.mjs conversation-display.test.mjs user-publish.test.mjs user-memory-profile.test.mjs skills-registry.test.mjs skill-runtime-policy.test.mjs excel-analyst.test.mjs agent-run-gateway.test.mjs agent-run-routes.test.mjs session-broker.test.mjs sse-event-taxonomy.test.mjs goosed-proxy-boundary.test.mjs agent-run-stream.test.mjs mindspace-h5-html-finish-guard.test.mjs admin-routes.test.mjs services/orchestrator/admin-config.test.mjs services/orchestrator/contracts.test.mjs services/orchestrator/checkpoint.test.mjs services/orchestrator/runtime.test.mjs services/orchestrator/app.test.mjs services/orchestrator/shadow-observer.test.mjs services/orchestrator/observability.test.mjs image-make-admin-config.test.mjs asset-gateway.test.mjs image-make-client.test.mjs mindspace-image-generation.test.mjs mindspace-image-generation-routes.test.mjs mindspace-image-review.test.mjs mindspace-run-public-html-scope.test.mjs direct-chat-service.test.mjs tool-gateway.test.mjs mindspace.test.mjs mindspace-scan.test.mjs mindspace-assets.test.mjs mindspace-local-runtime-services.test.mjs mindspace-local-server-adapter.test.mjs mindspace-public-asset-token.test.mjs mindspace-remote-server-adapter.test.mjs mindspace-server-adapter.test.mjs mindspace-pages.test.mjs mindspace-page-sync-service.test.mjs public-site-bases.test.mjs mindspace-html-download-links.test.mjs mindspace-page-purge.test.mjs mindspace-public-delivery.test.mjs mindspace-public-page-context.test.mjs mindspace-published-page-csp.test.mjs mindspace-published-script-localize.test.mjs agent-run-deliverable-check.test.mjs mindspace-public-route.test.mjs mindspace-publications.test.mjs mindspace-public-links.test.mjs mindspace-chat-save.test.mjs mindspace-chat-docx-package.test.mjs mindspace-public-finish-sync.test.mjs mindspace-chat-context.test.mjs mindspace-canonical-url.test.mjs mindspace-conversation-package.test.mjs mindspace-conversation-package-backfill.test.mjs mindspace-conversation-package-public-html.test.mjs mindspace-conversation-package-verify.test.mjs mindspace-conversation-package-registry.test.mjs mindspace-conversation-package-routes.test.mjs mindspace-conversation-package-store.test.mjs mindspace-conversation-schema.test.mjs mindspace-runtime-config.test.mjs mindspace-config.test.mjs mindspace-analytics.test.mjs mindspace-rybbit.test.mjs mindspace-service.test.mjs mindspace-storage-adapter.test.mjs mindspace-content-scan.test.mjs mindspace-html-localize.test.mjs mindspace-visual-editor.test.mjs mindspace-cleanup.test.mjs mindspace-thumbnails.test.mjs mindspace-workspace-thumbnails.test.mjs mindspace-workspace-sync.test.mjs mindspace-asset-preview.test.mjs mindspace-agent-jobs.test.mjs mindspace-agent-runner.test.mjs mindspace-sandbox-mcp.test.mjs mindspace-userdata-postgres.test.mjs postgres-user-data-space-service.test.mjs user-data-space-service.test.mjs page-data-routes.test.mjs page-access-policy.test.mjs page-access-visitor.test.mjs page-data-public-service.test.mjs page-data-integration.test.mjs page-data-log-store.test.mjs page-data-ops.test.mjs page-data-session-store.test.mjs page-data-browser-client.test.mjs page-data-policy-index.test.mjs message-stream.test.mjs mindspace-service/mindspace-rpc-server.test.mjs plaza-posts.test.mjs plaza-interactions.test.mjs plaza-algorithm.test.mjs plaza-seo.test.mjs plaza-ops.test.mjs user-auth.test.mjs llm-providers.test.mjs admin-guard.test.mjs user-feedback.test.mjs memory-v2.test.mjs memory-v2-admin-config.test.mjs memory-v2-lifecycle.test.mjs memory-v2-adapter-scaffold.test.mjs memory-v2-backend-contract.test.mjs memory-v2-health.test.mjs memory-v2-runtime.test.mjs memory-v2-plugin-backends.test.mjs memory-v2-pgvector.test.mjs memory-v2-pgvector-schema.test.mjs memory-v2-pgvector-backfill.test.mjs memory-v2-pgvector-smoke.test.mjs memory-v2-qdrant.test.mjs memory-v2-weaviate.test.mjs memory-v2-mem0.test.mjs memory-v2-letta.test.mjs memory-v2-external-adapters.test.mjs scripts/embed-memory-v2-local-hash.test.mjs scripts/check-memory-v2-app-canary.test.mjs scripts/check-memory-v2-config-gaps.test.mjs scripts/check-memory-v2-contracts.test.mjs scripts/check-memory-v2-health.test.mjs scripts/check-memory-v2-session-flow.test.mjs scripts/check-memory-v2-stack.test.mjs scripts/setup-memory-v2-pgvector-schema.test.mjs scripts/backfill-memory-v2-pgvector.test.mjs scripts/scaffold-memory-v2-backend.test.mjs scripts/smoke-memory-v2-pgvector.test.mjs scripts/smoke-memory-v2-qdrant.test.mjs scripts/smoke-memory-v2-external.test.mjs scripts/mock-memory-v2-services.test.mjs",
     "test:episodic-memory": "node --test episodic-memory.test.mjs direct-chat-service.test.mjs chat-intent-router.test.mjs",
     "test:deep-search": "node --test deep-search.test.mjs mindsearch.test.mjs",
     "test:image-review": "node --test mindspace-image-review.test.mjs mindspace-image-generation.test.mjs",
@@ -99,6 +100,9 @@
     "deploy:plaza-105": "bash scripts/deploy-plaza-105.sh"
   },
   "dependencies": {
+    "@langchain/core": "^1.2.3",
+    "@langchain/langgraph": "^1.4.8",
+    "@langchain/langgraph-checkpoint-postgres": "^1.0.4",
     "@node-rs/argon2": "^2.0.2",
     "@resvg/resvg-js": "^2.6.2",
     "debug": "^4.4.3",
diff --git a/page-data-html-detect.mjs b/page-data-html-detect.mjs
index 3a6dfbf..db57eb5 100644
--- a/page-data-html-detect.mjs
+++ b/page-data-html-detect.mjs
@@ -41,6 +41,9 @@ export function detectPageDataDatasetUsageFromHtml(html) {
   for (const match of text.matchAll(/\.listRows\(\s*['"]([^'"]+)['"]/g)) {
     remember(match[1], { read: true });
   }
+  for (const match of text.matchAll(/\.updateRow\(\s*['"]([^'"]+)['"]/g)) {
+    remember(match[1], { update: true });
+  }
   for (const match of text.matchAll(/\.deleteRow\(\s*['"]([^'"]+)['"]/g)) {
     // The browser client's deleteRow endpoint intentionally falls back to a
     // soft delete unless a policy explicitly grants hard_delete. A page using
@@ -57,6 +60,9 @@ export function detectPageDataDatasetUsageFromHtml(html) {
   for (const match of text.matchAll(/\.listRows\(\s*(?!\$\{)([A-Za-z_$][\w$]*)/g)) {
     remember(constants.get(match[1]) ?? match[1], { read: true });
   }
+  for (const match of text.matchAll(/\.updateRow\(\s*(?!\$\{)([A-Za-z_$][\w$]*)/g)) {
+    remember(constants.get(match[1]) ?? match[1], { update: true });
+  }
   for (const match of text.matchAll(/\.deleteRow\(\s*(?!\$\{)([A-Za-z_$][\w$]*)/g)) {
     remember(constants.get(match[1]) ?? match[1], { softDelete: true });
   }
@@ -91,7 +97,7 @@ export function assertPolicyMatchesHtmlDatasets(html, policyDatasets) {
   if (htmlNames.join(',') !== policyNames.join(',')) {
     throw Object.assign(
       new Error(
-        `Page Data 策略 dataset（${policyNames.join(', ') || '无'}）与 HTML 中 insertRow/listRows 引用的 dataset（${htmlNames.join(', ')}）不一致。请使用与页面脚本相同的 dataset 名称。`,
+        `Page Data 策略 dataset（${policyNames.join(', ') || '无'}）与 HTML 中 insertRow/listRows/updateRow/deleteRow 引用的 dataset（${htmlNames.join(', ')}）不一致。请使用与页面脚本相同的 dataset 名称。`,
       ),
       {
         code: 'dataset_policy_html_mismatch',
@@ -148,6 +154,10 @@ export function buildPageDataPolicyDatasetsFromRegistry({ html, registryDatasets
       entry.softDelete = true;
       entry.columns.soft_delete = registered.columns?.soft_delete ?? ['id'];
     }
+    if (perms.update) {
+      entry.update = true;
+      entry.columns.update = registered.columns?.update ?? [];
+    }
 
     datasets[name] = entry;
   }
diff --git a/page-data-html-detect.test.mjs b/page-data-html-detect.test.mjs
index 15a86b6..691fd20 100644
--- a/page-data-html-detect.test.mjs
+++ b/page-data-html-detect.test.mjs
@@ -26,6 +26,30 @@ test('detectPageDataDatasetUsageFromHtml treats browser deleteRow as a soft dele
   assert.deepEqual(usage.get('tkmind_exp_survey'), { insert: true, read: true, softDelete: true });
 });
 
+test('detectPageDataDatasetUsageFromHtml detects updateRow for literal and constant datasets', () => {
+  const usage = detectPageDataDatasetUsageFromHtml(`
+    const PRODUCTS = 'products';
+    await c.updateRow(PRODUCTS, 1, { status: 'inactive' });
+    await c.updateRow('orders', 2, { status: 'shipped' });
+  `);
+  assert.deepEqual(usage.get('products'), { update: true });
+  assert.deepEqual(usage.get('orders'), { update: true });
+});
+
+test('buildPageDataPolicyDatasetsFromRegistry grants registered update columns', () => {
+  const datasets = buildPageDataPolicyDatasetsFromRegistry({
+    html: `await c.listRows('orders'); await c.updateRow('orders', 1, { status: 'shipped' });`,
+    registryDatasets: [{
+      name: 'orders',
+      actions: ['read', 'update'],
+      columns: { read: ['id', 'status'], update: ['status'] },
+    }],
+  });
+  assert.equal(datasets.orders.read, true);
+  assert.equal(datasets.orders.update, true);
+  assert.deepEqual(datasets.orders.columns.update, ['status']);
+});
+
 test('buildPageDataPolicyDatasetsFromRegistry grants registered soft delete when HTML uses deleteRow', () => {
   const datasets = buildPageDataPolicyDatasetsFromRegistry({
     html: `const DATASET = 'mood_notes'; await c.deleteRow(DATASET, 1);`,
diff --git a/page-data-policy-index.mjs b/page-data-policy-index.mjs
index 575c489..d9e1711 100644
--- a/page-data-policy-index.mjs
+++ b/page-data-policy-index.mjs
@@ -62,6 +62,39 @@ export async function getPageDataPolicyIndex(pool, pageId) {
   };
 }
 
+export async function getPageDataPolicyIndexByWorkspacePath(
+  pool,
+  ownerUserId,
+  workspaceRelativePath,
+) {
+  if (!pool || !ownerUserId || !workspaceRelativePath) return null;
+  const [rows] = await pool.query(
+    `SELECT i.page_id, i.owner_user_id, i.access_mode, i.dataset_count,
+            i.scope_hash, i.updated_at, p.current_publish_id
+     FROM h5_page_data_policy_index i
+     JOIN h5_page_records p
+       ON p.id = i.page_id
+      AND p.user_id = i.owner_user_id
+     WHERE i.owner_user_id = ?
+       AND p.workspace_relative_path = ?
+       AND p.status <> 'deleted'
+     ORDER BY i.updated_at DESC
+     LIMIT 1`,
+    [ownerUserId, workspaceRelativePath],
+  );
+  const row = rows[0];
+  if (!row) return null;
+  return {
+    pageId: row.page_id,
+    ownerUserId: row.owner_user_id,
+    accessMode: row.access_mode,
+    datasetCount: Number(row.dataset_count ?? 0),
+    scopeHash: row.scope_hash,
+    updatedAt: Number(row.updated_at ?? 0),
+    publicationId: row.current_publish_id ?? null,
+  };
+}
+
 export async function listPageDataPolicyIndexByOwner(pool, ownerUserId, { limit = 50 } = {}) {
   if (!pool) return [];
   const safeLimit = Math.min(Math.max(1, Number(limit ?? 50)), 200);
diff --git a/page-data-policy-index.test.mjs b/page-data-policy-index.test.mjs
index da9ae72..52a6ec5 100644
--- a/page-data-policy-index.test.mjs
+++ b/page-data-policy-index.test.mjs
@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import {
   buildPageDataPolicyScopeHash,
+  getPageDataPolicyIndexByWorkspacePath,
   upsertPageDataPolicyIndex,
 } from './page-data-policy-index.mjs';
 import {
@@ -46,6 +47,40 @@ test('upsertPageDataPolicyIndex writes mysql row', async () => {
   assert.equal(queries[0].params[0], 'page-1');
 });
 
+test('getPageDataPolicyIndexByWorkspacePath resolves the local delivery binding', async () => {
+  const queries = [];
+  const pool = {
+    async query(sql, params) {
+      queries.push({ sql, params });
+      return [[{
+        page_id: 'page-1',
+        owner_user_id: 'user-1',
+        access_mode: 'password',
+        dataset_count: 3,
+        scope_hash: 'scope-1',
+        updated_at: 123,
+        current_publish_id: 'publish-1',
+      }]];
+    },
+  };
+  const result = await getPageDataPolicyIndexByWorkspacePath(
+    pool,
+    'user-1',
+    'public/storefront-admin.html',
+  );
+  assert.deepEqual(result, {
+    pageId: 'page-1',
+    ownerUserId: 'user-1',
+    accessMode: 'password',
+    datasetCount: 3,
+    scopeHash: 'scope-1',
+    updatedAt: 123,
+    publicationId: 'publish-1',
+  });
+  assert.match(queries[0].sql, /JOIN h5_page_records/);
+  assert.deepEqual(queries[0].params, ['user-1', 'public/storefront-admin.html']);
+});
+
 test('syncPageDataPolicyAccessMode updates policy access mode after publish', () => {
   const workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'page-data-publish-sync-'));
   writePageAccessPolicy(workspaceRoot, {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index d905b26..f38a882 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,6 +8,15 @@ importers:
 
   .:
     dependencies:
+      '@langchain/core':
+        specifier: ^1.2.3
+        version: 1.2.3(ws@8.21.0)
+      '@langchain/langgraph':
+        specifier: ^1.4.8
+        version: 1.4.8(@langchain/core@1.2.3(ws@8.21.0))(react-dom@19.2.7(react@19.2.7))(react@19.2.7)(zod@4.4.3)
+      '@langchain/langgraph-checkpoint-postgres':
+        specifier: ^1.0.4
+        version: 1.0.4(@langchain/core@1.2.3(ws@8.21.0))(@langchain/langgraph-checkpoint@1.1.3(@langchain/core@1.2.3(ws@8.21.0)))
       '@node-rs/argon2':
         specifier: ^2.0.2
         version: 2.0.2
@@ -173,6 +182,9 @@ packages:
     resolution: {integrity: sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==}
     engines: {node: '>=6.9.0'}
 
+  '@cfworker/json-schema@4.1.1':
+    resolution: {integrity: sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og==}
+
   '@emnapi/core@1.11.1':
     resolution: {integrity: sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ==}
 
@@ -522,6 +534,51 @@ packages:
   '@jridgewell/trace-mapping@0.3.31':
     resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
 
+  '@langchain/core@1.2.3':
+    resolution: {integrity: sha512-F+L5SsciykwDl7eDxacnhDTcWe1IF6jetzfkvI5PPfq6ogWHO7xcjU90SGh/3lqbbS0tgun+qF01KIqxawrCsA==}
+    engines: {node: '>=20'}
+
+  '@langchain/langgraph-checkpoint-postgres@1.0.4':
+    resolution: {integrity: sha512-wuCPq7VVqwi0+nQC5GOmheoXGJHAybgXbkA9Nn0J8nYW61WFJ3uqb4wyMbLFhAlya99EaxNNsi3FzdzV2COSzw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@langchain/core': ^1.1.44
+      '@langchain/langgraph-checkpoint': ^1.0.0
+
+  '@langchain/langgraph-checkpoint@1.1.3':
+    resolution: {integrity: sha512-wgzdQNeEsdw1e+4lvlj0tdq/RYR/k1vPin10g0ymGoehZDDgd9nvIllGXSXN4TFgF9sf5qQP/KTkOcLfeseIhA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@langchain/core': ^1.1.48
+
+  '@langchain/langgraph-sdk@1.9.28':
+    resolution: {integrity: sha512-4j3XuM0PvtmAbL8mPfBS99ez3+ytRfgbOpAR/nOeaejTRF3Q9dNw2QnaGLGng8wLPtGLoSj+SYgUOVxy9Bv9vg==}
+    peerDependencies:
+      '@langchain/core': ^1.1.48
+      react: ^18 || ^19
+      react-dom: ^18 || ^19
+      svelte: ^4.0.0 || ^5.0.0
+      vue: ^3.0.0
+    peerDependenciesMeta:
+      react:
+        optional: true
+      react-dom:
+        optional: true
+      svelte:
+        optional: true
+      vue:
+        optional: true
+
+  '@langchain/langgraph@1.4.8':
+    resolution: {integrity: sha512-DN1Np1XefdBEbp1qBKlt39cwoL743AAGpR5Ipja0gY2YbWvsoQnOTIrjnj/orSAhaUYsdTKS8VSWdFzsHZo6Ig==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@langchain/core': ^1.1.48
+      zod: ^3.25.32 || ^4.2.0
+
+  '@langchain/protocol@0.0.18':
+    resolution: {integrity: sha512-XW1egQtPfsGI41w2AMZNFZrUIwFSQHTjVMZs0OaTpCAvht/QLoaPN8FQcsysMVypOhupG28J29yOorrc70otBQ==}
+
   '@napi-rs/wasm-runtime@0.2.12':
     resolution: {integrity: sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==}
 
@@ -866,6 +923,9 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
   '@tybys/wasm-util@0.10.2':
     resolution: {integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==}
 
@@ -887,6 +947,9 @@ packages:
   '@types/http-proxy@1.17.17':
     resolution: {integrity: sha512-ED6LB+Z1AVylNTu7hdzuBqOgMnvG/ld6wGCG8wFnAzKX5uyW2K3WD52v0gnLCTK/VLpXtKckgWuyScYK6cSPaw==}
 
+  '@types/json-schema@7.0.15':
+    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
+
   '@types/node@14.18.63':
     resolution: {integrity: sha512-fAtCfv4jJg+ExtXhvCkCqUKZ+4ok/JQk01qDKhL5BDDoS3AxKXhV5/MAVUZyQnSEd2GT92fkgZl0pz0Q0AzcIQ==}
 
@@ -1189,6 +1252,9 @@ packages:
   eventemitter3@4.0.7:
     resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
 
+  eventemitter3@5.0.4:
+    resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
+
   exceljs@4.4.0:
     resolution: {integrity: sha512-XctvKaEMaj1Ii9oDOqbW/6e1gXknSY4g/aLCDicOXqBE4M0nRWkUu0PTp++UPNzoFY12BNHMfs/VadKIS6llvg==}
     engines: {node: '>=8.3.0'}
@@ -1372,6 +1438,10 @@ packages:
     resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
     engines: {node: '>=0.10.0'}
 
+  is-network-error@1.3.2:
+    resolution: {integrity: sha512-PhBY86zaxNZUuWP6h13Vu5oFe0XY6/UlKzQnYFELzGVHygP3MxmvTfYSG7GN3aIab/iWudSMgjSnG9Dq+nHrgA==}
+    engines: {node: '>=16'}
+
   is-number@7.0.0:
     resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
     engines: {node: '>=0.12.0'}
@@ -1386,6 +1456,9 @@ packages:
   isarray@1.0.0:
     resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
 
+  js-tiktoken@1.0.21:
+    resolution: {integrity: sha512-biOj/6M5qdgx5TKjDnFT1ymSpM5tbd3ylwDtrQvFQSu0Z7bBYko2dF+W/aUkXUPuk6IVpRxk/3Q2sHOzGlS36g==}
+
   js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
@@ -1406,6 +1479,26 @@ packages:
   jszip@3.10.1:
     resolution: {integrity: sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==}
 
+  langsmith@0.8.6:
+    resolution: {integrity: sha512-tl7cV79S/SkJNskCo7joRIVCYy+ljVLs4L1hgC2qT01x4CAWX+6IJzmfXGYAJcn1ecpaQr63WRjkLO9jefmOmQ==}
+    peerDependencies:
+      '@opentelemetry/api': '*'
+      '@opentelemetry/exporter-trace-otlp-proto': '*'
+      '@opentelemetry/sdk-trace-base': '*'
+      openai: '*'
+      ws: '>=7'
+    peerDependenciesMeta:
+      '@opentelemetry/api':
+        optional: true
+      '@opentelemetry/exporter-trace-otlp-proto':
+        optional: true
+      '@opentelemetry/sdk-trace-base':
+        optional: true
+      openai:
+        optional: true
+      ws:
+        optional: true
+
   lazystream@1.0.1:
     resolution: {integrity: sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==}
     engines: {node: '>= 0.6.3'}
@@ -1533,6 +1626,10 @@ packages:
   ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
 
+  mustache@4.2.0:
+    resolution: {integrity: sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==}
+    hasBin: true
+
   mysql2@3.22.5:
     resolution: {integrity: sha512-95uZ2TrPWAZdwpB3vvvDbmEMcNG8yIeNCyu6GUcr/QnWEE/wXm7+mhOCsdQfWQDTV7qYT/PDUZ4U4UPP4AsXqQ==}
     engines: {node: '>= 8.0'}
@@ -1571,6 +1668,10 @@ packages:
   once@1.4.0:
     resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
 
+  p-finally@1.0.0:
+    resolution: {integrity: sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==}
+    engines: {node: '>=4'}
+
   p-limit@2.3.0:
     resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
     engines: {node: '>=6'}
@@ -1579,6 +1680,26 @@ packages:
     resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
     engines: {node: '>=8'}
 
+  p-queue@6.6.2:
+    resolution: {integrity: sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==}
+    engines: {node: '>=8'}
+
+  p-queue@9.3.3:
+    resolution: {integrity: sha512-NXAOdnEe5FsZJfT4oK84lE1Y5cFFdWlRuOo5tww8DyNMxyRXwn39fIkUtNLKppcPC+UYU/bXujNCUGDv01y7CA==}
+    engines: {node: '>=20'}
+
+  p-retry@7.1.1:
+    resolution: {integrity: sha512-J5ApzjyRkkf601HpEeykoiCvzHQjWxPAHhyjFcEUP2SWq0+35NKh8TLhpLw+Dkq5TZBFvUM6UigdE9hIVYTl5w==}
+    engines: {node: '>=20'}
+
+  p-timeout@3.2.0:
+    resolution: {integrity: sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==}
+    engines: {node: '>=8'}
+
+  p-timeout@7.0.1:
+    resolution: {integrity: sha512-AxTM2wDGORHGEkPCt8yqxOTMgpfbEHqF51f/5fJCmwFC3C/zNcGT63SymH2ttOAaiIws2zVg4+izQCjrakcwHg==}
+    engines: {node: '>=20'}
+
   p-try@2.2.0:
     resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
     engines: {node: '>=6'}
@@ -2027,6 +2148,9 @@ packages:
     resolution: {integrity: sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==}
     engines: {node: '>= 10'}
 
+  zod@4.4.3:
+    resolution: {integrity: sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==}
+
 snapshots:
 
   '@babel/code-frame@7.29.7':
@@ -2141,6 +2265,8 @@ snapshots:
       '@babel/helper-string-parser': 7.29.7
       '@babel/helper-validator-identifier': 7.29.7
 
+  '@cfworker/json-schema@4.1.1': {}
+
   '@emnapi/core@1.11.1':
     dependencies:
       '@emnapi/wasi-threads': 1.2.2
@@ -2379,6 +2505,61 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  '@langchain/core@1.2.3(ws@8.21.0)':
+    dependencies:
+      '@cfworker/json-schema': 4.1.1
+      '@standard-schema/spec': 1.1.0
+      js-tiktoken: 1.0.21
+      langsmith: 0.8.6(ws@8.21.0)
+      mustache: 4.2.0
+      p-queue: 6.6.2
+      zod: 4.4.3
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+      - '@opentelemetry/exporter-trace-otlp-proto'
+      - '@opentelemetry/sdk-trace-base'
+      - openai
+      - ws
+
+  '@langchain/langgraph-checkpoint-postgres@1.0.4(@langchain/core@1.2.3(ws@8.21.0))(@langchain/langgraph-checkpoint@1.1.3(@langchain/core@1.2.3(ws@8.21.0)))':
+    dependencies:
+      '@langchain/core': 1.2.3(ws@8.21.0)
+      '@langchain/langgraph-checkpoint': 1.1.3(@langchain/core@1.2.3(ws@8.21.0))
+      pg: 8.22.0
+    transitivePeerDependencies:
+      - pg-native
+
+  '@langchain/langgraph-checkpoint@1.1.3(@langchain/core@1.2.3(ws@8.21.0))':
+    dependencies:
+      '@langchain/core': 1.2.3(ws@8.21.0)
+
+  '@langchain/langgraph-sdk@1.9.28(@langchain/core@1.2.3(ws@8.21.0))(react-dom@19.2.7(react@19.2.7))(react@19.2.7)':
+    dependencies:
+      '@langchain/core': 1.2.3(ws@8.21.0)
+      '@langchain/protocol': 0.0.18
+      '@types/json-schema': 7.0.15
+      p-queue: 9.3.3
+      p-retry: 7.1.1
+    optionalDependencies:
+      react: 19.2.7
+      react-dom: 19.2.7(react@19.2.7)
+
+  '@langchain/langgraph@1.4.8(@langchain/core@1.2.3(ws@8.21.0))(react-dom@19.2.7(react@19.2.7))(react@19.2.7)(zod@4.4.3)':
+    dependencies:
+      '@langchain/core': 1.2.3(ws@8.21.0)
+      '@langchain/langgraph-checkpoint': 1.1.3(@langchain/core@1.2.3(ws@8.21.0))
+      '@langchain/langgraph-sdk': 1.9.28(@langchain/core@1.2.3(ws@8.21.0))(react-dom@19.2.7(react@19.2.7))(react@19.2.7)
+      '@langchain/protocol': 0.0.18
+      '@standard-schema/spec': 1.1.0
+      zod: 4.4.3
+    transitivePeerDependencies:
+      - react
+      - react-dom
+      - svelte
+      - vue
+
+  '@langchain/protocol@0.0.18': {}
+
   '@napi-rs/wasm-runtime@0.2.12':
     dependencies:
       '@emnapi/core': 1.11.1
@@ -2601,6 +2782,8 @@ snapshots:
   '@rollup/rollup-win32-x64-msvc@4.62.0':
     optional: true
 
+  '@standard-schema/spec@1.1.0': {}
+
   '@tybys/wasm-util@0.10.2':
     dependencies:
       tslib: 2.8.1
@@ -2633,6 +2816,8 @@ snapshots:
     dependencies:
       '@types/node': 25.9.3
 
+  '@types/json-schema@7.0.15': {}
+
   '@types/node@14.18.63': {}
 
   '@types/node@25.9.3':
@@ -2951,6 +3136,8 @@ snapshots:
 
   eventemitter3@4.0.7: {}
 
+  eventemitter3@5.0.4: {}
+
   exceljs@4.4.0:
     dependencies:
       archiver: 5.3.2
@@ -3181,6 +3368,8 @@ snapshots:
     dependencies:
       is-extglob: 2.1.1
 
+  is-network-error@1.3.2: {}
+
   is-number@7.0.0: {}
 
   is-plain-object@5.0.0: {}
@@ -3189,6 +3378,10 @@ snapshots:
 
   isarray@1.0.0: {}
 
+  js-tiktoken@1.0.21:
+    dependencies:
+      base64-js: 1.5.1
+
   js-tokens@4.0.0: {}
 
   jsesc@3.1.0: {}
@@ -3204,6 +3397,12 @@ snapshots:
       readable-stream: 2.3.8
       setimmediate: 1.0.5
 
+  langsmith@0.8.6(ws@8.21.0):
+    dependencies:
+      p-queue: 6.6.2
+    optionalDependencies:
+      ws: 8.21.0
+
   lazystream@1.0.1:
     dependencies:
       readable-stream: 2.3.8
@@ -3301,6 +3500,8 @@ snapshots:
 
   ms@2.1.3: {}
 
+  mustache@4.2.0: {}
+
   mysql2@3.22.5(@types/node@25.9.3):
     dependencies:
       '@types/node': 25.9.3
@@ -3335,6 +3536,8 @@ snapshots:
     dependencies:
       wrappy: 1.0.2
 
+  p-finally@1.0.0: {}
+
   p-limit@2.3.0:
     dependencies:
       p-try: 2.2.0
@@ -3343,6 +3546,26 @@ snapshots:
     dependencies:
       p-limit: 2.3.0
 
+  p-queue@6.6.2:
+    dependencies:
+      eventemitter3: 4.0.7
+      p-timeout: 3.2.0
+
+  p-queue@9.3.3:
+    dependencies:
+      eventemitter3: 5.0.4
+      p-timeout: 7.0.1
+
+  p-retry@7.1.1:
+    dependencies:
+      is-network-error: 1.3.2
+
+  p-timeout@3.2.0:
+    dependencies:
+      p-finally: 1.0.0
+
+  p-timeout@7.0.1: {}
+
   p-try@2.2.0: {}
 
   pako@1.0.11: {}
@@ -3803,3 +4026,5 @@ snapshots:
       archiver-utils: 3.0.4
       compress-commons: 4.1.2
       readable-stream: 3.6.2
+
+  zod@4.4.3: {}
diff --git a/schema.sql b/schema.sql
index b7468d4..4287b12 100644
--- a/schema.sql
+++ b/schema.sql
@@ -408,9 +408,15 @@ CREATE TABLE IF NOT EXISTS h5_agent_runs (
   updated_at BIGINT NOT NULL,
   started_at BIGINT NULL,
   completed_at BIGINT NULL,
+  required_runtime_root VARCHAR(1024) NULL,
+  required_build_id VARCHAR(128) NULL,
+  claimed_worker_id VARCHAR(255) NULL,
+  claimed_runtime_root VARCHAR(1024) NULL,
+  claimed_build_id VARCHAR(128) NULL,
   UNIQUE KEY uq_h5_agent_run_request (user_id, request_id),
   KEY idx_h5_agent_run_user_status (user_id, status, updated_at),
   KEY idx_h5_agent_run_session (agent_session_id, updated_at),
+  KEY idx_h5_agent_run_runtime_status (required_build_id, status, updated_at),
   CONSTRAINT fk_h5_agent_run_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE,
   CONSTRAINT fk_h5_agent_run_session FOREIGN KEY (agent_session_id) REFERENCES h5_user_sessions(agent_session_id) ON DELETE SET NULL
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
@@ -422,6 +428,7 @@ CREATE TABLE IF NOT EXISTS h5_agent_run_events (
   data_json JSON NULL,
   created_at BIGINT NOT NULL,
   KEY idx_h5_agent_run_event_run (run_id, created_at),
+  KEY idx_h5_agent_run_event_type_time (event_type, created_at),
   CONSTRAINT fk_h5_agent_run_event_run FOREIGN KEY (run_id) REFERENCES h5_agent_runs(id) ON DELETE CASCADE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
diff --git a/scripts/orchestrator-dr.mjs b/scripts/orchestrator-dr.mjs
new file mode 100644
index 0000000..8bf01ac
--- /dev/null
+++ b/scripts/orchestrator-dr.mjs
@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+function parseArgs(argv) {
+  const [action = '', ...rest] = argv;
+  const options = { action };
+  for (let index = 0; index < rest.length; index += 1) {
+    const item = rest[index];
+    if (item === '--output') options.output = rest[++index];
+    else if (item === '--input') options.input = rest[++index];
+    else if (item === '--database-url') options.databaseUrl = rest[++index];
+    else if (item === '--confirm-empty-target') options.confirmEmptyTarget = true;
+    else if (item === '--allow-remote-target') options.allowRemoteTarget = true;
+  }
+  return options;
+}
+
+function run(command, args, { env = process.env } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      env,
+      stdio: ['ignore', 'inherit', 'inherit'],
+      shell: false,
+    });
+    child.once('error', reject);
+    child.once('exit', (code, signal) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${command} exited with ${signal ?? code}`));
+    });
+  });
+}
+
+function databaseUrl(options) {
+  const value = String(
+    options.databaseUrl ?? process.env.MEMIND_ORCHESTRATOR_DATABASE_URL ?? '',
+  ).trim();
+  if (!value) throw new Error('Provide --database-url or MEMIND_ORCHESTRATOR_DATABASE_URL');
+  return value;
+}
+
+function requireLocalOrExplicitRemote(url, options) {
+  const hostname = new URL(url).hostname.toLowerCase();
+  const local = ['localhost', '127.0.0.1', '::1', 'postgres'].includes(hostname);
+  if (!local && !options.allowRemoteTarget) {
+    throw new Error('Remote database targets require --allow-remote-target');
+  }
+}
+
+async function backup(options) {
+  const output = path.resolve(String(options.output ?? ''));
+  if (!options.output || path.extname(output) !== '.dump') {
+    throw new Error('Backup requires an explicit --output path ending in .dump');
+  }
+  await fs.mkdir(path.dirname(output), { recursive: true });
+  await fs.access(output).then(
+    () => Promise.reject(new Error(`Refusing to overwrite existing backup: ${output}`)),
+    () => null,
+  );
+  await run('pg_dump', [
+    '--format=custom',
+    '--no-owner',
+    '--no-privileges',
+    '--file',
+    output,
+    databaseUrl(options),
+  ]);
+  console.log(JSON.stringify({ ok: true, action: 'backup', output }));
+}
+
+async function verify(options) {
+  const input = path.resolve(String(options.input ?? ''));
+  if (!options.input) throw new Error('Verify requires --input');
+  await fs.access(input);
+  await run('pg_restore', ['--list', input]);
+  console.log(JSON.stringify({ ok: true, action: 'verify', input }));
+}
+
+async function restore(options) {
+  if (!options.confirmEmptyTarget) {
+    throw new Error('Restore requires --confirm-empty-target and never cleans an existing database');
+  }
+  const input = path.resolve(String(options.input ?? ''));
+  if (!options.input) throw new Error('Restore requires --input');
+  await fs.access(input);
+  const target = databaseUrl(options);
+  requireLocalOrExplicitRemote(target, options);
+  await run('pg_restore', [
+    '--exit-on-error',
+    '--no-owner',
+    '--no-privileges',
+    '--dbname',
+    target,
+    input,
+  ]);
+  console.log(JSON.stringify({ ok: true, action: 'restore', input }));
+}
+
+const options = parseArgs(process.argv.slice(2));
+try {
+  if (options.action === 'backup') await backup(options);
+  else if (options.action === 'verify') await verify(options);
+  else if (options.action === 'restore') await restore(options);
+  else {
+    throw new Error(
+      'Usage: orchestrator-dr.mjs backup --output file.dump | verify --input file.dump | restore --input file.dump --confirm-empty-target',
+    );
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}
+
+export const orchestratorDrInternals = {
+  databaseUrl,
+  parseArgs,
+  requireLocalOrExplicitRemote,
+  run,
+};
diff --git a/scripts/smoke-orchestrator-shadow.mjs b/scripts/smoke-orchestrator-shadow.mjs
new file mode 100644
index 0000000..a318048
--- /dev/null
+++ b/scripts/smoke-orchestrator-shadow.mjs
@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+import crypto from 'node:crypto';
+import { createAgentRunGateway } from '../agent-run-gateway.mjs';
+import { createDbPool, isDatabaseConfigured } from '../db.mjs';
+import { createOrchestratorAdminConfigService } from '../services/orchestrator/admin-config.mjs';
+import { createOrchestratorObservabilityService } from '../services/orchestrator/observability.mjs';
+import { createWorkflowShadowObserver } from '../services/orchestrator/shadow-observer.mjs';
+import { loadMemindEnvFiles } from './memind-runtime-profile.mjs';
+
+loadMemindEnvFiles(new URL('..', import.meta.url).pathname);
+
+const args = new Set(process.argv.slice(2));
+const cleanup = args.has('--cleanup');
+const restoreConfig = args.has('--restore-config');
+const serviceUrl = String(
+  process.env.MEMIND_ORCHESTRATOR_URL ?? 'http://127.0.0.1:8093',
+).trim().replace(/\/$/, '');
+const serviceToken = String(process.env.MEMIND_ORCHESTRATOR_SERVICE_TOKEN ?? '').trim();
+
+function assertLocalServiceUrl(value) {
+  const url = new URL(value);
+  if (!['127.0.0.1', 'localhost', '::1'].includes(url.hostname) && !args.has('--allow-remote')) {
+    throw new Error('Shadow smoke defaults to a loopback Orchestrator; pass --allow-remote explicitly');
+  }
+}
+
+async function waitForShadowEvent(pool, runId, timeoutMs = 15_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const [rows] = await pool.query(
+      `SELECT event_type, data_json, created_at
+         FROM h5_agent_run_events
+        WHERE run_id = ?
+          AND event_type IN ('workflow_shadow_completed', 'workflow_shadow_failed')
+        ORDER BY created_at DESC
+        LIMIT 1`,
+      [runId],
+    );
+    if (rows[0]) return rows[0];
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Timed out waiting for Shadow projection for run ${runId}`);
+}
+
+async function main() {
+  if (!isDatabaseConfigured()) {
+    throw new Error('Shadow smoke requires the local Memind MySQL configuration');
+  }
+  if (!serviceToken) {
+    throw new Error('MEMIND_ORCHESTRATOR_SERVICE_TOKEN is required');
+  }
+  assertLocalServiceUrl(serviceUrl);
+  const ready = await fetch(`${serviceUrl}/ready`);
+  if (!ready.ok) throw new Error(`Orchestrator readiness failed with HTTP ${ready.status}`);
+
+  const pool = createDbPool();
+  const configService = createOrchestratorAdminConfigService(pool);
+  const previous = await configService.getAdminConfig();
+  let runId = null;
+  try {
+    await configService.updateAdminConfig({
+      ...previous.config,
+      mode: 'shadow',
+      serviceUrl,
+      primaryEngine: 'langgraph',
+      workflowAllowlist: ['code-run-v1'],
+    });
+    const [users] = await pool.query(
+      `SELECT id
+         FROM h5_users
+        ORDER BY created_at ASC
+        LIMIT 1`,
+    );
+    if (!users[0]?.id) throw new Error('Shadow smoke requires at least one local user');
+
+    const observer = createWorkflowShadowObserver({
+      configService,
+      serviceToken,
+    });
+    const gateway = createAgentRunGateway({
+      pool,
+      tkmindProxy: {},
+      autoDispatch: false,
+      observeWorkflowRun: observer,
+    });
+    const requestId = `orchestrator-shadow-smoke-${Date.now()}-${crypto.randomUUID()}`;
+    const run = await gateway.createRun(users[0].id, {
+      requestId,
+      toolMode: 'code',
+      taskType: 'orchestrator_shadow_smoke',
+      userMessage: {
+        role: 'user',
+        content: [{ type: 'text', text: 'Observe this local smoke run without executing tools.' }],
+      },
+    });
+    runId = run.id;
+    const event = await waitForShadowEvent(pool, runId);
+    if (event.event_type !== 'workflow_shadow_completed') {
+      throw new Error(`Shadow smoke failed: ${JSON.stringify(event.data_json)}`);
+    }
+
+    const completedAt = Date.now();
+    await pool.query(
+      `UPDATE h5_agent_runs
+          SET status = 'succeeded', updated_at = ?, completed_at = ?
+        WHERE id = ? AND status = 'queued'`,
+      [completedAt, completedAt, runId],
+    );
+
+    const observability = createOrchestratorObservabilityService({
+      pool,
+      configService,
+      serviceToken,
+    });
+    const [summary, detail] = await Promise.all([
+      observability.listShadowRuns({ hours: 1, limit: 10 }),
+      observability.getShadowRun(runId),
+    ]);
+    if (!detail?.remote?.available || detail.remote.state?.status !== 'succeeded') {
+      throw new Error('Shadow checkpoint detail was not recoverable through the remote API');
+    }
+
+    console.log(JSON.stringify({
+      ok: true,
+      runId,
+      mode: 'shadow',
+      shadowEvent: event.event_type,
+      metrics: summary.metrics,
+      checkpointStatus: detail.remote.state.status,
+      graphEvents: detail.remote.events.map((item) => item.type),
+      cleanup,
+      restoreConfig,
+    }, null, 2));
+  } finally {
+    if (cleanup && runId) {
+      await pool.query('DELETE FROM h5_agent_runs WHERE id = ?', [runId]);
+    }
+    if (restoreConfig) {
+      await configService.updateAdminConfig(previous.config);
+    }
+    await pool.end();
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+});
diff --git a/server.mjs b/server.mjs
index e75323d..2a1d238 100644
--- a/server.mjs
+++ b/server.mjs
@@ -14,6 +14,7 @@ import { isLocalDevHostname } from './scripts/local-test-config.mjs';
 import { PUBLISH_ROOT_DIR } from './user-publish.mjs';
 import { startWorkspaceThumbnailWatcher } from './mindspace-workspace-thumbnails.mjs';
 import { resolveMindSpaceAnalyticsConfig, sendMindSpaceAnalyticsEvent } from './mindspace-analytics.mjs';
+import { resolveMindSpaceRybbitConfig } from './mindspace-rybbit.mjs';
 import { startWorkspaceAssetSyncWatcher } from './mindspace-workspace-sync.mjs';
 import { attachRequestId, sendData, sendError } from './api-response.mjs';
 import { attachPortalAgentJobRoutes } from './server/portal-agent-job-routes.mjs';
@@ -317,6 +318,7 @@ let authPool = null;
 let pageDataService = null;
 let pageDataPublicService = null;
 let mindSpaceAnalyticsConfig = resolveMindSpaceAnalyticsConfig();
+let mindSpaceRybbitConfig = resolveMindSpaceRybbitConfig();
 
 async function bootstrapUserAuth() {
   try {
@@ -505,6 +507,7 @@ async function bootstrapUserAuth() {
         systemDisclosurePolicyService,
         sessionSnapshotService,
         mindSpaceAnalyticsConfig,
+        mindSpaceRybbitConfig,
         subscriptionService,
         apiTarget: API_TARGET,
         apiSecret: API_SECRET,
@@ -1400,6 +1403,7 @@ attachPortalSessionRoutes(api, {
   getMindSpaceAssets: () => mindSpaceAssets,
   getMemoryV2: () => memoryV2,
   getMindSpaceAnalyticsConfig: () => mindSpaceAnalyticsConfig,
+  getMindSpaceRybbitConfig: () => mindSpaceRybbitConfig,
   isWorkspaceMaintenanceEnabled: () =>
     WORKSPACE_MAINTENANCE_ENABLED,
   ownsAgentSession,
@@ -1486,6 +1490,18 @@ app.use('/analytics', createProxyMiddleware({
     secure: false,
     pathRewrite: { [`^${mindSpaceAnalyticsConfig.hostPath}`]: '' },
   }));
+app.use('/rybbit', createProxyMiddleware({
+  target: 'https://rybbit.tkmind.cn',
+  router: () =>
+    mindSpaceRybbitConfig.rybbitUrl ||
+    process.env.MEMIND_RYBBIT_URL ||
+    process.env.RYBBIT_URL ||
+    'https://rybbit.tkmind.cn',
+  changeOrigin: true,
+  secure: true,
+  // Express strips the /rybbit mount. Rybbit serves trackers under /api/*.
+  pathRewrite: { '^/': '/api/' },
+}));
 const { serveUserPublishFile } =
   createPortalWorkspacePublicationDelivery({
     h5Root: H5_ROOT,
@@ -1493,6 +1509,8 @@ const { serveUserPublishFile } =
       INTERNAL_AGENT_SECRET,
     analyticsConfig:
       mindSpaceAnalyticsConfig,
+    rybbitConfig:
+      mindSpaceRybbitConfig,
     getAuthPool: () => authPool,
     getUserAuth: () => userAuth,
     getMindSpacePages: () => mindSpacePages,
diff --git a/server/portal-gateway-services-bootstrap.mjs b/server/portal-gateway-services-bootstrap.mjs
index 87ab315..5f2b76e 100644
--- a/server/portal-gateway-services-bootstrap.mjs
+++ b/server/portal-gateway-services-bootstrap.mjs
@@ -1,6 +1,8 @@
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createAgentRunGateway } from '../agent-run-gateway.mjs';
+import { isDirectChatSessionId } from '../direct-chat-service.mjs';
 import { scanWorkspaceFilesForProhibitedBrowserStorage } from '../mindspace-browser-storage-policy.mjs';
 import { evaluatePageDataHtmlContent } from '../mindspace-page-data-finish-guard.mjs';
 import { normalizeWorkspaceRelativePath } from '../mindspace-pages.mjs';
@@ -8,6 +10,12 @@ import { resolveMindSpaceUserPublishDir } from '../mindspace-runtime-config.mjs'
 import { policyAllowsAction } from '../page-access-policy.mjs';
 import { detectPageDataDatasetUsageFromHtml } from '../page-data-html-detect.mjs';
 import { readPageAccessPolicy } from '../page-data-policy-store.mjs';
+import {
+  cancelSessionActiveRequest,
+  quiesceSessionStdioExtensions,
+} from '../session-runtime-lifecycle.mjs';
+import { createOrchestratorAdminConfigService } from '../services/orchestrator/admin-config.mjs';
+import { createWorkflowShadowObserver } from '../services/orchestrator/shadow-observer.mjs';
 import { createTkmindProxy } from '../tkmind-proxy.mjs';
 import { createToolGateway } from '../tool-gateway.mjs';
 
@@ -17,6 +25,70 @@ function isEnabledFlag(value, fallback = '') {
   );
 }
 
+export function startPortalAgentRunRecoveryLoop(
+  agentRunGateway,
+  {
+    env = process.env,
+    logger = console,
+    setIntervalFn = setInterval,
+  } = {},
+) {
+  if (
+    typeof agentRunGateway?.dispatchQueuedRuns !== 'function' ||
+    typeof agentRunGateway?.recoverStaleRunningRuns !== 'function'
+  ) {
+    return null;
+  }
+  const configuredInterval = Number(
+    env.MEMIND_AGENT_RUN_RECOVERY_INTERVAL_MS ?? 30_000,
+  );
+  const intervalMs = Number.isFinite(configuredInterval)
+    ? Math.max(5_000, configuredInterval)
+    : 30_000;
+  const configuredHeartbeatStaleMs = Number(
+    env.MEMIND_AGENT_RUN_HEARTBEAT_STALE_MS ?? 90_000,
+  );
+  const heartbeatStaleMs =
+    Number.isFinite(configuredHeartbeatStaleMs)
+      ? Math.max(intervalMs * 2, configuredHeartbeatStaleMs)
+      : Math.max(intervalMs * 2, 90_000);
+  let sweepActive = false;
+  const sweep = async () => {
+    if (sweepActive) return;
+    sweepActive = true;
+    try {
+      const heartbeatRecovery =
+        await agentRunGateway.recoverStaleRunningRuns({
+          staleMs: heartbeatStaleMs,
+          limit: 20,
+          dryRun: false,
+          reason: 'worker_heartbeat_stale_recovery',
+        });
+      const result =
+        await agentRunGateway.dispatchQueuedRuns();
+      const recovered =
+        Number(heartbeatRecovery?.recovered ?? 0) +
+        Number(result?.staleRecovery?.recovered ?? 0);
+      if (recovered > 0) {
+        logger.warn(
+          `[AgentRun] recovered ${recovered} stale run(s)`,
+        );
+      }
+    } catch (error) {
+      logger.warn(
+        '[AgentRun] background recovery sweep failed:',
+        error instanceof Error ? error.message : error,
+      );
+    } finally {
+      sweepActive = false;
+    }
+  };
+  void sweep();
+  const timer = setIntervalFn(sweep, intervalMs);
+  timer?.unref?.();
+  return timer;
+}
+
 export function createPortalRunDeliverablesValidator({
   h5Root,
   resolveMindSpaceUserPublishDirFn =
@@ -154,8 +226,14 @@ export function bootstrapPortalGatewayServices({
   createTkmindProxyFn = createTkmindProxy,
   createToolGatewayFn = createToolGateway,
   createAgentRunGatewayFn = createAgentRunGateway,
+  createOrchestratorAdminConfigServiceFn =
+    createOrchestratorAdminConfigService,
+  createWorkflowShadowObserverFn =
+    createWorkflowShadowObserver,
   createRunDeliverablesValidatorFn =
     createPortalRunDeliverablesValidator,
+  startAgentRunRecoveryLoopFn =
+    startPortalAgentRunRecoveryLoop,
   readAssetFileFn = fs.promises.readFile,
 } = {}) {
   if (
@@ -207,6 +285,32 @@ export function bootstrapPortalGatewayServices({
   });
   const validateRunDeliverables =
     createRunDeliverablesValidatorFn({ h5Root });
+  const workflowShadowObserver =
+    createWorkflowShadowObserverFn({
+      configService:
+        createOrchestratorAdminConfigServiceFn(pool),
+      logger: console,
+    });
+  let runtimeRoot;
+  try {
+    runtimeRoot = fs.realpathSync(h5Root);
+  } catch {
+    runtimeRoot = path.resolve(h5Root);
+  }
+  const workerIdentity = {
+    workerId:
+      String(
+        env.MEMIND_AGENT_RUN_WORKER_ID ?? '',
+      ).trim() || `${process.pid}:${crypto.randomUUID()}`,
+    runtimeRoot,
+    buildId:
+      String(
+        env.MEMIND_RUNTIME_BUILD_ID ??
+          env.MEMIND_RELEASE_ID ??
+          env.GIT_COMMIT ??
+          'dev',
+      ).trim() || 'dev',
+  };
   const agentRunGateway = createAgentRunGatewayFn({
     pool,
     userAuth,
@@ -218,6 +322,7 @@ export function bootstrapPortalGatewayServices({
     chatIntentRouter,
     sessionSnapshotService,
     conversationMemoryService,
+    observeWorkflowRun: workflowShadowObserver,
     observePersonalMemoryOnSuccess: async ({
       userId,
       sessionId,
@@ -242,6 +347,37 @@ export function bootstrapPortalGatewayServices({
     isSessionExternallyBusy: ({ sessionId }) =>
       isSessionPageDeliveryActive(sessionId),
     validateRunDeliverables,
+    quiesceSessionOnTerminal: async ({
+      sessionId,
+      requestId,
+      status,
+    }) => {
+      if (isDirectChatSessionId(sessionId)) {
+        return { removed: [], skipped: true };
+      }
+      const target =
+        await tkmindProxy.resolveTarget(sessionId);
+      const sessionApiFetch = (pathname, init) =>
+        tkmindProxy.apiFetchTo(
+          target,
+          pathname,
+          init,
+        );
+      const cancellation =
+        status === 'failed'
+          ? await cancelSessionActiveRequest(
+              sessionApiFetch,
+              sessionId,
+              requestId,
+            )
+          : { cancelled: false, skipped: true };
+      const quiesced =
+        await quiesceSessionStdioExtensions(
+          sessionApiFetch,
+          sessionId,
+        );
+      return { ...quiesced, cancellation };
+    },
     autoDispatch: isEnabledFlag(
       env.MEMIND_AGENT_RUN_AUTODISPATCH,
       '1',
@@ -253,12 +389,19 @@ export function bootstrapPortalGatewayServices({
       env.MEMIND_AGENT_RUN_TIMEOUT_MS ??
         15 * 60 * 1000,
     ),
+    workerIdentity,
   });
+  const agentRunRecoveryTimer =
+    startAgentRunRecoveryLoopFn(
+      agentRunGateway,
+      { env, logger: console },
+    );
 
   return {
     tkmindProxy,
     toolGateway,
     agentRunGateway,
+    agentRunRecoveryTimer,
     validateRunDeliverables,
   };
 }
diff --git a/server/portal-integration-services-bootstrap.mjs b/server/portal-integration-services-bootstrap.mjs
index 3e4ee71..4b06248 100644
--- a/server/portal-integration-services-bootstrap.mjs
+++ b/server/portal-integration-services-bootstrap.mjs
@@ -3,6 +3,9 @@ import {
   resolveAnalyticsOwnerSegment,
   sendMindSpaceAnalyticsEvent,
 } from '../mindspace-analytics.mjs';
+import {
+  sendMindSpaceRybbitEvent,
+} from '../mindspace-rybbit.mjs';
 import { createPageEditSessionService } from '../mindspace-page-edit-session.mjs';
 import { resolveMindSpaceRuntimeConfig } from '../mindspace-runtime-config.mjs';
 import { createNotificationDispatcher } from '../notification-dispatcher.mjs';
@@ -26,6 +29,7 @@ export async function bootstrapPortalIntegrationServices({
   systemDisclosurePolicyService,
   sessionSnapshotService,
   mindSpaceAnalyticsConfig,
+  mindSpaceRybbitConfig,
   subscriptionService,
   apiTarget,
   apiSecret,
@@ -41,6 +45,8 @@ export async function bootstrapPortalIntegrationServices({
     resolveAnalyticsOwnerLabel,
   sendMindSpaceAnalyticsEventFn =
     sendMindSpaceAnalyticsEvent,
+  sendMindSpaceRybbitEventFn =
+    sendMindSpaceRybbitEvent,
   createNotificationDispatcherFn =
     createNotificationDispatcher,
   startScheduleReminderWorkerFn =
@@ -135,20 +141,19 @@ export async function bootstrapPortalIntegrationServices({
         artifacts = [],
       }) => {
         for (const artifact of artifacts) {
-          void sendMindSpaceAnalyticsEventFn({
-            config: mindSpaceAnalyticsConfig,
+          const pageOwner =
+            (await userAuth
+              ?.getUserById(userId)
+              .catch(() => null)) ?? {};
+          const analyticsPayload = {
             eventName: 'page_generated',
             ownerId: userId,
             ownerSegment:
               resolveAnalyticsOwnerSegmentFn(
-                (await userAuth
-                  ?.getUserById(userId)
-                  .catch(() => null)) ?? {},
+                pageOwner,
               ),
             ownerLabel: resolveAnalyticsOwnerLabelFn(
-              (await userAuth
-                ?.getUserById(userId)
-                .catch(() => null)) ?? {},
+              pageOwner,
             ),
             pageId: artifact.relativePath,
             publicationId: sessionId,
@@ -158,6 +163,14 @@ export async function bootstrapPortalIntegrationServices({
               artifact.url ||
               artifact.relativePath ||
               '/',
+          };
+          void sendMindSpaceAnalyticsEventFn({
+            config: mindSpaceAnalyticsConfig,
+            ...analyticsPayload,
+          });
+          void sendMindSpaceRybbitEventFn({
+            config: mindSpaceRybbitConfig,
+            ...analyticsPayload,
           });
         }
       },
diff --git a/server/portal-integration-services-bootstrap.test.mjs b/server/portal-integration-services-bootstrap.test.mjs
index b0d4e75..bbe6ffc 100644
--- a/server/portal-integration-services-bootstrap.test.mjs
+++ b/server/portal-integration-services-bootstrap.test.mjs
@@ -112,6 +112,7 @@ function createSetup(overrides = {}) {
     },
     sessionSnapshotService,
     mindSpaceAnalyticsConfig: { enabled: true },
+    mindSpaceRybbitConfig: { enabled: true },
     subscriptionService,
     apiTarget: 'http://api',
     apiSecret: 'secret',
@@ -151,6 +152,10 @@ function createSetup(overrides = {}) {
       calls.push(['analytics', event]);
       return Promise.resolve();
     },
+    sendMindSpaceRybbitEventFn(event) {
+      calls.push(['rybbit', event]);
+      return Promise.resolve();
+    },
     createNotificationDispatcherFn(receivedOptions) {
       calls.push(['notification-dispatcher']);
       notificationOptions = receivedOptions;
@@ -333,7 +338,7 @@ test('preserves generated-page analytics projection', async () => {
   assert.equal(
     setup.calls.filter(([name]) => name === 'get-user')
       .length,
-    2,
+    1,
   );
   const analyticsCall = setup.calls.find(
     ([name]) => name === 'analytics',
@@ -350,6 +355,13 @@ test('preserves generated-page analytics projection', async () => {
     channel: 'wechat_mp',
     url: 'https://example/page',
   });
+  const rybbitCall = setup.calls.find(
+    ([name]) => name === 'rybbit',
+  );
+  assert.deepEqual(rybbitCall[1], {
+    ...analyticsCall[1],
+    config: { enabled: true },
+  });
 });
 
 test('preserves notification, recharge, reminder, and page-edit wiring', async () => {
diff --git a/server/portal-session-routes.mjs b/server/portal-session-routes.mjs
index 9630fcf..4ab18f8 100644
--- a/server/portal-session-routes.mjs
+++ b/server/portal-session-routes.mjs
@@ -11,6 +11,9 @@ import {
   resolveAnalyticsOwnerSegment,
   sendMindSpaceAnalyticsEvent,
 } from '../mindspace-analytics.mjs';
+import {
+  sendMindSpaceRybbitEvent,
+} from '../mindspace-rybbit.mjs';
 import {
   markPageDeliveryContractReady,
   preparePageDeliveryContract,
@@ -58,6 +61,7 @@ export function attachPortalSessionRoutes(
     getMindSpaceAssets = () => null,
     getMemoryV2 = () => null,
     getMindSpaceAnalyticsConfig = () => null,
+    getMindSpaceRybbitConfig = () => null,
     isWorkspaceMaintenanceEnabled = () => false,
     ownsAgentSession,
     unregisterAgentSessionForUser,
@@ -86,6 +90,8 @@ export function attachPortalSessionRoutes(
       materializePublicHtmlWritesFromSessionEvent,
     sendMindSpaceAnalyticsEventFn =
       sendMindSpaceAnalyticsEvent,
+    sendMindSpaceRybbitEventFn =
+      sendMindSpaceRybbitEvent,
     resolveAnalyticsOwnerSegmentFn =
       resolveAnalyticsOwnerSegment,
     resolveAnalyticsOwnerLabelFn =
@@ -419,8 +425,7 @@ export function attachPortalSessionRoutes(
             continue;
           }
           generationAnalyticsEvents.add(relativePath);
-          void sendMindSpaceAnalyticsEventFn({
-            config: getMindSpaceAnalyticsConfig(),
+          const analyticsPayload = {
             eventName: 'page_generated',
             ownerId: req.currentUser.id,
             ownerSegment:
@@ -433,6 +438,14 @@ export function attachPortalSessionRoutes(
             channel: 'h5',
             url:
               `/${publishRootDir}/${req.currentUser.id}/${relativePath}`,
+          };
+          void sendMindSpaceAnalyticsEventFn({
+            config: getMindSpaceAnalyticsConfig(),
+            ...analyticsPayload,
+          });
+          void sendMindSpaceRybbitEventFn({
+            config: getMindSpaceRybbitConfig(),
+            ...analyticsPayload,
           });
         }
       };
diff --git a/server/portal-workspace-publication-delivery.mjs b/server/portal-workspace-publication-delivery.mjs
index a2e548f..8ad8c4d 100644
--- a/server/portal-workspace-publication-delivery.mjs
+++ b/server/portal-workspace-publication-delivery.mjs
@@ -8,12 +8,16 @@ import {
   resolveAnalyticsOwnerLabel,
   resolveAnalyticsOwnerSegment,
 } from '../mindspace-analytics.mjs';
+import {
+  injectMindSpaceRybbit,
+} from '../mindspace-rybbit.mjs';
 import {
   resolveMindSpacePublicRequest,
 } from '../mindspace-public-route.mjs';
 import {
   buildPublishedHtmlViewContext,
   parseMindSpacePublishFilePath,
+  resolveMindSpacePageDataContext,
 } from '../mindspace-public-page-context.mjs';
 import {
   preparePublicHtmlAssetDelivery,
@@ -71,6 +75,7 @@ export function createPortalWorkspacePublicationDelivery({
   h5Root,
   internalAgentSecret,
   analyticsConfig,
+  rybbitConfig,
   getAuthPool = () => null,
   getUserAuth = () => null,
   getMindSpacePages = () => null,
@@ -90,6 +95,8 @@ export function createPortalWorkspacePublicationDelivery({
     resolveClosestHtmlRelativePath,
   ensureWorkspaceThumbnail =
     ensureWorkspaceHtmlThumbnail,
+  resolvePageDataContext =
+    resolveMindSpacePageDataContext,
   getDeliveryContract =
     getPageDeliveryContract,
   ensureThumbnail = ensureThumbnailPng,
@@ -271,26 +278,20 @@ export function createPortalWorkspacePublicationDelivery({
             .catch(() => null)
         : null;
     let pageDataContext = null;
-    const mindSpacePages =
-      getMindSpacePages();
+    const mindSpacePages = getMindSpacePages();
     if (
-      mindSpacePages &&
       parsedPublishPath?.userId &&
       parsedPublishPath.relativePath
     ) {
-      const page = await mindSpacePages
-        .findPageByRelativePath(
-          parsedPublishPath.userId,
-          parsedPublishPath.relativePath,
-        )
-        .catch(() => null);
-      if (page?.id) {
-        pageDataContext = {
-          pageId: page.id,
-          accessMode:
-            page.publicationAccessMode ?? null,
-        };
-      }
+      pageDataContext =
+        await resolvePageDataContext({
+          pool: getAuthPool(),
+          pageService: mindSpacePages,
+          userId: parsedPublishPath.userId,
+          relativePath:
+            parsedPublishPath.relativePath,
+          logger,
+        });
     }
     html = injectMindSpaceAnalytics(html, {
       ownerId:
@@ -310,6 +311,24 @@ export function createPortalWorkspacePublicationDelivery({
         '',
       config: analyticsConfig,
     });
+    html = injectMindSpaceRybbit(html, {
+      ownerId:
+        parsedPublishPath?.userId ?? '',
+      ownerSegment:
+        resolveAnalyticsOwnerSegment(
+          pageOwner ?? {},
+        ),
+      ownerLabel: resolveAnalyticsOwnerLabel(
+        pageOwner ?? {},
+      ),
+      pageId:
+        pageDataContext?.pageId ?? '',
+      publicationId:
+        pageDataContext?.publicationId ??
+        pageDataContext?.publication_id ??
+        '',
+      config: rybbitConfig,
+    });
     const decorated =
       decorateMindSpacePublishedHtml({
         html,
diff --git a/services/orchestrator/Dockerfile b/services/orchestrator/Dockerfile
new file mode 100644
index 0000000..c843c1d
--- /dev/null
+++ b/services/orchestrator/Dockerfile
@@ -0,0 +1,16 @@
+FROM node:24-bookworm-slim
+
+ENV NODE_ENV=production
+WORKDIR /app
+
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev
+
+COPY *.mjs ./
+
+USER node
+EXPOSE 8093
+HEALTHCHECK --interval=15s --timeout=3s --start-period=10s --retries=3 \
+  CMD node -e "fetch('http://127.0.0.1:8093/ready').then((r) => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
+
+CMD ["node", "server.mjs"]
diff --git a/services/orchestrator/README.md b/services/orchestrator/README.md
new file mode 100644
index 0000000..861a637
--- /dev/null
+++ b/services/orchestrator/README.md
@@ -0,0 +1,290 @@
+# Memind Workflow Orchestrator
+
+This directory is the extraction boundary for Memind's durable workflow runtime.
+It is intentionally source-colocated with Memind while remaining framework-neutral
+at its public edge.
+
+## Dependency rule
+
+Allowed:
+
+```text
+Memind -> orchestrator contracts / client
+Orchestrator -> contracts / executor adapters
+Executor adapters -> versioned internal APIs
+```
+
+Forbidden:
+
+```text
+Orchestrator -> server.mjs
+Orchestrator -> user-auth.mjs
+Orchestrator -> Memind business tables
+Orchestrator -> production filesystem paths
+Memind -> LangGraph StateGraph / Command / checkpoint types
+```
+
+LangGraph is an implementation of the generic workflow engine contract. The
+Memind-facing protocol is `orchestrator-run-v1` plus `orchestrator-event-v1`.
+
+## Current stage
+
+Phase 1 established:
+
+- framework-neutral run and event contracts;
+- a plug-in workflow engine registry;
+- a remote workflow engine client;
+- versioned admin configuration;
+- deterministic Off / Shadow / Canary / Active routing decisions;
+- an environment-level emergency kill switch.
+
+Phase 2 adds:
+
+- a real LangGraph `StateGraph` service on the versioned HTTP boundary;
+- a PostgreSQL `PostgresSaver` checkpoint owner;
+- an explicitly non-durable MemorySaver option for tests and local debugging;
+- a `code-run-v1` observe-only graph with no executor dispatch or tool access;
+- a Portal fire-and-forget shadow projection;
+- live health probing from memindadm;
+- a separate Colima/Compose deployment artifact.
+
+Phase 2.5 adds a Memind-owned Shadow observability projection:
+
+- success/failure totals and rates;
+- P50/P95 observation latency;
+- Native terminal status beside the Shadow result;
+- recent failure codes and messages;
+- per-run LangGraph checkpoint and node-event inspection through the versioned
+  remote API.
+
+The projection reads `h5_agent_run_events` from the Memind control plane.
+LangGraph still has no access to Memind business tables.
+
+Phase 2.6 adds a read-only Canary readiness gate. It evaluates a fixed seven-day
+window and never changes the runtime mode. The first gate requires:
+
+- at least 20 non-smoke observations across at least five real sessions;
+- at least 95% Shadow success, latency coverage, and Native terminal coverage;
+- Shadow P95 latency no greater than two seconds;
+- a healthy observe-only service backed by a durable checkpoint;
+- a fresh, uncapped metric window while the control plane remains in Shadow.
+
+Passing the gate means only `manual_canary_review`; it does not authorize or
+activate Canary routing.
+
+Phase 3 introduced the execution handoff boundary in a hard-disabled state:
+
+- `workflow-execution-request-v1` normalizes authorization, timeout,
+  cancellation, fallback, and idempotency controls;
+- `workflow-execution-decision-v1` separates the candidate engine from the
+  effective executor;
+- Canary and Active selections emit auditable `workflow_execution_planned`
+  events;
+- the effective engine remains Native and non-Native dispatch throws
+  `WORKFLOW_EXECUTION_HANDOFF_DISABLED`;
+- the implementation capability was hard-disabled in code while the contracts
+  and observability matured.
+
+Phase 3.1 adds a Memind-owned Dry-run projection. Shadow mode continues its
+LangGraph observation while also evaluating the configured Canary allowlist and
+percentage. It records both selected and non-selected decisions so the
+candidate selection rate has a complete denominator. memindadm shows candidate
+reasons, task-type distribution, Native terminal coverage, recent decisions,
+and an explicit alert if any stored decision ever reports
+`handoffAllowed=true`.
+
+Phase 3.2 establishes the Executor Gateway boundary:
+
+- `executor-job-request-v1`, `executor-job-state-v1`, and
+  `executor-dispatch-decision-v1` remain independent of Goosed, Aider,
+  OpenHands, and LangGraph SDK types;
+- jobs use workspace and artifact references rather than host filesystem paths;
+- the store contract provides atomic idempotency, lookup, and state update
+  operations;
+- timeout, cancellation, fallback, authorization, network, and side-effect
+  controls are normalized before adapter selection;
+- Goosed, Aider, and OpenHands were initially registered as `contract-only`
+  adapters;
+- the reference memory store is explicitly non-durable and used only for local
+  contract tests.
+
+Phase 3.2 could record blocked, idempotent job state but could not invoke an
+adapter or launch a process.
+
+Phase 3.3 makes that blocked state durable:
+
+- the Orchestrator owns a PostgreSQL `executor_jobs` table beside its LangGraph
+  checkpoint tables, under the same isolated schema and database credentials;
+- the `build_plan` node atomically creates one deterministic Executor Job per
+  run and graph-node version;
+- retries recover the same job through its idempotency key, while a changed
+  semantic request fails closed;
+- `/health` and `/ready` report and probe checkpoint and Executor Job storage
+  independently;
+- memory mode keeps both stores explicitly non-durable.
+
+The Phase 3.3 persisted job was a preview terminal state. Existing Shadow runs
+remain blocked and non-executable after later phases.
+
+Phase 3.4 adds read-only Executor Job observability:
+
+- `executor-job-event-v1` is stored in the separate PostgreSQL
+  `executor_job_events` table with a per-job sequence cursor;
+- initial state and its first event are committed atomically, as are later
+  state transitions and their events;
+- existing Phase 3.3 snapshots receive a deterministic
+  `executor_job_snapshot_imported` migration event;
+- the versioned API exposes job state and cursor-paged events without exposing
+  task instructions, credentials, workspace paths, or executor SDK types;
+- unsafe or oversized run identifiers are represented by a deterministic
+  SHA-256-derived opaque Executor Job id so PostgreSQL and URL identifiers stay
+  bounded;
+- Shadow Run detail in memindadm joins Native state, LangGraph checkpoints,
+  Executor Job state, and Executor Job events;
+- Canary readiness now requires both checkpoint and Executor Job storage to be
+  durable.
+
+Phase 3.5 through Phase 5 add the opt-in execution plane:
+
+- `executor-worker-v1` provides atomic claim, lease fencing, heartbeat, progress,
+  retry, timeout recovery, completion, cancellation, and drain semantics;
+- PostgreSQL stores worker heartbeats and exposes queue/worker metrics;
+- Goosed uses the existing session HTTP/SSE transport with abort propagation;
+- Aider and OpenHands run as separate worker processes or containers with
+  workspace aliases, isolated roots, no shell, bounded environment/output, and
+  artifact references;
+- LangGraph active runs queue an Executor Job, wait durably, and converge their
+  terminal state from the job/event boundary;
+- admission policy enforces tenant/user/workspace allowlists, concurrency, and
+  per-minute limits before a job can enter the queue;
+- memindadm, Portal environment, Orchestrator environment, adapter enablement,
+  worker health, authorization, and admission are independent fail-closed gates.
+
+The default memindadm switch and both environment execution gates remain off.
+Native Agent Run therefore remains the executor until an explicitly approved
+Canary satisfies every gate.
+
+## Admin configuration
+
+The memindadm page is `/ops/admin/orchestrator`.
+
+Supported modes:
+
+- `off`: Native Agent Run only.
+- `shadow`: Native executes; the configured engine may observe.
+- `canary`: user allowlist and deterministic rollout percentage select eligible
+  runs; execution still requires the explicit execution switch and environment
+  gates.
+- `active`: workflow-allowlisted tasks select the primary engine, subject to
+  the same health, policy, worker, and kill-switch gates.
+
+`MEMIND_ORCHESTRATOR_KILL_SWITCH=1` always forces Native selection.
+
+## Local process
+
+PostgreSQL is the default and required checkpoint and Executor Job backend:
+
+```bash
+MEMIND_ORCHESTRATOR_DATABASE_URL='postgresql://...' \
+MEMIND_ORCHESTRATOR_SERVICE_TOKEN='...' \
+pnpm dev:orchestrator
+```
+
+Memory mode is intentionally opt-in and non-durable:
+
+```bash
+MEMIND_ORCHESTRATOR_CHECKPOINT_MODE=memory pnpm dev:orchestrator
+```
+
+The service binds to `127.0.0.1:8093` by default. Configure the same URL and
+service token in Portal, then enable `shadow` in `/ops/admin/orchestrator`.
+
+memindadm exposes the projection through:
+
+```text
+GET /admin-api/orchestrator/shadow-runs
+GET /admin-api/orchestrator/shadow-runs/:runId
+GET /admin-api/orchestrator/canary-readiness
+GET /admin-api/orchestrator/execution-plans
+```
+
+Selecting a Shadow Run in memindadm also reads the linked Executor Job through
+the Orchestrator API:
+
+```text
+GET /v1/executor-jobs/:jobId
+GET /v1/executor-jobs/:jobId/events?after=<cursor>&limit=<limit>
+POST /v1/executor-jobs
+POST /v1/workers/claim
+POST /v1/workers/jobs/:jobId/start
+POST /v1/workers/jobs/:jobId/heartbeat
+POST /v1/workers/jobs/:jobId/progress
+POST /v1/workers/jobs/:jobId/complete
+POST /v1/workers/jobs/:jobId/fail
+POST /v1/workers/recover-expired
+GET /v1/workers/stats
+```
+
+## Colima deployment
+
+Colima is the recommended first container host on macOS because this service and
+its PostgreSQL checkpoint database have an isolated Compose lifecycle:
+
+```bash
+cd deploy/orchestrator
+cp .env.example .env
+# Replace both example secrets before starting.
+docker compose up -d --build
+docker compose ps
+curl http://127.0.0.1:8093/ready
+```
+
+When Portal or the Shadow smoke process runs outside Compose, export the same
+service token into the child process environment. Plain `source` does not export
+new shell variables by itself:
+
+```bash
+set -a
+source deploy/orchestrator/.env
+set +a
+export MEMIND_ORCHESTRATOR_URL=http://127.0.0.1:8093
+pnpm dev
+```
+
+The Compose project:
+
+- publishes only the Orchestrator port on loopback;
+- does not publish PostgreSQL;
+- does not mount the Docker socket or a Memind workspace;
+- keeps PostgreSQL on a dedicated internal network while the service also joins
+  a separate edge network for its loopback-published port;
+- is not part of the Goosed Compose lifecycle.
+
+This local Compose artifact is not a production release path. Production still
+requires the repository release gates and a separately approved deployment.
+
+## Runtime environment
+
+| Variable | Purpose | Default |
+|---|---|---|
+| `MEMIND_ORCHESTRATOR_HOST` | HTTP bind address | `127.0.0.1` |
+| `MEMIND_ORCHESTRATOR_PORT` | HTTP port | `8093` |
+| `MEMIND_ORCHESTRATOR_SERVICE_TOKEN` | Bearer token for `/v1/*` | empty |
+| `MEMIND_ORCHESTRATOR_WORKER_TOKEN` | Additional worker-protocol token | empty |
+| `MEMIND_ORCHESTRATOR_EXECUTION_ENABLED` | Queue admission execution gate | `false` |
+| `MEMIND_ORCHESTRATOR_ENABLED_EXECUTORS` | Enabled adapter IDs | empty |
+| `MEMIND_ORCHESTRATOR_*_ALLOWLIST` | Tenant/user/workspace admission scopes | empty / workspace alias |
+| `MEMIND_ORCHESTRATOR_MAX_*` | Global, tenant, user and rate quotas | bounded safe defaults |
+| `MEMIND_ORCHESTRATOR_CHECKPOINT_MODE` | `postgres` or explicit `memory` | `postgres` |
+| `MEMIND_ORCHESTRATOR_DATABASE_URL` | Dedicated Orchestrator PostgreSQL URL | required |
+| `MEMIND_ORCHESTRATOR_DATABASE_SCHEMA` | Checkpoint and Executor Job schema | `memind_orchestrator` |
+
+## Extraction test
+
+The service is ready to move into a separate repository only when:
+
+1. it can run against a mock Memind control plane;
+2. it owns its checkpoint database and credentials;
+3. task inputs use resource references rather than host paths;
+4. executor calls use versioned adapters;
+5. moving the service requires only changing `ORCHESTRATOR_URL`.
diff --git a/services/orchestrator/admin-config.mjs b/services/orchestrator/admin-config.mjs
new file mode 100644
index 0000000..dedff21
--- /dev/null
+++ b/services/orchestrator/admin-config.mjs
@@ -0,0 +1,455 @@
+import {
+  DEFAULT_ORCHESTRATED_WORKFLOWS,
+  ORCHESTRATOR_MODE,
+  WORKFLOW_ENGINE,
+  normalizeStringList,
+  normalizeWorkflowEngineId,
+  normalizeWorkflowName,
+  stableRolloutBucket,
+} from './contracts.mjs';
+import { listPhase5ExecutorAdapters } from './executor-gateway.mjs';
+
+const CONFIG_TABLE = 'h5_orchestrator_admin_config';
+const CONFIG_SCOPE = 'global';
+const EXECUTION_HANDOFF_IMPLEMENTED = true;
+
+function normalizeBoolean(value, fallback = false) {
+  if (value == null || value === '') return fallback;
+  if (typeof value === 'boolean') return value;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'off'].includes(normalized)) return false;
+  return fallback;
+}
+
+function clampInteger(value, fallback, min, max) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(number)));
+}
+
+function normalizeMode(value, fallback = ORCHESTRATOR_MODE.OFF) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  return Object.values(ORCHESTRATOR_MODE).includes(normalized) ? normalized : fallback;
+}
+
+function normalizeServiceUrl(value) {
+  const raw = String(value ?? '').trim().replace(/\/$/, '');
+  if (!raw) return '';
+  try {
+    const url = new URL(raw);
+    if (!['http:', 'https:'].includes(url.protocol)) return '';
+    url.username = '';
+    url.password = '';
+    url.hash = '';
+    return url.toString().replace(/\/$/, '').slice(0, 2048);
+  } catch {
+    return '';
+  }
+}
+
+function parseJsonLike(value, fallback) {
+  if (value == null || value === '') return fallback;
+  if (typeof value === 'object') return value;
+  try {
+    return JSON.parse(String(value));
+  } catch {
+    return fallback;
+  }
+}
+
+function clone(value) {
+  if (typeof structuredClone === 'function') return structuredClone(value);
+  return JSON.parse(JSON.stringify(value));
+}
+
+export function defaultOrchestratorConfig() {
+  return {
+    mode: ORCHESTRATOR_MODE.OFF,
+    primaryEngine: WORKFLOW_ENGINE.LANGGRAPH,
+    fallbackEngine: WORKFLOW_ENGINE.NATIVE,
+    serviceUrl: '',
+    requestTimeoutMs: 5000,
+    rolloutPercent: 0,
+    userAllowlist: [],
+    workflowAllowlist: [...DEFAULT_ORCHESTRATED_WORKFLOWS],
+    fallbackToNative: true,
+    requireHealthy: true,
+    executionEnabled: false,
+  };
+}
+
+export function normalizeOrchestratorConfig(input = {}, fallback = defaultOrchestratorConfig()) {
+  const source = input && typeof input === 'object' && !Array.isArray(input) ? input : {};
+  const base = fallback && typeof fallback === 'object' ? fallback : defaultOrchestratorConfig();
+  const workflowAllowlist = normalizeStringList(
+    source.workflowAllowlist ?? base.workflowAllowlist,
+    { normalize: (item) => normalizeWorkflowName(item, ''), itemLimit: 128 },
+  );
+  return {
+    mode: normalizeMode(source.mode, base.mode),
+    primaryEngine: normalizeWorkflowEngineId(source.primaryEngine, base.primaryEngine),
+    fallbackEngine: normalizeWorkflowEngineId(source.fallbackEngine, base.fallbackEngine),
+    serviceUrl: normalizeServiceUrl(source.serviceUrl ?? base.serviceUrl),
+    requestTimeoutMs: clampInteger(
+      source.requestTimeoutMs,
+      base.requestTimeoutMs,
+      500,
+      60_000,
+    ),
+    rolloutPercent: clampInteger(source.rolloutPercent, base.rolloutPercent, 0, 100),
+    userAllowlist: normalizeStringList(source.userAllowlist ?? base.userAllowlist, {
+      itemLimit: 128,
+    }),
+    workflowAllowlist: workflowAllowlist.length
+      ? workflowAllowlist
+      : [...DEFAULT_ORCHESTRATED_WORKFLOWS],
+    fallbackToNative: normalizeBoolean(source.fallbackToNative, base.fallbackToNative),
+    requireHealthy: normalizeBoolean(source.requireHealthy, base.requireHealthy),
+    executionEnabled: normalizeBoolean(source.executionEnabled, base.executionEnabled),
+  };
+}
+
+function runtimeState(config, env = process.env) {
+  const killSwitch = normalizeBoolean(env.MEMIND_ORCHESTRATOR_KILL_SWITCH, false);
+  const environmentExecutionGate = normalizeBoolean(
+    env.MEMIND_ORCHESTRATOR_EXECUTION_HANDOFF_ENABLED,
+    false,
+  );
+  const configured = config.primaryEngine !== WORKFLOW_ENGINE.LANGGRAPH || Boolean(config.serviceUrl);
+  let reason = null;
+  if (killSwitch) reason = 'kill_switch';
+  else if (config.mode === ORCHESTRATOR_MODE.OFF) reason = 'mode_off';
+  else if (!configured) reason = 'service_url_missing';
+  const executionModeSelected = [ORCHESTRATOR_MODE.CANARY, ORCHESTRATOR_MODE.ACTIVE]
+    .includes(config.mode);
+  const executionHandoffRequested = config.executionEnabled
+    && executionModeSelected
+    && config.primaryEngine === WORKFLOW_ENGINE.LANGGRAPH;
+  const executionHandoffEnabled = !reason
+    && EXECUTION_HANDOFF_IMPLEMENTED
+    && environmentExecutionGate
+    && executionHandoffRequested
+    && config.primaryEngine === WORKFLOW_ENGINE.LANGGRAPH;
+  return {
+    killSwitch,
+    configured,
+    effective: !reason,
+    reason: reason ?? (
+      executionModeSelected
+      && config.primaryEngine === WORKFLOW_ENGINE.LANGGRAPH
+      && !executionHandoffEnabled
+        ? 'execution_gate_disabled'
+        : null
+    ),
+    executesLangGraph: executionHandoffEnabled,
+    plansLangGraph: !reason
+      && executionModeSelected
+      && config.primaryEngine === WORKFLOW_ENGINE.LANGGRAPH,
+    shadowsLangGraph: !reason
+      && config.mode === ORCHESTRATOR_MODE.SHADOW
+      && config.primaryEngine === WORKFLOW_ENGINE.LANGGRAPH,
+    executionHandoff: {
+      implemented: EXECUTION_HANDOFF_IMPLEMENTED,
+      requested: executionHandoffRequested,
+      enabled: executionHandoffEnabled,
+      reason: executionHandoffEnabled
+        ? null
+        : !EXECUTION_HANDOFF_IMPLEMENTED
+          ? 'execution_handoff_not_implemented'
+          : !environmentExecutionGate
+            ? 'environment_execution_gate_disabled'
+            : 'execution_handoff_not_requested',
+      environmentGate: environmentExecutionGate,
+    },
+  };
+}
+
+function engineCatalog(config) {
+  return [
+    {
+      id: WORKFLOW_ENGINE.NATIVE,
+      label: 'Native Agent Run',
+      kind: 'built-in',
+      configured: true,
+      capabilities: ['existing-runtime', 'tool-gateway'],
+    },
+    {
+      id: WORKFLOW_ENGINE.LANGGRAPH,
+      label: 'LangGraph Orchestrator',
+      kind: 'remote',
+      configured: Boolean(config.serviceUrl),
+      capabilities: ['durable-execution', 'interrupt', 'streaming'],
+    },
+  ];
+}
+
+async function probeServiceHealth(config, {
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  const checkedAt = Date.now();
+  if (!config.serviceUrl) {
+    return {
+      checkedAt,
+      ok: false,
+      status: 'unconfigured',
+      latencyMs: 0,
+      httpStatus: null,
+      details: null,
+    };
+  }
+  if (typeof fetchImpl !== 'function') {
+    return {
+      checkedAt,
+      ok: false,
+      status: 'fetch_unavailable',
+      latencyMs: 0,
+      httpStatus: null,
+      details: null,
+    };
+  }
+  const startedAt = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(),
+    Math.max(500, Number(config.requestTimeoutMs) || 5000),
+  );
+  try {
+    const response = await fetchImpl(`${config.serviceUrl}/ready`, {
+      headers: { accept: 'application/json' },
+      signal: controller.signal,
+    });
+    const body = await response.json().catch(() => null);
+    const healthy = response.ok && body?.status === 'ok';
+    return {
+      checkedAt,
+      ok: healthy,
+      status: healthy ? 'healthy' : 'unhealthy',
+      latencyMs: Math.max(0, Date.now() - startedAt),
+      httpStatus: response.status,
+      details: body && typeof body === 'object' ? {
+        service: body.service == null ? null : String(body.service).slice(0, 128),
+        checkpoint: body.checkpoint && typeof body.checkpoint === 'object' ? {
+          kind: body.checkpoint.kind == null ? null : String(body.checkpoint.kind).slice(0, 64),
+          durable: Boolean(body.checkpoint.durable),
+        } : null,
+        execution: body.execution == null ? null : String(body.execution).slice(0, 64),
+        executorGateway: body.executorGateway && typeof body.executorGateway === 'object' ? {
+          dispatchImplemented: body.executorGateway.dispatchImplemented === true,
+          executionEnabled: body.executorGateway.executionEnabled === true,
+          store: body.executorGateway.store && typeof body.executorGateway.store === 'object' ? {
+            kind: body.executorGateway.store.kind == null
+              ? null
+              : String(body.executorGateway.store.kind).slice(0, 64),
+            durable: body.executorGateway.store.durable === true,
+          } : null,
+        } : null,
+      } : null,
+    };
+  } catch (error) {
+    return {
+      checkedAt,
+      ok: false,
+      status: error?.name === 'AbortError' ? 'timeout' : 'unreachable',
+      latencyMs: Math.max(0, Date.now() - startedAt),
+      httpStatus: null,
+      details: null,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function ensureConfigTable(pool) {
+  await pool.query(`
+    CREATE TABLE IF NOT EXISTS ${CONFIG_TABLE} (
+      config_scope VARCHAR(32) PRIMARY KEY,
+      config_json JSON NOT NULL,
+      config_version INT NOT NULL DEFAULT 1,
+      updated_by CHAR(36) NULL,
+      updated_at BIGINT NOT NULL
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+  `);
+}
+
+async function loadStoredState(pool) {
+  await ensureConfigTable(pool);
+  const [rows] = await pool.query(
+    `SELECT config_json, config_version, updated_by, updated_at
+       FROM ${CONFIG_TABLE}
+      WHERE config_scope = ?
+      LIMIT 1`,
+    [CONFIG_SCOPE],
+  );
+  const row = rows[0];
+  if (!row) return null;
+  return {
+    config: normalizeOrchestratorConfig(parseJsonLike(row.config_json, {})),
+    configVersion: Math.max(1, Number(row.config_version ?? 1) || 1),
+    updatedBy: row.updated_by ?? null,
+    updatedAt: Number(row.updated_at ?? 0) || null,
+  };
+}
+
+export function createOrchestratorAdminConfigService(pool, {
+  env = process.env,
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  async function loadEffectiveState() {
+    const stored = await loadStoredState(pool);
+    if (stored) return { ...stored, source: 'admin-db' };
+    const config = normalizeOrchestratorConfig({
+      mode: env.MEMIND_ORCHESTRATOR_MODE,
+      serviceUrl: env.MEMIND_ORCHESTRATOR_URL,
+    });
+    const fromEnv = Boolean(env.MEMIND_ORCHESTRATOR_MODE || env.MEMIND_ORCHESTRATOR_URL);
+    return {
+      config,
+      configVersion: 1,
+      updatedBy: null,
+      updatedAt: null,
+      source: fromEnv ? 'env' : 'default',
+    };
+  }
+
+  return {
+    ensureSchema() {
+      return ensureConfigTable(pool);
+    },
+
+    async getAdminConfig() {
+      const state = await loadEffectiveState();
+      return {
+        ...state,
+        runtime: runtimeState(state.config, env),
+        engines: engineCatalog(state.config),
+        executors: listPhase5ExecutorAdapters(),
+      };
+    },
+
+    async updateAdminConfig(patch = {}, { updatedBy = null } = {}) {
+      const stored = await loadStoredState(pool);
+      const current = stored?.config ?? defaultOrchestratorConfig();
+      const nextConfig = normalizeOrchestratorConfig(
+        { ...current, ...(patch?.config ?? patch) },
+        current,
+      );
+      const configVersion = (stored?.configVersion ?? 0) + 1;
+      const now = Date.now();
+      await pool.query(
+        `INSERT INTO ${CONFIG_TABLE}
+          (config_scope, config_json, config_version, updated_by, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON DUPLICATE KEY UPDATE
+          config_json = VALUES(config_json),
+          config_version = VALUES(config_version),
+          updated_by = VALUES(updated_by),
+          updated_at = VALUES(updated_at)`,
+        [CONFIG_SCOPE, JSON.stringify(nextConfig), configVersion, updatedBy, now],
+      );
+      return this.getAdminConfig();
+    },
+
+    async getRuntimeState({ probe = false } = {}) {
+      const state = await loadEffectiveState();
+      return {
+        ...state,
+        runtime: runtimeState(state.config, env),
+        engines: engineCatalog(state.config),
+        executors: listPhase5ExecutorAdapters(),
+        ...(probe ? { serviceHealth: await probeServiceHealth(state.config, { fetchImpl }) } : {}),
+      };
+    },
+
+    async selectEngine({
+      runId,
+      requestId,
+      userId = null,
+      workflowName,
+    } = {}) {
+      const state = await loadEffectiveState();
+      const config = state.config;
+      const runtime = runtimeState(config, env);
+      const normalizedWorkflow = normalizeWorkflowName(workflowName, '');
+      const workflowMatched = config.workflowAllowlist.includes(normalizedWorkflow);
+      const base = {
+        engine: WORKFLOW_ENGINE.NATIVE,
+        candidateEngine: WORKFLOW_ENGINE.NATIVE,
+        shadowEngine: null,
+        fallbackEngine: config.fallbackToNative ? config.fallbackEngine : null,
+        mode: config.mode,
+        workflowMatched,
+        configVersion: state.configVersion,
+        reason: runtime.reason,
+        candidateReason: null,
+        dryRun: false,
+      };
+      if (!runtime.effective || !workflowMatched) {
+        return { ...base, reason: runtime.reason ?? 'workflow_not_enabled' };
+      }
+      const rolloutKey = runId || requestId || `${userId ?? ''}:${normalizedWorkflow}`;
+      const bucket = stableRolloutBucket(rolloutKey);
+      const explicitlyAllowed = Boolean(userId && config.userAllowlist.includes(String(userId)));
+      const percentAllowed = bucket < config.rolloutPercent;
+      const rolloutSelected = explicitlyAllowed || percentAllowed;
+      const rolloutReason = explicitlyAllowed
+        ? 'user_allowlist'
+        : percentAllowed
+          ? 'percentage'
+          : 'canary_not_selected';
+      if (config.mode === ORCHESTRATOR_MODE.SHADOW) {
+        return {
+          ...base,
+          shadowEngine: config.primaryEngine,
+          reason: 'shadow',
+          candidateEngine: rolloutSelected
+            ? config.primaryEngine
+            : WORKFLOW_ENGINE.NATIVE,
+          candidateReason: rolloutReason,
+          bucket,
+          dryRun: true,
+        };
+      }
+      if (config.mode === ORCHESTRATOR_MODE.ACTIVE) {
+        const selected = {
+          ...base,
+          candidateEngine: config.primaryEngine,
+          candidateReason: 'active',
+        };
+        if (config.primaryEngine === WORKFLOW_ENGINE.NATIVE) {
+          return { ...selected, reason: 'active' };
+        }
+        return runtime.executionHandoff.enabled
+          ? { ...selected, engine: config.primaryEngine, reason: 'active' }
+          : { ...selected, reason: 'execution_gate_disabled', dryRun: true };
+      }
+      if (config.mode === ORCHESTRATOR_MODE.CANARY) {
+        if (!rolloutSelected) {
+          return { ...base, reason: 'canary_not_selected', bucket };
+        }
+        const selected = {
+          ...base,
+          candidateEngine: config.primaryEngine,
+          candidateReason: rolloutReason,
+          bucket,
+        };
+        if (config.primaryEngine === WORKFLOW_ENGINE.NATIVE) {
+          return { ...selected, reason: rolloutReason };
+        }
+        return runtime.executionHandoff.enabled
+          ? { ...selected, engine: config.primaryEngine, reason: rolloutReason }
+          : { ...selected, reason: 'execution_gate_disabled', dryRun: true };
+      }
+      return base;
+    },
+  };
+}
+
+export const orchestratorAdminConfigInternals = {
+  CONFIG_SCOPE,
+  CONFIG_TABLE,
+  engineCatalog,
+  EXECUTION_HANDOFF_IMPLEMENTED,
+  probeServiceHealth,
+  runtimeState,
+};
diff --git a/services/orchestrator/admin-config.test.mjs b/services/orchestrator/admin-config.test.mjs
new file mode 100644
index 0000000..02a2722
--- /dev/null
+++ b/services/orchestrator/admin-config.test.mjs
@@ -0,0 +1,256 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  createOrchestratorAdminConfigService,
+  defaultOrchestratorConfig,
+  normalizeOrchestratorConfig,
+} from './admin-config.mjs';
+
+function createPool() {
+  let row = null;
+  return {
+    async query(sql, params = []) {
+      if (sql.includes('CREATE TABLE')) return [[], []];
+      if (sql.includes('SELECT config_json')) return [[...(row ? [row] : [])], []];
+      if (sql.includes('INSERT INTO')) {
+        row = {
+          config_json: params[1],
+          config_version: params[2],
+          updated_by: params[3],
+          updated_at: params[4],
+        };
+        return [{ affectedRows: 1 }, []];
+      }
+      throw new Error(`Unexpected SQL: ${sql}`);
+    },
+  };
+}
+
+test('orchestrator config defaults to a disabled native-safe runtime', async () => {
+  const service = createOrchestratorAdminConfigService(createPool(), { env: {} });
+  const state = await service.getAdminConfig();
+  assert.equal(state.config.mode, 'off');
+  assert.equal(state.config.primaryEngine, 'langgraph');
+  assert.equal(state.runtime.effective, false);
+  assert.equal(state.runtime.reason, 'mode_off');
+  assert.equal(state.engines.find((engine) => engine.id === 'native').configured, true);
+  assert.equal(state.engines.find((engine) => engine.id === 'langgraph').configured, false);
+  assert.deepEqual(
+    state.executors.map((executor) => executor.id),
+    ['goosed', 'aider', 'openhands'],
+  );
+  assert.equal(state.executors.every((executor) => executor.enabled === false), true);
+  assert.equal(
+    state.executors.every((executor) => executor.dispatchImplemented === true),
+    true,
+  );
+  assert.equal(state.config.executionEnabled, false);
+});
+
+test('orchestrator config normalizes unsafe values and keeps a workflow allowlist', () => {
+  const normalized = normalizeOrchestratorConfig({
+    mode: 'active',
+    serviceUrl: 'file:///tmp/graph',
+    requestTimeoutMs: 1,
+    rolloutPercent: 500,
+    workflowAllowlist: ['code-run-v1', 'INVALID WORKFLOW', 'code-run-v1'],
+  });
+  assert.equal(normalized.serviceUrl, '');
+  assert.equal(normalized.requestTimeoutMs, 500);
+  assert.equal(normalized.rolloutPercent, 100);
+  assert.deepEqual(normalized.workflowAllowlist, ['code-run-v1']);
+});
+
+test('orchestrator config persists versioned admin updates and selects canary users', async () => {
+  const service = createOrchestratorAdminConfigService(createPool(), { env: {} });
+  const updated = await service.updateAdminConfig({
+    ...defaultOrchestratorConfig(),
+    mode: 'canary',
+    serviceUrl: 'http://127.0.0.1:8093',
+    rolloutPercent: 0,
+    userAllowlist: ['user-1'],
+  }, { updatedBy: 'admin-1' });
+  assert.equal(updated.configVersion, 1);
+  assert.equal(updated.updatedBy, 'admin-1');
+  assert.equal(updated.runtime.effective, true);
+
+  const selected = await service.selectEngine({
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowName: 'code-run-v1',
+  });
+  assert.equal(selected.engine, 'native');
+  assert.equal(selected.candidateEngine, 'langgraph');
+  assert.equal(selected.reason, 'execution_gate_disabled');
+  assert.equal(selected.candidateReason, 'user_allowlist');
+  assert.equal(selected.dryRun, true);
+
+  const native = await service.selectEngine({
+    runId: 'run-2',
+    userId: 'user-2',
+    workflowName: 'code-run-v1',
+  });
+  assert.equal(native.engine, 'native');
+  assert.equal(native.candidateEngine, 'native');
+  assert.equal(native.reason, 'canary_not_selected');
+});
+
+test('orchestrator execution handoff remains disabled without both admin and environment gates', async () => {
+  const service = createOrchestratorAdminConfigService(createPool(), { env: {} });
+  await service.updateAdminConfig({
+    mode: 'active',
+    serviceUrl: 'http://127.0.0.1:8093',
+  });
+
+  const runtime = await service.getRuntimeState();
+  assert.equal(runtime.runtime.plansLangGraph, true);
+  assert.equal(runtime.runtime.executesLangGraph, false);
+  assert.deepEqual(runtime.runtime.executionHandoff, {
+    implemented: true,
+    requested: false,
+    enabled: false,
+    reason: 'environment_execution_gate_disabled',
+    environmentGate: false,
+  });
+
+  const selected = await service.selectEngine({
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowName: 'code-run-v1',
+  });
+  assert.equal(selected.engine, 'native');
+  assert.equal(selected.candidateEngine, 'langgraph');
+  assert.equal(selected.dryRun, true);
+});
+
+test('orchestrator selects LangGraph only when admin and environment execution gates agree', async () => {
+  const service = createOrchestratorAdminConfigService(createPool(), {
+    env: { MEMIND_ORCHESTRATOR_EXECUTION_HANDOFF_ENABLED: '1' },
+  });
+  await service.updateAdminConfig({
+    mode: 'canary',
+    serviceUrl: 'http://127.0.0.1:8093',
+    executionEnabled: true,
+    userAllowlist: ['user-1'],
+  });
+  const runtime = await service.getRuntimeState();
+  assert.equal(runtime.runtime.executesLangGraph, true);
+  assert.equal(runtime.runtime.executionHandoff.environmentGate, true);
+  const selected = await service.selectEngine({
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowName: 'code-run-v1',
+  });
+  assert.equal(selected.engine, 'langgraph');
+  assert.equal(selected.candidateEngine, 'langgraph');
+  assert.equal(selected.reason, 'user_allowlist');
+  assert.equal(selected.dryRun, false);
+});
+
+test('orchestrator keeps a Native primary as a non-dry-run Native selection', async () => {
+  const service = createOrchestratorAdminConfigService(createPool(), { env: {} });
+  await service.updateAdminConfig({
+    mode: 'active',
+    primaryEngine: 'native',
+  });
+
+  const selected = await service.selectEngine({
+    runId: 'run-native',
+    workflowName: 'code-run-v1',
+  });
+  assert.equal(selected.engine, 'native');
+  assert.equal(selected.candidateEngine, 'native');
+  assert.equal(selected.reason, 'active');
+  assert.equal(selected.dryRun, false);
+});
+
+test('Shadow mode evaluates the Canary rollout while Native remains effective', async () => {
+  const service = createOrchestratorAdminConfigService(createPool(), { env: {} });
+  await service.updateAdminConfig({
+    mode: 'shadow',
+    serviceUrl: 'http://127.0.0.1:8093',
+    rolloutPercent: 0,
+    userAllowlist: ['user-preview'],
+  });
+
+  const selected = await service.selectEngine({
+    runId: 'run-preview-selected',
+    userId: 'user-preview',
+    workflowName: 'code-run-v1',
+  });
+  assert.equal(selected.engine, 'native');
+  assert.equal(selected.shadowEngine, 'langgraph');
+  assert.equal(selected.candidateEngine, 'langgraph');
+  assert.equal(selected.candidateReason, 'user_allowlist');
+  assert.equal(selected.dryRun, true);
+
+  const native = await service.selectEngine({
+    runId: 'run-preview-native',
+    userId: 'user-native',
+    workflowName: 'code-run-v1',
+  });
+  assert.equal(native.engine, 'native');
+  assert.equal(native.shadowEngine, 'langgraph');
+  assert.equal(native.candidateEngine, 'native');
+  assert.equal(native.candidateReason, 'canary_not_selected');
+  assert.equal(native.dryRun, true);
+});
+
+test('orchestrator emergency kill switch always forces native selection', async () => {
+  const service = createOrchestratorAdminConfigService(createPool(), {
+    env: { MEMIND_ORCHESTRATOR_KILL_SWITCH: '1' },
+  });
+  await service.updateAdminConfig({
+    mode: 'active',
+    serviceUrl: 'http://127.0.0.1:8093',
+  });
+  const selected = await service.selectEngine({
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowName: 'code-run-v1',
+  });
+  assert.equal(selected.engine, 'native');
+  assert.equal(selected.reason, 'kill_switch');
+});
+
+test('orchestrator runtime probe reports sanitized service health', async () => {
+  let requestedUrl = null;
+  const service = createOrchestratorAdminConfigService(createPool(), {
+    env: {},
+    fetchImpl: async (url) => {
+      requestedUrl = url;
+      return new Response(JSON.stringify({
+        status: 'ok',
+        service: 'memind-langgraph-orchestrator',
+        checkpoint: { kind: 'postgres', durable: true, password: 'must-not-pass-through' },
+        execution: 'observe-only',
+        executorGateway: {
+          dispatchImplemented: false,
+          executionEnabled: false,
+          store: { kind: 'postgres', durable: true, password: 'must-not-pass-through' },
+          adapters: [{ id: 'goosed', secret: 'must-not-pass-through' }],
+        },
+        ignoredSecret: 'must-not-pass-through',
+      }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      });
+    },
+  });
+  await service.updateAdminConfig({
+    mode: 'shadow',
+    serviceUrl: 'http://127.0.0.1:8093',
+  });
+
+  const runtime = await service.getRuntimeState({ probe: true });
+  assert.equal(requestedUrl, 'http://127.0.0.1:8093/ready');
+  assert.equal(runtime.serviceHealth.ok, true);
+  assert.equal(runtime.serviceHealth.details.checkpoint.durable, true);
+  assert.deepEqual(runtime.serviceHealth.details.executorGateway, {
+    dispatchImplemented: false,
+    executionEnabled: false,
+    store: { kind: 'postgres', durable: true },
+  });
+  assert.equal('password' in runtime.serviceHealth.details.checkpoint, false);
+  assert.equal('ignoredSecret' in runtime.serviceHealth.details, false);
+});
diff --git a/services/orchestrator/app.mjs b/services/orchestrator/app.mjs
new file mode 100644
index 0000000..14319b9
--- /dev/null
+++ b/services/orchestrator/app.mjs
@@ -0,0 +1,300 @@
+import express from 'express';
+
+function errorStatus(error) {
+  if (Number.isInteger(error?.status)) return error.status;
+  if (['WORKFLOW_NOT_SUPPORTED', 'WORKFLOW_OBSERVE_ONLY_REQUIRED'].includes(error?.code)) {
+    return 422;
+  }
+  return 500;
+}
+
+function authorize(serviceToken) {
+  const expected = String(serviceToken ?? '').trim();
+  return (request, response, next) => {
+    if (!expected) return next();
+    if (request.get('authorization') === `Bearer ${expected}`) return next();
+    return response.status(401).json({
+      error: {
+        code: 'UNAUTHORIZED',
+        message: 'Missing or invalid service token',
+      },
+    });
+  };
+}
+
+function authorizeWorker(workerToken) {
+  const expected = String(workerToken ?? '').trim();
+  return (request, response, next) => {
+    if (!expected) return next();
+    if (request.get('x-orchestrator-worker-token') === expected) return next();
+    return response.status(401).json({
+      error: {
+        code: 'WORKER_UNAUTHORIZED',
+        message: 'Missing or invalid worker token',
+      },
+    });
+  };
+}
+
+function prometheusMetrics(metrics) {
+  const lines = [
+    '# HELP memind_orchestrator_executor_jobs Executor jobs by state.',
+    '# TYPE memind_orchestrator_executor_jobs gauge',
+  ];
+  for (const [status, count] of Object.entries(metrics.queue?.counts ?? {})) {
+    lines.push(`memind_orchestrator_executor_jobs{status="${status}"} ${Number(count) || 0}`);
+  }
+  lines.push(
+    '# HELP memind_orchestrator_executor_claimable Claimable executor jobs.',
+    '# TYPE memind_orchestrator_executor_claimable gauge',
+    `memind_orchestrator_executor_claimable ${Number(metrics.queue?.claimable) || 0}`,
+    '# HELP memind_orchestrator_executor_expired_leases Expired executor leases.',
+    '# TYPE memind_orchestrator_executor_expired_leases gauge',
+    `memind_orchestrator_executor_expired_leases ${Number(metrics.queue?.expiredLeases) || 0}`,
+    '# HELP memind_orchestrator_executor_workers Healthy registered workers.',
+    '# TYPE memind_orchestrator_executor_workers gauge',
+    `memind_orchestrator_executor_workers ${Number(metrics.queue?.healthyWorkers) || 0}`,
+    '# HELP memind_orchestrator_execution_enabled Whether executor queue admission is enabled.',
+    '# TYPE memind_orchestrator_execution_enabled gauge',
+    `memind_orchestrator_execution_enabled ${metrics.gateway?.executionEnabled ? 1 : 0}`,
+  );
+  return `${lines.join('\n')}\n`;
+}
+
+export function createOrchestratorApp({
+  runtime,
+  serviceToken = process.env.MEMIND_ORCHESTRATOR_SERVICE_TOKEN,
+  workerToken = process.env.MEMIND_ORCHESTRATOR_WORKER_TOKEN,
+} = {}) {
+  if (!runtime) throw new Error('Orchestrator app requires runtime');
+  const app = express();
+  app.disable('x-powered-by');
+  app.use(express.json({ limit: '256kb' }));
+
+  app.get('/health', (_request, response) => response.json(runtime.health()));
+  app.get('/ready', async (_request, response) => {
+    try {
+      return response.json(await runtime.ready());
+    } catch {
+      return response.status(503).json({
+        ...runtime.health(),
+        ready: false,
+      });
+    }
+  });
+  app.get('/metrics', async (_request, response, next) => {
+    try {
+      const metrics = await runtime.metrics();
+      return response
+        .type('text/plain; version=0.0.4; charset=utf-8')
+        .send(prometheusMetrics(metrics));
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.use('/v1', authorize(serviceToken));
+
+  app.post('/v1/runs', async (request, response, next) => {
+    try {
+      response.status(202).json(await runtime.start(request.body));
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.post('/v1/executor-jobs', async (request, response, next) => {
+    try {
+      const result = await runtime.submitExecutorJob(request.body);
+      return response.status(result.created ? 202 : 200).json(result);
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.get('/v1/runs/:runId', async (request, response, next) => {
+    try {
+      const state = await runtime.getState(request.params.runId);
+      if (!state) return response.status(404).json({ error: { code: 'RUN_NOT_FOUND' } });
+      return response.json(state);
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.get('/v1/runs/:runId/events', async (request, response, next) => {
+    try {
+      const result = await runtime.listEvents(request.params.runId, {
+        after: request.query.after,
+      });
+      if (!result) return response.status(404).json({ error: { code: 'RUN_NOT_FOUND' } });
+      return response.json(result);
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.post('/v1/runs/:runId/resume', async (request, response, next) => {
+    try {
+      const state = await runtime.resume(request.params.runId, request.body);
+      if (!state) return response.status(404).json({ error: { code: 'RUN_NOT_FOUND' } });
+      return response.json(state);
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.post('/v1/runs/:runId/cancel', async (request, response, next) => {
+    try {
+      const state = await runtime.cancel(request.params.runId, request.body);
+      if (!state) return response.status(404).json({ error: { code: 'RUN_NOT_FOUND' } });
+      return response.json(state);
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.get('/v1/executor-jobs/:jobId', async (request, response, next) => {
+    try {
+      const job = await runtime.getExecutorJob(request.params.jobId);
+      if (!job) {
+        return response.status(404).json({ error: { code: 'EXECUTOR_JOB_NOT_FOUND' } });
+      }
+      return response.json(job);
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.get('/v1/executor-jobs/:jobId/events', async (request, response, next) => {
+    try {
+      const result = await runtime.listExecutorJobEvents(request.params.jobId, {
+        after: request.query.after,
+        limit: request.query.limit,
+      });
+      if (!result) {
+        return response.status(404).json({ error: { code: 'EXECUTOR_JOB_NOT_FOUND' } });
+      }
+      return response.json(result);
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  const requireWorker = authorizeWorker(workerToken);
+
+  app.post('/v1/workers/claim', requireWorker, async (request, response, next) => {
+    try {
+      const claim = await runtime.claimExecutorJob(request.body);
+      return claim ? response.json(claim) : response.status(204).end();
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.post(
+    '/v1/workers/jobs/:jobId/start',
+    requireWorker,
+    async (request, response, next) => {
+      try {
+        return response.json(await runtime.startExecutorJob(request.params.jobId, request.body));
+      } catch (error) {
+        return next(error);
+      }
+    },
+  );
+
+  app.post(
+    '/v1/workers/jobs/:jobId/heartbeat',
+    requireWorker,
+    async (request, response, next) => {
+      try {
+        return response.json(await runtime.heartbeatExecutorJob(request.params.jobId, request.body));
+      } catch (error) {
+        return next(error);
+      }
+    },
+  );
+
+  app.post(
+    '/v1/workers/jobs/:jobId/progress',
+    requireWorker,
+    async (request, response, next) => {
+      try {
+        return response.json(await runtime.progressExecutorJob(request.params.jobId, request.body));
+      } catch (error) {
+        return next(error);
+      }
+    },
+  );
+
+  app.post(
+    '/v1/workers/jobs/:jobId/complete',
+    requireWorker,
+    async (request, response, next) => {
+      try {
+        return response.json(await runtime.completeExecutorJob(request.params.jobId, request.body));
+      } catch (error) {
+        return next(error);
+      }
+    },
+  );
+
+  app.post(
+    '/v1/workers/jobs/:jobId/fail',
+    requireWorker,
+    async (request, response, next) => {
+      try {
+        return response.json(await runtime.failExecutorJob(request.params.jobId, request.body));
+      } catch (error) {
+        return next(error);
+      }
+    },
+  );
+
+  app.post('/v1/workers/recover-expired', requireWorker, async (request, response, next) => {
+    try {
+      return response.json(await runtime.recoverExpiredExecutorJobs(request.body));
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.get('/v1/workers/stats', requireWorker, async (_request, response, next) => {
+    try {
+      return response.json(await runtime.getExecutorQueueStats());
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.post('/v1/executor-jobs/:jobId/cancel', async (request, response, next) => {
+    try {
+      const job = await runtime.cancelExecutorJob(request.params.jobId, request.body);
+      if (!job) {
+        return response.status(404).json({ error: { code: 'EXECUTOR_JOB_NOT_FOUND' } });
+      }
+      return response.json(job);
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  app.use((error, _request, response, _next) => {
+    response.status(errorStatus(error)).json({
+      error: {
+        code: error?.code ?? 'ORCHESTRATOR_ERROR',
+        message: error instanceof Error ? error.message : 'Orchestrator request failed',
+      },
+    });
+  });
+
+  return app;
+}
+
+export const orchestratorAppInternals = {
+  authorize,
+  authorizeWorker,
+  errorStatus,
+  prometheusMetrics,
+};
diff --git a/services/orchestrator/app.test.mjs b/services/orchestrator/app.test.mjs
new file mode 100644
index 0000000..d8f422f
--- /dev/null
+++ b/services/orchestrator/app.test.mjs
@@ -0,0 +1,223 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { MemorySaver } from '@langchain/langgraph';
+import { createOrchestratorApp } from './app.mjs';
+import { createLangGraphOrchestratorRuntime } from './runtime.mjs';
+
+async function listen(app) {
+  const server = await new Promise((resolve) => {
+    const candidate = app.listen(0, '127.0.0.1', () => resolve(candidate));
+  });
+  const address = server.address();
+  return {
+    baseUrl: `http://127.0.0.1:${address.port}`,
+    close: () => new Promise((resolve, reject) => {
+      server.close((error) => (error ? reject(error) : resolve()));
+    }),
+  };
+}
+
+function spec() {
+  return {
+    runId: 'http-shadow-1',
+    requestId: 'http-request-1',
+    workflow: { name: 'code-run-v1', version: 1 },
+    input: { instruction: 'Inspect without executing' },
+    policy: { executionMode: 'observe-only', sideEffectsAllowed: false },
+  };
+}
+
+test('orchestrator HTTP API exposes health and authenticated run endpoints', async (t) => {
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: new MemorySaver(),
+    checkpointKind: 'memory',
+  });
+  const server = await listen(createOrchestratorApp({
+    runtime,
+    serviceToken: 'test-service-token',
+  }));
+  t.after(server.close);
+
+  const health = await fetch(`${server.baseUrl}/health`);
+  assert.equal(health.status, 200);
+  const healthBody = await health.json();
+  assert.equal(healthBody.execution, 'observe-only');
+  assert.equal(healthBody.executorGateway.executionEnabled, false);
+  assert.deepEqual(healthBody.executorGateway.store, {
+    kind: 'memory',
+    durable: false,
+  });
+  const ready = await fetch(`${server.baseUrl}/ready`);
+  assert.equal(ready.status, 200);
+  assert.equal((await ready.json()).ready, true);
+  const metrics = await fetch(`${server.baseUrl}/metrics`);
+  assert.equal(metrics.status, 200);
+  assert.match(await metrics.text(), /memind_orchestrator_execution_enabled 0/);
+
+  const unauthorized = await fetch(`${server.baseUrl}/v1/runs`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(spec()),
+  });
+  assert.equal(unauthorized.status, 401);
+  const unauthorizedExecutorJob = await fetch(
+    `${server.baseUrl}/v1/executor-jobs/http-shadow-1%3Aexecutor-preview`,
+  );
+  assert.equal(unauthorizedExecutorJob.status, 401);
+
+  const created = await fetch(`${server.baseUrl}/v1/runs`, {
+    method: 'POST',
+    headers: {
+      authorization: 'Bearer test-service-token',
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(spec()),
+  });
+  assert.equal(created.status, 202);
+  assert.equal((await created.json()).status, 'succeeded');
+
+  const events = await fetch(`${server.baseUrl}/v1/runs/http-shadow-1/events?after=1`, {
+    headers: { authorization: 'Bearer test-service-token' },
+  });
+  const eventBody = await events.json();
+  assert.equal(events.status, 200);
+  assert.deepEqual(eventBody.events.map((event) => event.sequence), [2, 3]);
+
+  const jobId = 'http-shadow-1:executor-preview';
+  const executorJob = await fetch(
+    `${server.baseUrl}/v1/executor-jobs/${encodeURIComponent(jobId)}`,
+    { headers: { authorization: 'Bearer test-service-token' } },
+  );
+  assert.equal(executorJob.status, 200);
+  assert.equal((await executorJob.json()).status, 'blocked');
+
+  const executorEvents = await fetch(
+    `${server.baseUrl}/v1/executor-jobs/${encodeURIComponent(jobId)}/events?after=0`,
+    { headers: { authorization: 'Bearer test-service-token' } },
+  );
+  const executorEventBody = await executorEvents.json();
+  assert.equal(executorEvents.status, 200);
+  assert.deepEqual(
+    executorEventBody.events.map((event) => event.type),
+    ['executor_job_blocked'],
+  );
+  assert.equal(executorEventBody.nextCursor, 1);
+});
+
+test('orchestrator HTTP API reports missing runs and observe-only violations', async (t) => {
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: new MemorySaver(),
+  });
+  const server = await listen(createOrchestratorApp({ runtime }));
+  t.after(server.close);
+
+  const missing = await fetch(`${server.baseUrl}/v1/runs/missing`);
+  assert.equal(missing.status, 404);
+  const missingExecutorJob = await fetch(`${server.baseUrl}/v1/executor-jobs/missing`);
+  assert.equal(missingExecutorJob.status, 404);
+  assert.equal((await missingExecutorJob.json()).error.code, 'EXECUTOR_JOB_NOT_FOUND');
+
+  const activeSpec = spec();
+  activeSpec.runId = 'http-active-1';
+  activeSpec.policy = { executionMode: 'active', sideEffectsAllowed: true };
+  const rejected = await fetch(`${server.baseUrl}/v1/runs`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(activeSpec),
+  });
+  assert.equal(rejected.status, 422);
+  assert.equal((await rejected.json()).error.code, 'WORKFLOW_OBSERVE_ONLY_REQUIRED');
+});
+
+test('executor worker HTTP protocol requires both service and worker credentials', async (t) => {
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: new MemorySaver(),
+    executionEnabled: true,
+    enabledExecutors: ['goosed'],
+  });
+  const server = await listen(createOrchestratorApp({
+    runtime,
+    serviceToken: 'service-token',
+    workerToken: 'worker-token',
+  }));
+  t.after(server.close);
+  const serviceHeaders = {
+    authorization: 'Bearer service-token',
+    'content-type': 'application/json',
+  };
+  const submitted = await fetch(`${server.baseUrl}/v1/executor-jobs`, {
+    method: 'POST',
+    headers: serviceHeaders,
+    body: JSON.stringify({
+      jobId: 'http-worker-job-1',
+      idempotencyKey: 'http-worker-idem-1',
+      executor: 'goosed',
+      task: {
+        instruction: 'Run the canary',
+        workspaceRef: { kind: 'workspace-alias', id: 'canary' },
+      },
+      subject: { tenantId: 'tenant-1', userId: 'user-1' },
+      authorization: { executionAllowed: true },
+      policy: { sideEffectsAllowed: true },
+    }),
+  });
+  assert.equal(submitted.status, 202);
+  assert.equal((await submitted.json()).job.status, 'queued');
+
+  const unauthorizedWorker = await fetch(`${server.baseUrl}/v1/workers/claim`, {
+    method: 'POST',
+    headers: serviceHeaders,
+    body: JSON.stringify({ workerId: 'worker-1', executors: ['goosed'] }),
+  });
+  assert.equal(unauthorizedWorker.status, 401);
+  assert.equal((await unauthorizedWorker.json()).error.code, 'WORKER_UNAUTHORIZED');
+
+  const workerHeaders = {
+    ...serviceHeaders,
+    'x-orchestrator-worker-token': 'worker-token',
+  };
+  const claimResponse = await fetch(`${server.baseUrl}/v1/workers/claim`, {
+    method: 'POST',
+    headers: workerHeaders,
+    body: JSON.stringify({ workerId: 'worker-1', executors: ['goosed'] }),
+  });
+  assert.equal(claimResponse.status, 200);
+  const claim = await claimResponse.json();
+  assert.equal(claim.job.request.task.instruction, 'Run the canary');
+
+  const started = await fetch(
+    `${server.baseUrl}/v1/workers/jobs/http-worker-job-1/start`,
+    {
+      method: 'POST',
+      headers: workerHeaders,
+      body: JSON.stringify({ leaseToken: claim.leaseToken }),
+    },
+  );
+  assert.equal(started.status, 200);
+
+  const completed = await fetch(
+    `${server.baseUrl}/v1/workers/jobs/http-worker-job-1/complete`,
+    {
+      method: 'POST',
+      headers: workerHeaders,
+      body: JSON.stringify({
+        leaseToken: claim.leaseToken,
+        result: {
+          summary: 'completed',
+          artifactRefs: [{ kind: 'canary-result', id: 'result-1' }],
+        },
+      }),
+    },
+  );
+  assert.equal(completed.status, 200);
+  assert.equal((await completed.json()).status, 'succeeded');
+
+  const projected = await fetch(
+    `${server.baseUrl}/v1/executor-jobs/http-worker-job-1`,
+    { headers: { authorization: 'Bearer service-token' } },
+  );
+  const projectedBody = await projected.json();
+  assert.equal(projectedBody.status, 'succeeded');
+  assert.equal('request' in projectedBody, false);
+  assert.equal('token' in (projectedBody.lease ?? {}), false);
+});
diff --git a/services/orchestrator/checkpoint.mjs b/services/orchestrator/checkpoint.mjs
new file mode 100644
index 0000000..275fd86
--- /dev/null
+++ b/services/orchestrator/checkpoint.mjs
@@ -0,0 +1,74 @@
+import { MemorySaver } from '@langchain/langgraph';
+import { PostgresSaver } from '@langchain/langgraph-checkpoint-postgres';
+
+const DEFAULT_POSTGRES_SCHEMA = 'memind_orchestrator';
+
+function normalizeMode(value) {
+  const mode = String(value ?? 'postgres').trim().toLowerCase();
+  if (mode === 'memory' || mode === 'postgres') return mode;
+  throw new Error(`Unsupported orchestrator checkpoint mode: ${value}`);
+}
+
+function normalizeSchema(value) {
+  const schema = String(value ?? DEFAULT_POSTGRES_SCHEMA).trim();
+  if (!/^[a-z_][a-z0-9_]{0,62}$/i.test(schema)) {
+    throw new Error('Invalid orchestrator PostgreSQL schema');
+  }
+  return schema;
+}
+
+export async function createOrchestratorCheckpoint({
+  mode = process.env.MEMIND_ORCHESTRATOR_CHECKPOINT_MODE,
+  connectionString = process.env.MEMIND_ORCHESTRATOR_DATABASE_URL,
+  schema = process.env.MEMIND_ORCHESTRATOR_DATABASE_SCHEMA,
+} = {}) {
+  const normalizedMode = normalizeMode(mode);
+  if (normalizedMode === 'memory') {
+    return {
+      kind: 'memory',
+      durable: false,
+      checkpointer: new MemorySaver(),
+      async probe() {
+        return true;
+      },
+      async close() {},
+    };
+  }
+
+  const normalizedConnectionString = String(connectionString ?? '').trim();
+  if (!normalizedConnectionString) {
+    const error = new Error(
+      'MEMIND_ORCHESTRATOR_DATABASE_URL is required when checkpoint mode is postgres',
+    );
+    error.code = 'ORCHESTRATOR_DATABASE_URL_REQUIRED';
+    throw error;
+  }
+
+  const checkpointer = PostgresSaver.fromConnString(normalizedConnectionString, {
+    schema: normalizeSchema(schema),
+  });
+  await checkpointer.setup();
+  return {
+    kind: 'postgres',
+    durable: true,
+    checkpointer,
+    async probe() {
+      await checkpointer.getTuple({
+        configurable: {
+          thread_id: '__orchestrator_readiness__',
+          checkpoint_ns: '',
+        },
+      });
+      return true;
+    },
+    async close() {
+      await checkpointer.end();
+    },
+  };
+}
+
+export const orchestratorCheckpointInternals = {
+  DEFAULT_POSTGRES_SCHEMA,
+  normalizeMode,
+  normalizeSchema,
+};
diff --git a/services/orchestrator/checkpoint.test.mjs b/services/orchestrator/checkpoint.test.mjs
new file mode 100644
index 0000000..c68b56a
--- /dev/null
+++ b/services/orchestrator/checkpoint.test.mjs
@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  createOrchestratorCheckpoint,
+  orchestratorCheckpointInternals,
+} from './checkpoint.mjs';
+
+test('checkpoint defaults to durable PostgreSQL and fails closed without a URL', async () => {
+  await assert.rejects(
+    createOrchestratorCheckpoint({ mode: undefined, connectionString: '' }),
+    (error) => error.code === 'ORCHESTRATOR_DATABASE_URL_REQUIRED',
+  );
+});
+
+test('memory checkpoint is explicitly non-durable', async () => {
+  const checkpoint = await createOrchestratorCheckpoint({ mode: 'memory' });
+  assert.equal(checkpoint.kind, 'memory');
+  assert.equal(checkpoint.durable, false);
+  assert.equal(typeof checkpoint.checkpointer.getTuple, 'function');
+  await checkpoint.close();
+});
+
+test('checkpoint schema accepts identifiers and rejects SQL fragments', () => {
+  assert.equal(
+    orchestratorCheckpointInternals.normalizeSchema('memind_orchestrator_v2'),
+    'memind_orchestrator_v2',
+  );
+  assert.throws(
+    () => orchestratorCheckpointInternals.normalizeSchema('public; drop schema public'),
+    /Invalid orchestrator PostgreSQL schema/,
+  );
+});
diff --git a/services/orchestrator/code-run-shadow-graph.mjs b/services/orchestrator/code-run-shadow-graph.mjs
new file mode 100644
index 0000000..19f0beb
--- /dev/null
+++ b/services/orchestrator/code-run-shadow-graph.mjs
@@ -0,0 +1,209 @@
+import crypto from 'node:crypto';
+import {
+  Annotation,
+  END,
+  START,
+  StateGraph,
+} from '@langchain/langgraph';
+import {
+  buildRunEvent,
+  normalizeRunSpec,
+} from './contracts.mjs';
+
+export const CODE_RUN_SHADOW_WORKFLOW = 'code-run-v1';
+
+const ShadowState = Annotation.Root({
+  spec: Annotation(),
+  status: Annotation({
+    reducer: (_current, update) => update,
+    default: () => 'queued',
+  }),
+  phase: Annotation({
+    reducer: (_current, update) => update,
+    default: () => 'accepted',
+  }),
+  plan: Annotation({
+    reducer: (_current, update) => update,
+    default: () => null,
+  }),
+  result: Annotation({
+    reducer: (_current, update) => update,
+    default: () => null,
+  }),
+  events: Annotation({
+    reducer: (current, update) => [...current, ...update],
+    default: () => [],
+  }),
+});
+
+function executorIdentityForRun(runId) {
+  const normalizedRunId = String(runId ?? '').trim();
+  const jobId = `${normalizedRunId}:executor-preview`;
+  if (/^[a-zA-Z0-9:_-]+$/.test(normalizedRunId) && jobId.length <= 128) {
+    return {
+      jobId,
+      idempotencyKey: `${normalizedRunId}:build_plan:v1`,
+    };
+  }
+  const digest = crypto.createHash('sha256').update(normalizedRunId).digest('hex');
+  return {
+    jobId: `run_${digest}:executor-preview`,
+    idempotencyKey: `run_${digest}:build_plan:v1`,
+  };
+}
+
+function eventFor(state, type, data = null) {
+  return buildRunEvent({
+    runId: state.spec.runId,
+    sequence: state.events.length + 1,
+    type,
+    data,
+  });
+}
+
+function validateNode(state, { executionEnabled = false } = {}) {
+  const spec = normalizeRunSpec(state.spec);
+  if (spec.workflow.name !== CODE_RUN_SHADOW_WORKFLOW) {
+    const error = new Error(`Unsupported workflow: ${spec.workflow.name}`);
+    error.code = 'WORKFLOW_NOT_SUPPORTED';
+    throw error;
+  }
+  const observeOnly = spec.policy.executionMode === 'observe-only'
+    && spec.policy.sideEffectsAllowed === false;
+  const active = spec.policy.executionMode === 'active'
+    && spec.policy.sideEffectsAllowed === true
+    && executionEnabled;
+  if (!observeOnly && !active) {
+    const error = new Error(
+      executionEnabled
+        ? 'LangGraph run policy must be observe-only or explicitly active'
+        : 'LangGraph execution is disabled; only observe-only runs are accepted',
+    );
+    error.code = 'WORKFLOW_OBSERVE_ONLY_REQUIRED';
+    throw error;
+  }
+  return {
+    spec,
+    status: 'running',
+    phase: 'validated',
+    events: [eventFor(state, 'workflow_validated', {
+      workflow: spec.workflow,
+      executionMode: spec.policy.executionMode,
+    })],
+  };
+}
+
+async function planNode(state, executorGateway) {
+  const taskType = String(state.spec.input?.taskType ?? '').trim() || 'code-change';
+  const instruction = String(state.spec.input?.instruction ?? '');
+  const executorIdentity = executorIdentityForRun(state.spec.runId);
+  const active = state.spec.policy.executionMode === 'active';
+  const executor = String(state.spec.input?.executor ?? 'goosed').trim().toLowerCase();
+  const executorJob = await executorGateway.createJob({
+    jobId: executorIdentity.jobId,
+    idempotencyKey: executorIdentity.idempotencyKey,
+    executor,
+    task: {
+      type: taskType,
+      instruction,
+      workspaceRef: state.spec.input?.workspaceRef ?? null,
+      inputRefs: state.spec.input?.inputRefs ?? [],
+    },
+    subject: state.spec.subject,
+    authorization: {
+      executionAllowed: active,
+      actorId: state.spec.subject?.userId ?? null,
+    },
+    policy: {
+      sideEffectsAllowed: active && state.spec.policy.sideEffectsAllowed === true,
+      networkAllowed: active && state.spec.policy.networkAllowed === true,
+    },
+    controls: {
+      timeoutMs: state.spec.limits?.timeoutMs,
+      cancellationAllowed: true,
+      fallbackExecutor: 'aider',
+      maxAttempts: state.spec.limits?.maxAttempts,
+    },
+    metadata: {
+      source: 'langgraph-shadow-plan',
+      workflow: state.spec.workflow,
+    },
+  });
+  const plan = {
+    taskType,
+    executorAdapter: active ? 'executor-gateway' : 'native-agent-run',
+    executorJob: {
+      kind: 'executor-job',
+      id: executorJob.job.jobId,
+      executor: executorJob.job.executor,
+      status: executorJob.job.status,
+      reason: executorJob.job.reason,
+      durable: executorGateway.status().store.durable,
+    },
+    instructionCharacters: instruction.length,
+    steps: [
+      'accept_control_plane_run',
+      'project_executor_boundary',
+      'record_shadow_result',
+    ],
+  };
+  return {
+    phase: 'planned',
+    plan,
+    events: [eventFor(state, 'workflow_planned', {
+      taskType,
+      executorAdapter: plan.executorAdapter,
+      executorJob: plan.executorJob,
+      stepCount: plan.steps.length,
+    })],
+  };
+}
+
+function finalizeNode(state) {
+  const queued = state.plan.executorJob.status === 'queued';
+  const result = {
+    observed: !queued,
+    executed: false,
+    executorAdapter: state.plan.executorAdapter,
+    taskType: state.plan.taskType,
+  };
+  return {
+    status: queued ? 'waiting' : 'succeeded',
+    phase: queued ? 'executor_queued' : 'completed',
+    result,
+    events: [eventFor(
+      state,
+      queued ? 'workflow_executor_queued' : 'workflow_completed',
+      result,
+    )],
+  };
+}
+
+export function createCodeRunShadowGraph({
+  checkpointer,
+  executorGateway,
+  executionEnabled = false,
+} = {}) {
+  if (!checkpointer) throw new Error('Code run shadow graph requires a checkpointer');
+  if (!executorGateway?.createJob) {
+    throw new Error('Code run shadow graph requires an Executor Gateway');
+  }
+  return new StateGraph(ShadowState)
+    .addNode('validate_run', (state) => validateNode(state, { executionEnabled }))
+    .addNode('build_plan', (state) => planNode(state, executorGateway))
+    .addNode('finalize_run', finalizeNode)
+    .addEdge(START, 'validate_run')
+    .addEdge('validate_run', 'build_plan')
+    .addEdge('build_plan', 'finalize_run')
+    .addEdge('finalize_run', END)
+    .compile({ checkpointer });
+}
+
+export const codeRunShadowGraphInternals = {
+  ShadowState,
+  executorIdentityForRun,
+  eventFor,
+  validateNode,
+  planNode,
+  finalizeNode,
+};
diff --git a/services/orchestrator/contracts.mjs b/services/orchestrator/contracts.mjs
new file mode 100644
index 0000000..62d2a61
--- /dev/null
+++ b/services/orchestrator/contracts.mjs
@@ -0,0 +1,104 @@
+import crypto from 'node:crypto';
+
+export const ORCHESTRATOR_MODE = Object.freeze({
+  OFF: 'off',
+  SHADOW: 'shadow',
+  CANARY: 'canary',
+  ACTIVE: 'active',
+});
+
+export const WORKFLOW_ENGINE = Object.freeze({
+  NATIVE: 'native',
+  LANGGRAPH: 'langgraph',
+});
+
+export const DEFAULT_ORCHESTRATED_WORKFLOWS = Object.freeze([
+  'code-run-v1',
+]);
+
+const ENGINE_ID_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
+const WORKFLOW_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,127}$/;
+
+function normalizeIdentifier(value, pattern, fallback) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  return pattern.test(normalized) ? normalized : fallback;
+}
+
+export function normalizeWorkflowEngineId(value, fallback = WORKFLOW_ENGINE.NATIVE) {
+  return normalizeIdentifier(value, ENGINE_ID_PATTERN, fallback);
+}
+
+export function normalizeWorkflowName(value, fallback = '') {
+  return normalizeIdentifier(value, WORKFLOW_NAME_PATTERN, fallback);
+}
+
+export function normalizeStringList(value, {
+  limit = 200,
+  itemLimit = 128,
+  normalize = (item) => String(item ?? '').trim(),
+} = {}) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value
+    .map((item) => normalize(item).slice(0, itemLimit))
+    .filter(Boolean))]
+    .slice(0, limit);
+}
+
+export function normalizeRunSpec(input = {}) {
+  const source = input && typeof input === 'object' && !Array.isArray(input) ? input : {};
+  const requestId = String(source.requestId ?? '').trim();
+  const runId = String(source.runId ?? crypto.randomUUID()).trim();
+  const workflowName = normalizeWorkflowName(
+    source.workflow?.name ?? source.workflowName,
+  );
+  if (!requestId) throw new Error('RunSpec requires requestId');
+  if (!runId) throw new Error('RunSpec requires runId');
+  if (!workflowName) throw new Error('RunSpec requires workflow.name');
+  return {
+    version: 'orchestrator-run-v1',
+    runId,
+    requestId,
+    workflow: {
+      name: workflowName,
+      version: Math.max(1, Number(source.workflow?.version ?? 1) || 1),
+    },
+    subject: {
+      tenantId: String(source.subject?.tenantId ?? '').trim() || null,
+      userId: String(source.subject?.userId ?? '').trim() || null,
+    },
+    input: source.input && typeof source.input === 'object' ? structuredClone(source.input) : {},
+    policy: source.policy && typeof source.policy === 'object' ? structuredClone(source.policy) : {},
+    limits: source.limits && typeof source.limits === 'object' ? structuredClone(source.limits) : {},
+    metadata: source.metadata && typeof source.metadata === 'object'
+      ? structuredClone(source.metadata)
+      : {},
+  };
+}
+
+export function buildRunEvent({
+  eventId = crypto.randomUUID(),
+  runId,
+  sequence,
+  type,
+  timestamp = Date.now(),
+  data = null,
+} = {}) {
+  const normalizedRunId = String(runId ?? '').trim();
+  const normalizedType = String(type ?? '').trim();
+  if (!normalizedRunId) throw new Error('RunEvent requires runId');
+  if (!normalizedType) throw new Error('RunEvent requires type');
+  return {
+    version: 'orchestrator-event-v1',
+    eventId: String(eventId),
+    runId: normalizedRunId,
+    sequence: Math.max(0, Number(sequence ?? 0) || 0),
+    type: normalizedType,
+    timestamp: Number(timestamp) || Date.now(),
+    data: data == null ? null : structuredClone(data),
+  };
+}
+
+export function stableRolloutBucket(value) {
+  const hash = crypto.createHash('sha256').update(String(value ?? '')).digest();
+  return hash.readUInt32BE(0) % 100;
+}
diff --git a/services/orchestrator/contracts.test.mjs b/services/orchestrator/contracts.test.mjs
new file mode 100644
index 0000000..d53b0cf
--- /dev/null
+++ b/services/orchestrator/contracts.test.mjs
@@ -0,0 +1,98 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildRunEvent,
+  normalizeRunSpec,
+  stableRolloutBucket,
+} from './contracts.mjs';
+import {
+  createRemoteWorkflowEngine,
+  createWorkflowEngineRegistry,
+} from './engine-registry.mjs';
+
+test('orchestrator contracts normalize run specs without exposing framework types', () => {
+  const spec = normalizeRunSpec({
+    runId: 'run-1',
+    requestId: 'request-1',
+    workflow: { name: 'code-run-v1', version: 2 },
+    subject: { userId: 'user-1' },
+    input: { instruction: 'fix tests' },
+  });
+  assert.equal(spec.version, 'orchestrator-run-v1');
+  assert.equal(spec.workflow.name, 'code-run-v1');
+  assert.equal(spec.workflow.version, 2);
+  assert.equal(spec.subject.userId, 'user-1');
+
+  const event = buildRunEvent({
+    runId: spec.runId,
+    sequence: 1,
+    type: 'workflow.started',
+  });
+  assert.equal(event.version, 'orchestrator-event-v1');
+  assert.equal(event.type, 'workflow.started');
+  assert.equal(stableRolloutBucket('run-1'), stableRolloutBucket('run-1'));
+});
+
+test('workflow engine registry enforces the framework-neutral contract', () => {
+  const engine = {
+    id: 'native',
+    start() {},
+    resume() {},
+    cancel() {},
+    getState() {},
+    async *streamEvents() {},
+  };
+  const registry = createWorkflowEngineRegistry([engine]);
+  assert.equal(registry.has('native'), true);
+  assert.equal(registry.get('native'), engine);
+  assert.throws(
+    () => registry.register({ id: 'broken' }),
+    /missing methods/,
+  );
+});
+
+test('remote workflow engine speaks only the versioned orchestrator HTTP contract', async () => {
+  const calls = [];
+  const engine = createRemoteWorkflowEngine({
+    baseUrl: 'http://orchestrator.internal',
+    fetchImpl: async (url, init) => {
+      calls.push({ url, init });
+      return {
+        ok: true,
+        async json() {
+          return url.includes('/events')
+            ? { events: [{ type: 'run.succeeded' }] }
+            : { ok: true };
+        },
+      };
+    },
+  });
+  await engine.start({ runId: 'run-1' });
+  await engine.resume('run-1', { approvalId: 'approval-1', decision: 'approve' });
+  await engine.cancel('run-1');
+  await engine.getState('run-1');
+  const events = [];
+  for await (const event of engine.streamEvents('run-1')) events.push(event);
+  await engine.getExecutorJob('run-1:executor-preview');
+  const executorEvents = [];
+  for await (
+    const event of engine.streamExecutorJobEvents('run-1:executor-preview', 2)
+  ) {
+    executorEvents.push(event);
+  }
+
+  assert.deepEqual(calls.map((call) => [call.init?.method ?? 'GET', call.url]), [
+    ['POST', 'http://orchestrator.internal/v1/runs'],
+    ['POST', 'http://orchestrator.internal/v1/runs/run-1/resume'],
+    ['POST', 'http://orchestrator.internal/v1/runs/run-1/cancel'],
+    ['GET', 'http://orchestrator.internal/v1/runs/run-1'],
+    ['GET', 'http://orchestrator.internal/v1/runs/run-1/events'],
+    ['GET', 'http://orchestrator.internal/v1/executor-jobs/run-1%3Aexecutor-preview'],
+    [
+      'GET',
+      'http://orchestrator.internal/v1/executor-jobs/run-1%3Aexecutor-preview/events?after=2',
+    ],
+  ]);
+  assert.deepEqual(events, [{ type: 'run.succeeded' }]);
+  assert.deepEqual(executorEvents, [{ type: 'run.succeeded' }]);
+});
diff --git a/services/orchestrator/engine-registry.mjs b/services/orchestrator/engine-registry.mjs
new file mode 100644
index 0000000..fad6c31
--- /dev/null
+++ b/services/orchestrator/engine-registry.mjs
@@ -0,0 +1,143 @@
+import {
+  WORKFLOW_ENGINE,
+  normalizeWorkflowEngineId,
+} from './contracts.mjs';
+
+const REQUIRED_ENGINE_METHODS = Object.freeze([
+  'start',
+  'resume',
+  'cancel',
+  'getState',
+  'streamEvents',
+]);
+
+function validateEngine(engine) {
+  if (!engine || typeof engine !== 'object') {
+    throw new Error('Workflow engine must be an object');
+  }
+  const id = normalizeWorkflowEngineId(engine.id, '');
+  if (!id) throw new Error('Workflow engine requires a valid id');
+  const missing = REQUIRED_ENGINE_METHODS.filter((method) => typeof engine[method] !== 'function');
+  if (missing.length) {
+    throw new Error(`Workflow engine ${id} missing methods: ${missing.join(', ')}`);
+  }
+  return id;
+}
+
+export function createWorkflowEngineRegistry(initialEngines = []) {
+  const engines = new Map();
+
+  function register(engine) {
+    const id = validateEngine(engine);
+    if (engines.has(id)) throw new Error(`Workflow engine already registered: ${id}`);
+    engines.set(id, engine);
+    return engine;
+  }
+
+  for (const engine of initialEngines) register(engine);
+
+  return {
+    register,
+    get(id) {
+      return engines.get(normalizeWorkflowEngineId(id, '')) ?? null;
+    },
+    has(id) {
+      return engines.has(normalizeWorkflowEngineId(id, ''));
+    },
+    list() {
+      return [...engines.values()].map((engine) => ({
+        id: engine.id,
+        label: engine.label ?? engine.id,
+        kind: engine.kind ?? 'plugin',
+        capabilities: Array.isArray(engine.capabilities) ? [...engine.capabilities] : [],
+      }));
+    },
+  };
+}
+
+function createHttpError(response, action) {
+  const error = new Error(`Workflow engine ${action} failed with HTTP ${response?.status ?? 'unknown'}`);
+  error.code = 'WORKFLOW_ENGINE_HTTP_ERROR';
+  error.status = response?.status ?? null;
+  return error;
+}
+
+function joinUrl(baseUrl, pathname) {
+  return `${String(baseUrl).replace(/\/$/, '')}/${String(pathname).replace(/^\//, '')}`;
+}
+
+export function createRemoteWorkflowEngine({
+  id = WORKFLOW_ENGINE.LANGGRAPH,
+  label = 'LangGraph',
+  baseUrl,
+  serviceToken = null,
+  timeoutMs = 5000,
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  const normalizedId = normalizeWorkflowEngineId(id, '');
+  const normalizedBaseUrl = String(baseUrl ?? '').trim().replace(/\/$/, '');
+  if (!normalizedId) throw new Error('Remote workflow engine requires a valid id');
+  if (!normalizedBaseUrl) throw new Error(`Remote workflow engine ${normalizedId} requires baseUrl`);
+  if (typeof fetchImpl !== 'function') throw new Error('Remote workflow engine requires fetch');
+
+  async function request(pathname, init = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.max(100, Number(timeoutMs) || 5000));
+    try {
+      const response = await fetchImpl(joinUrl(normalizedBaseUrl, pathname), {
+        ...init,
+        headers: {
+          accept: 'application/json',
+          ...(init.body ? { 'content-type': 'application/json' } : {}),
+          ...(serviceToken ? { authorization: `Bearer ${serviceToken}` } : {}),
+          ...(init.headers ?? {}),
+        },
+        signal: controller.signal,
+      });
+      if (!response?.ok) throw createHttpError(response, pathname);
+      return response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  return {
+    id: normalizedId,
+    label,
+    kind: 'remote',
+    capabilities: ['durable-execution', 'interrupt', 'streaming', 'executor-observability'],
+    async start(spec) {
+      return request('/v1/runs', { method: 'POST', body: JSON.stringify(spec) });
+    },
+    async resume(runId, input) {
+      return request(`/v1/runs/${encodeURIComponent(runId)}/resume`, {
+        method: 'POST',
+        body: JSON.stringify(input ?? {}),
+      });
+    },
+    async cancel(runId, input = {}) {
+      return request(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
+        method: 'POST',
+        body: JSON.stringify(input),
+      });
+    },
+    async getState(runId) {
+      return request(`/v1/runs/${encodeURIComponent(runId)}`);
+    },
+    async *streamEvents(runId, cursor = null) {
+      const query = cursor == null ? '' : `?after=${encodeURIComponent(cursor)}`;
+      const result = await request(`/v1/runs/${encodeURIComponent(runId)}/events${query}`);
+      for (const event of Array.isArray(result?.events) ? result.events : []) yield event;
+    },
+    async getExecutorJob(jobId) {
+      return request(`/v1/executor-jobs/${encodeURIComponent(jobId)}`);
+    },
+    async *streamExecutorJobEvents(jobId, cursor = null) {
+      const query = cursor == null ? '' : `?after=${encodeURIComponent(cursor)}`;
+      const result = await request(
+        `/v1/executor-jobs/${encodeURIComponent(jobId)}/events${query}`,
+      );
+      for (const event of Array.isArray(result?.events) ? result.events : []) yield event;
+    },
+  };
+}
diff --git a/services/orchestrator/execution-adapter.mjs b/services/orchestrator/execution-adapter.mjs
new file mode 100644
index 0000000..6dfd05a
--- /dev/null
+++ b/services/orchestrator/execution-adapter.mjs
@@ -0,0 +1,171 @@
+import {
+  WORKFLOW_ENGINE,
+  normalizeRunSpec,
+} from './contracts.mjs';
+
+const EXECUTION_REQUEST_VERSION = 'workflow-execution-request-v1';
+const EXECUTION_DECISION_VERSION = 'workflow-execution-decision-v1';
+const MAX_IDEMPOTENCY_KEY_CHARACTERS = 200;
+
+function clampTimeoutMs(value, fallback = 30_000) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(60_000, Math.max(500, Math.floor(number)));
+}
+
+function normalizeIdempotencyKey(value) {
+  return String(value ?? '').trim().slice(0, MAX_IDEMPOTENCY_KEY_CHARACTERS);
+}
+
+export function normalizeWorkflowExecutionRequest(input = {}) {
+  const source = input && typeof input === 'object' && !Array.isArray(input) ? input : {};
+  const spec = normalizeRunSpec(source.spec ?? source.runSpec ?? source);
+  return {
+    version: EXECUTION_REQUEST_VERSION,
+    spec,
+    idempotencyKey: normalizeIdempotencyKey(source.idempotencyKey),
+    authorization: {
+      executionAllowed: source.authorization?.executionAllowed === true,
+      actorId: String(source.authorization?.actorId ?? '').trim() || null,
+    },
+    controls: {
+      timeoutMs: clampTimeoutMs(source.controls?.timeoutMs),
+      fallbackAllowed: source.controls?.fallbackAllowed !== false,
+      cancellationAllowed: source.controls?.cancellationAllowed !== false,
+    },
+  };
+}
+
+function disabledHandoffError(decision) {
+  const error = new Error(
+    `Workflow execution handoff is disabled; ${decision.effectiveEngine} remains the executor`,
+  );
+  error.code = 'WORKFLOW_EXECUTION_HANDOFF_DISABLED';
+  error.status = 409;
+  error.decision = decision;
+  return error;
+}
+
+/**
+ * Framework-neutral control-plane adapter. Routing, authorization and the
+ * environment/admin gates are evaluated before a remote engine can be invoked.
+ */
+export function createWorkflowExecutionAdapter({
+  configService,
+  engineRegistry,
+} = {}) {
+  if (!configService?.selectEngine) {
+    throw new Error('Workflow execution adapter requires orchestrator config service');
+  }
+  if (!engineRegistry?.has) {
+    throw new Error('Workflow execution adapter requires workflow engine registry');
+  }
+
+  async function plan(input) {
+    const request = normalizeWorkflowExecutionRequest(input);
+    const selection = await configService.selectEngine({
+      runId: request.spec.runId,
+      requestId: request.spec.requestId,
+      userId: request.spec.subject.userId,
+      workflowName: request.spec.workflow.name,
+    });
+    const candidateEngine = selection.candidateEngine ?? selection.engine ?? WORKFLOW_ENGINE.NATIVE;
+    const nonNativeCandidate = candidateEngine !== WORKFLOW_ENGINE.NATIVE;
+    const selectedEngine = selection.engine ?? WORKFLOW_ENGINE.NATIVE;
+    const nonNativeSelected = selectedEngine !== WORKFLOW_ENGINE.NATIVE;
+    const gates = {
+      implementation: true,
+      routingSelected: nonNativeSelected,
+      engineRegistered: engineRegistry.has(selectedEngine),
+      idempotencyKeyPresent: Boolean(request.idempotencyKey),
+      executionAuthorized: request.authorization.executionAllowed,
+      killSwitchOpen: selection.reason !== 'kill_switch',
+    };
+    const handoffAllowed = nonNativeSelected && Object.values(gates).every(Boolean);
+    return {
+      version: EXECUTION_DECISION_VERSION,
+      runId: request.spec.runId,
+      requestId: request.spec.requestId,
+      mode: selection.mode,
+      candidateEngine,
+      effectiveEngine: handoffAllowed ? selectedEngine : WORKFLOW_ENGINE.NATIVE,
+      fallbackEngine: selection.fallbackEngine ?? WORKFLOW_ENGINE.NATIVE,
+      dryRun: nonNativeCandidate && !handoffAllowed,
+      handoffAllowed,
+      reason: handoffAllowed
+        ? selection.reason ?? 'execution_handoff_selected'
+        : nonNativeCandidate
+          ? selection.reason ?? 'execution_gate_disabled'
+          : selection.reason ?? 'native_selected',
+      candidateReason: selection.candidateReason ?? null,
+      configVersion: selection.configVersion,
+      gates,
+      controls: request.controls,
+    };
+  }
+
+  return {
+    plan,
+
+    async start(input) {
+      const request = normalizeWorkflowExecutionRequest(input);
+      const decision = await plan(input);
+      if (!decision.handoffAllowed) {
+        if (decision.candidateEngine !== WORKFLOW_ENGINE.NATIVE) {
+          throw disabledHandoffError(decision);
+        }
+        return {
+          dispatched: false,
+          reason: 'native_execution_owned_by_portal',
+          decision,
+        };
+      }
+      const engine = engineRegistry.get(decision.effectiveEngine);
+      try {
+        const state = await engine.start(request.spec);
+        return {
+          dispatched: true,
+          engine: decision.effectiveEngine,
+          state,
+          decision,
+        };
+      } catch (error) {
+        error.code = error.code ?? 'WORKFLOW_EXECUTION_HANDOFF_FAILED';
+        error.decision = decision;
+        error.fallbackRequested = request.controls.fallbackAllowed;
+        throw error;
+      }
+    },
+
+    async resume({ engineId = WORKFLOW_ENGINE.LANGGRAPH, runId, input = null } = {}) {
+      const engine = engineRegistry.get(engineId);
+      if (!engine || engineId === WORKFLOW_ENGINE.NATIVE) {
+        throw disabledHandoffError({
+          effectiveEngine: WORKFLOW_ENGINE.NATIVE,
+          reason: 'execution_gate_disabled',
+        });
+      }
+      return engine.resume(runId, input);
+    },
+
+    async cancel({ engineId = WORKFLOW_ENGINE.LANGGRAPH, runId, reason = null } = {}) {
+      const engine = engineRegistry.get(engineId);
+      if (!engine || engineId === WORKFLOW_ENGINE.NATIVE) {
+        throw disabledHandoffError({
+          effectiveEngine: WORKFLOW_ENGINE.NATIVE,
+          reason: 'execution_gate_disabled',
+        });
+      }
+      return engine.cancel(runId, reason);
+    },
+  };
+}
+
+export const workflowExecutionAdapterInternals = {
+  EXECUTION_DECISION_VERSION,
+  EXECUTION_REQUEST_VERSION,
+  MAX_IDEMPOTENCY_KEY_CHARACTERS,
+  clampTimeoutMs,
+  disabledHandoffError,
+  normalizeIdempotencyKey,
+};
diff --git a/services/orchestrator/execution-adapter.test.mjs b/services/orchestrator/execution-adapter.test.mjs
new file mode 100644
index 0000000..323a4ab
--- /dev/null
+++ b/services/orchestrator/execution-adapter.test.mjs
@@ -0,0 +1,149 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createWorkflowEngineRegistry } from './engine-registry.mjs';
+import {
+  createWorkflowExecutionAdapter,
+  normalizeWorkflowExecutionRequest,
+} from './execution-adapter.mjs';
+
+function engine(id) {
+  return {
+    id,
+    start() {
+      throw new Error('must not dispatch during Phase 3 dry-run');
+    },
+    resume() {},
+    cancel() {},
+    getState() {},
+    async *streamEvents() {},
+  };
+}
+
+function executionRequest(overrides = {}) {
+  return {
+    spec: {
+      runId: 'run-1',
+      requestId: 'request-1',
+      workflow: { name: 'code-run-v1', version: 1 },
+      subject: { userId: 'user-1' },
+    },
+    idempotencyKey: 'agent-run:run-1:attempt-1',
+    authorization: { executionAllowed: true, actorId: 'user-1' },
+    controls: { timeoutMs: 10_000 },
+    ...overrides,
+  };
+}
+
+test('workflow execution request normalizes authorization, limits and idempotency', () => {
+  const request = normalizeWorkflowExecutionRequest(executionRequest({
+    idempotencyKey: `  ${'x'.repeat(250)}  `,
+    controls: { timeoutMs: 120_000, fallbackAllowed: false },
+  }));
+  assert.equal(request.version, 'workflow-execution-request-v1');
+  assert.equal(request.idempotencyKey.length, 200);
+  assert.equal(request.authorization.executionAllowed, true);
+  assert.equal(request.controls.timeoutMs, 60_000);
+  assert.equal(request.controls.fallbackAllowed, false);
+});
+
+test('workflow execution adapter records a LangGraph candidate but keeps Native effective', async () => {
+  const registry = createWorkflowEngineRegistry([engine('native'), engine('langgraph')]);
+  const adapter = createWorkflowExecutionAdapter({
+    engineRegistry: registry,
+    configService: {
+      async selectEngine() {
+        return {
+          engine: 'native',
+          candidateEngine: 'langgraph',
+          fallbackEngine: 'native',
+          mode: 'canary',
+          reason: 'execution_gate_disabled',
+          candidateReason: 'user_allowlist',
+          configVersion: 4,
+        };
+      },
+    },
+  });
+
+  const decision = await adapter.plan(executionRequest());
+  assert.equal(decision.version, 'workflow-execution-decision-v1');
+  assert.equal(decision.candidateEngine, 'langgraph');
+  assert.equal(decision.effectiveEngine, 'native');
+  assert.equal(decision.dryRun, true);
+  assert.equal(decision.handoffAllowed, false);
+  assert.equal(decision.candidateReason, 'user_allowlist');
+  assert.deepEqual(decision.gates, {
+    implementation: true,
+    routingSelected: false,
+    engineRegistered: true,
+    idempotencyKeyPresent: true,
+    executionAuthorized: true,
+    killSwitchOpen: true,
+  });
+
+  await assert.rejects(
+    () => adapter.start(executionRequest()),
+    (error) => error.code === 'WORKFLOW_EXECUTION_HANDOFF_DISABLED'
+      && error.decision.effectiveEngine === 'native',
+  );
+});
+
+test('workflow execution adapter dispatches a selected and authorized LangGraph engine', async () => {
+  let started = null;
+  const registry = createWorkflowEngineRegistry([
+    engine('native'),
+    {
+      ...engine('langgraph'),
+      start(spec) {
+        started = spec;
+        return { runId: spec.runId, status: 'waiting' };
+      },
+    },
+  ]);
+  const adapter = createWorkflowExecutionAdapter({
+    engineRegistry: registry,
+    configService: {
+      async selectEngine() {
+        return {
+          engine: 'langgraph',
+          candidateEngine: 'langgraph',
+          fallbackEngine: 'native',
+          mode: 'canary',
+          reason: 'user_allowlist',
+          candidateReason: 'user_allowlist',
+          configVersion: 5,
+        };
+      },
+    },
+  });
+  const result = await adapter.start(executionRequest());
+  assert.equal(result.dispatched, true);
+  assert.equal(result.engine, 'langgraph');
+  assert.equal(result.decision.handoffAllowed, true);
+  assert.equal(result.decision.dryRun, false);
+  assert.equal(started.runId, 'run-1');
+});
+
+test('workflow execution adapter leaves native dispatch under Portal ownership', async () => {
+  const registry = createWorkflowEngineRegistry([engine('native')]);
+  const adapter = createWorkflowExecutionAdapter({
+    engineRegistry: registry,
+    configService: {
+      async selectEngine() {
+        return {
+          engine: 'native',
+          candidateEngine: 'native',
+          fallbackEngine: 'native',
+          mode: 'off',
+          reason: 'mode_off',
+          configVersion: 1,
+        };
+      },
+    },
+  });
+
+  const result = await adapter.start(executionRequest());
+  assert.equal(result.dispatched, false);
+  assert.equal(result.reason, 'native_execution_owned_by_portal');
+  assert.equal(result.decision.effectiveEngine, 'native');
+});
diff --git a/services/orchestrator/executor-adapters.mjs b/services/orchestrator/executor-adapters.mjs
new file mode 100644
index 0000000..63479bb
--- /dev/null
+++ b/services/orchestrator/executor-adapters.mjs
@@ -0,0 +1,522 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { Agent, fetch as undiciFetch } from 'undici';
+
+const DEFAULT_OUTPUT_LIMIT = 64 * 1024;
+const DEFAULT_ALLOWED_ENV = Object.freeze(['PATH', 'LANG', 'LC_ALL', 'TMPDIR']);
+
+function adapterError(code, message, { retryable = false, cause = null } = {}) {
+  const error = new Error(message, cause ? { cause } : undefined);
+  error.code = code;
+  error.retryable = retryable;
+  return error;
+}
+
+function appendBounded(current, chunk, limit) {
+  const next = `${current}${Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk ?? '')}`;
+  return next.length <= limit ? next : next.slice(next.length - limit);
+}
+
+function isLoopbackHostname(hostname) {
+  const normalized = String(hostname ?? '').trim().toLowerCase();
+  return normalized === 'localhost'
+    || normalized === '127.0.0.1'
+    || normalized === '::1'
+    || normalized === '[::1]'
+    || normalized.endsWith('.localhost');
+}
+
+function isLocalExecutorHostname(hostname) {
+  const normalized = String(hostname ?? '').trim().toLowerCase();
+  return isLoopbackHostname(normalized)
+    || normalized === 'host.docker.internal'
+    || normalized === 'gateway.docker.internal';
+}
+
+function normalizeBaseUrl(value, { allowRemote = false } = {}) {
+  const url = new URL(String(value ?? '').trim());
+  if (!['http:', 'https:'].includes(url.protocol)) {
+    throw new Error('Executor adapter URL must use HTTP or HTTPS');
+  }
+  if (!allowRemote && !isLoopbackHostname(url.hostname)) {
+    throw new Error('Remote executor targets require explicit allowRemote');
+  }
+  url.username = '';
+  url.password = '';
+  url.hash = '';
+  return url.toString().replace(/\/$/, '');
+}
+
+async function responseError(response, code, prefix) {
+  const text = await response.text().catch(() => '');
+  return adapterError(
+    code,
+    `${prefix} (${response.status})${text ? `: ${text.slice(0, 512)}` : ''}`,
+    { retryable: response.status >= 500 || response.status === 429 },
+  );
+}
+
+async function* parseSse(body) {
+  const decoder = new TextDecoder();
+  let buffer = '';
+  for await (const chunk of body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    while (true) {
+      const boundary = buffer.search(/\r?\n\r?\n/);
+      if (boundary < 0) break;
+      const raw = buffer.slice(0, boundary);
+      const separatorLength = buffer.startsWith('\r\n\r\n', boundary) ? 4 : 2;
+      buffer = buffer.slice(boundary + separatorLength);
+      let event = 'message';
+      const data = [];
+      for (const line of raw.split(/\r?\n/)) {
+        if (line.startsWith('event:')) event = line.slice(6).trim() || 'message';
+        if (line.startsWith('data:')) data.push(line.slice(5).trimStart());
+      }
+      if (data.length) {
+        const text = data.join('\n');
+        let parsed = text;
+        try {
+          parsed = JSON.parse(text);
+        } catch {
+          // Preserve non-JSON Goosed events as bounded text.
+        }
+        yield { event, data: parsed };
+      }
+    }
+  }
+}
+
+function terminalGoosedEvent(event) {
+  const type = String(
+    event?.event
+      ?? event?.data?.type
+      ?? event?.data?.event_type
+      ?? '',
+  ).trim().toLowerCase();
+  return ['finish', 'finished', 'completed', 'error', 'failed'].includes(type);
+}
+
+export function createGoosedExecutorAdapter({
+  baseUrl,
+  secret = '',
+  fetchImpl = null,
+  allowRemote = false,
+  tlsInsecure = false,
+  workspaceResolver = async (reference) => reference?.id ?? null,
+} = {}) {
+  const target = normalizeBaseUrl(baseUrl, { allowRemote });
+  const targetUrl = new URL(target);
+  if (tlsInsecure && !isLocalExecutorHostname(targetUrl.hostname)) {
+    throw new Error('Insecure executor TLS is restricted to local targets');
+  }
+  const transport = fetchImpl ?? undiciFetch;
+  if (typeof transport !== 'function') throw new Error('Goosed adapter requires fetch');
+  const dispatcher = tlsInsecure
+    ? new Agent({ connect: { rejectUnauthorized: false } })
+    : null;
+  const active = new Map();
+
+  function headers(extra = {}) {
+    return {
+      accept: 'application/json',
+      'content-type': 'application/json',
+      ...(secret ? { 'X-Secret-Key': secret } : {}),
+      ...extra,
+    };
+  }
+
+  async function submit(request, {
+    jobId,
+    signal = null,
+    emit = async () => {},
+  } = {}) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(signal?.reason);
+    if (signal?.aborted) abort();
+    else signal?.addEventListener?.('abort', abort, { once: true });
+    active.set(jobId, controller);
+    try {
+      const workingDir = await workspaceResolver(request.task.workspaceRef);
+      if (!workingDir) {
+        throw adapterError(
+          'GOOSED_WORKSPACE_UNRESOLVED',
+          'Goosed workspace reference could not be resolved',
+        );
+      }
+      const start = await transport(`${target}/agent/start`, {
+        method: 'POST',
+        headers: headers(),
+        body: JSON.stringify({
+          working_dir: workingDir,
+          enable_context_memory: false,
+        }),
+        signal: controller.signal,
+        ...(dispatcher ? { dispatcher } : {}),
+      });
+      if (!start.ok) throw await responseError(start, 'GOOSED_START_FAILED', 'Goosed start failed');
+      const session = await start.json();
+      const sessionId = String(session?.id ?? '').trim();
+      if (!sessionId) {
+        throw adapterError('GOOSED_SESSION_ID_MISSING', 'Goosed start response missing session id');
+      }
+      await emit('executor_job_session_created', {
+        sessionRef: { kind: 'goosed-session', id: sessionId },
+      });
+
+      const eventsResponse = await transport(
+        `${target}/sessions/${encodeURIComponent(sessionId)}/events`,
+        {
+          method: 'GET',
+          headers: headers({ accept: 'text/event-stream' }),
+          signal: controller.signal,
+          ...(dispatcher ? { dispatcher } : {}),
+        },
+      );
+      if (!eventsResponse.ok || !eventsResponse.body) {
+        throw await responseError(
+          eventsResponse,
+          'GOOSED_EVENTS_FAILED',
+          'Goosed event stream failed',
+        );
+      }
+
+      const finishPromise = (async () => {
+        let eventCount = 0;
+        let finalEvent = null;
+        for await (const event of parseSse(eventsResponse.body)) {
+          eventCount += 1;
+          const eventType = String(
+            event?.event ?? event?.data?.type ?? event?.data?.event_type ?? 'message',
+          ).slice(0, 96);
+          await emit('executor_job_adapter_event', {
+            adapter: 'goosed',
+            eventType,
+            eventCount,
+          });
+          if (terminalGoosedEvent(event)) {
+            finalEvent = event;
+            break;
+          }
+        }
+        return { eventCount, finalEvent };
+      })();
+
+      const reply = await transport(
+        `${target}/sessions/${encodeURIComponent(sessionId)}/reply`,
+        {
+          method: 'POST',
+          headers: headers(),
+          body: JSON.stringify({
+            request_id: jobId,
+            user_message: {
+              role: 'user',
+              content: [{ type: 'text', text: request.task.instruction }],
+            },
+          }),
+          signal: controller.signal,
+          ...(dispatcher ? { dispatcher } : {}),
+        },
+      );
+      if (!reply.ok) throw await responseError(reply, 'GOOSED_REPLY_FAILED', 'Goosed reply failed');
+      reply.body?.cancel?.().catch?.(() => {});
+
+      const finished = await finishPromise;
+      const finalType = String(
+        finished.finalEvent?.event
+          ?? finished.finalEvent?.data?.type
+          ?? finished.finalEvent?.data?.event_type
+          ?? '',
+      ).toLowerCase();
+      if (['error', 'failed'].includes(finalType)) {
+        throw adapterError('GOOSED_RUN_FAILED', 'Goosed reported a failed terminal event');
+      }
+      return {
+        outcome: 'completed',
+        summary: `Goosed session completed after ${finished.eventCount} events`,
+        artifactRefs: [{ kind: 'goosed-session', id: sessionId }],
+        metrics: { eventCount: finished.eventCount },
+      };
+    } catch (error) {
+      if (controller.signal.aborted || error?.name === 'AbortError') {
+        throw adapterError('GOOSED_CANCELLED', 'Goosed execution was cancelled');
+      }
+      throw error;
+    } finally {
+      signal?.removeEventListener?.('abort', abort);
+      active.delete(jobId);
+    }
+  }
+
+  return {
+    id: 'goosed',
+    label: 'Goosed',
+    kind: 'remote',
+    enabled: true,
+    dispatchImplemented: true,
+    capabilities: ['session-execution', 'streaming', 'cancel'],
+    submit,
+    async cancel(jobId) {
+      const controller = active.get(jobId);
+      if (!controller) return false;
+      controller.abort();
+      return true;
+    },
+    async getState(jobId) {
+      return { active: active.has(jobId) };
+    },
+    async health() {
+      try {
+        const response = await transport(`${target}/status`, {
+          method: 'GET',
+          headers: headers(),
+          signal: AbortSignal.timeout(2_000),
+          ...(dispatcher ? { dispatcher } : {}),
+        });
+        return { ok: response.ok, status: response.status };
+      } catch (error) {
+        return {
+          ok: false,
+          status: null,
+          code: String(error?.code ?? error?.name ?? 'GOOSED_UNREACHABLE').slice(0, 128),
+        };
+      }
+    },
+    async *streamEvents() {
+      throw adapterError(
+        'GOOSED_STREAM_PUSH_ONLY',
+        'Goosed events are delivered through submit emit callbacks',
+      );
+    },
+  };
+}
+
+async function resolveWorkspace(reference, {
+  allowedRoot,
+  aliases = {},
+} = {}) {
+  const alias = String(reference?.id ?? '').trim();
+  const configured = aliases[alias];
+  if (!configured) {
+    throw adapterError(
+      'EXECUTOR_WORKSPACE_ALIAS_UNKNOWN',
+      `Workspace alias is not configured: ${alias || '<empty>'}`,
+    );
+  }
+  const root = await fs.realpath(allowedRoot);
+  const resolved = await fs.realpath(path.resolve(configured));
+  if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) {
+    throw adapterError(
+      'EXECUTOR_WORKSPACE_OUTSIDE_ROOT',
+      'Workspace resolves outside the configured worker root',
+    );
+  }
+  return resolved;
+}
+
+function safeCommand(value) {
+  const command = String(value ?? '').trim();
+  if (!command || /[\r\n\0]/.test(command)) {
+    throw new Error('Process executor requires a safe command');
+  }
+  return command;
+}
+
+export function createProcessExecutorAdapter({
+  id,
+  label = id,
+  command,
+  buildArgs,
+  allowedRoot,
+  workspaceAliases = {},
+  spawnImpl = nodeSpawn,
+  outputLimit = DEFAULT_OUTPUT_LIMIT,
+  allowedEnv = DEFAULT_ALLOWED_ENV,
+  extraEnv = {},
+  artifactCollector = async ({ request }) => [request.task.workspaceRef],
+} = {}) {
+  const executorId = String(id ?? '').trim().toLowerCase();
+  if (!['aider', 'openhands'].includes(executorId)) {
+    throw new Error('Process executor id must be aider or openhands');
+  }
+  const executable = safeCommand(command);
+  if (!allowedRoot) throw new Error('Process executor requires allowedRoot');
+  if (typeof buildArgs !== 'function') throw new Error('Process executor requires buildArgs');
+  const active = new Map();
+
+  async function submit(request, {
+    jobId,
+    signal = null,
+    emit = async () => {},
+  } = {}) {
+    const cwd = await resolveWorkspace(request.task.workspaceRef, {
+      allowedRoot,
+      aliases: workspaceAliases,
+    });
+    const args = buildArgs(request.task.instruction, request);
+    if (!Array.isArray(args) || args.some((arg) => typeof arg !== 'string')) {
+      throw new Error(`${executorId} buildArgs must return a string array`);
+    }
+    const env = {};
+    for (const key of allowedEnv) {
+      if (process.env[key] != null) env[key] = process.env[key];
+    }
+    Object.assign(env, extraEnv);
+
+    return new Promise((resolve, reject) => {
+      let stdout = '';
+      let stderr = '';
+      let settled = false;
+      const child = spawnImpl(executable, args, {
+        cwd,
+        env,
+        shell: false,
+        detached: false,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      active.set(jobId, child);
+      const cleanup = () => {
+        active.delete(jobId);
+        signal?.removeEventListener?.('abort', onAbort);
+      };
+      const fail = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+      const onAbort = () => {
+        child.kill('SIGTERM');
+        fail(adapterError('EXECUTOR_PROCESS_CANCELLED', `${label} execution was cancelled`));
+      };
+      if (signal?.aborted) onAbort();
+      else signal?.addEventListener?.('abort', onAbort, { once: true });
+      child.stdout?.on?.('data', (chunk) => {
+        stdout = appendBounded(stdout, chunk, outputLimit);
+        void emit('executor_job_output_chunk', {
+          adapter: executorId,
+          stream: 'stdout',
+          bytes: Buffer.byteLength(chunk),
+        });
+      });
+      child.stderr?.on?.('data', (chunk) => {
+        stderr = appendBounded(stderr, chunk, outputLimit);
+        void emit('executor_job_output_chunk', {
+          adapter: executorId,
+          stream: 'stderr',
+          bytes: Buffer.byteLength(chunk),
+        });
+      });
+      child.once?.('error', (error) => {
+        fail(adapterError(
+          'EXECUTOR_PROCESS_START_FAILED',
+          `${label} failed to start: ${error.message}`,
+          { retryable: true, cause: error },
+        ));
+      });
+      child.once?.('exit', async (code, exitSignal) => {
+        if (settled) return;
+        if (code !== 0) {
+          fail(adapterError(
+            'EXECUTOR_PROCESS_FAILED',
+            `${label} exited with ${exitSignal ?? code}: ${stderr.slice(-1024)}`,
+          ));
+          return;
+        }
+        try {
+          const artifactRefs = await artifactCollector({
+            executor: executorId,
+            request,
+            cwd,
+            stdout,
+            stderr,
+          });
+          settled = true;
+          cleanup();
+          resolve({
+            outcome: 'completed',
+            summary: `${label} completed successfully`,
+            artifactRefs,
+            metrics: {
+              stdoutBytes: Buffer.byteLength(stdout),
+              stderrBytes: Buffer.byteLength(stderr),
+            },
+          });
+        } catch (error) {
+          fail(error);
+        }
+      });
+    });
+  }
+
+  return {
+    id: executorId,
+    label,
+    kind: 'isolated-process',
+    enabled: true,
+    dispatchImplemented: true,
+    capabilities: ['code-edit', 'cancel', 'artifact-refs', 'workspace-alias'],
+    submit,
+    async cancel(jobId) {
+      const child = active.get(jobId);
+      if (!child) return false;
+      child.kill('SIGTERM');
+      return true;
+    },
+    async getState(jobId) {
+      return { active: active.has(jobId) };
+    },
+    async health() {
+      try {
+        await fs.access(executable);
+        await fs.access(allowedRoot);
+        return { ok: true };
+      } catch (error) {
+        return {
+          ok: false,
+          code: String(error?.code ?? 'EXECUTOR_PROCESS_UNAVAILABLE').slice(0, 128),
+        };
+      }
+    },
+    async *streamEvents() {
+      throw adapterError(
+        'EXECUTOR_PROCESS_STREAM_PUSH_ONLY',
+        'Process events are delivered through submit emit callbacks',
+      );
+    },
+  };
+}
+
+export function createAiderExecutorAdapter(options = {}) {
+  return createProcessExecutorAdapter({
+    id: 'aider',
+    label: 'Aider',
+    buildArgs: (instruction) => ['--yes-always', '--message', instruction],
+    ...options,
+  });
+}
+
+export function createOpenHandsExecutorAdapter(options = {}) {
+  return createProcessExecutorAdapter({
+    id: 'openhands',
+    label: 'OpenHands',
+    buildArgs: (instruction) => ['--headless', '--task', instruction],
+    ...options,
+  });
+}
+
+export const executorAdapterInternals = {
+  DEFAULT_ALLOWED_ENV,
+  DEFAULT_OUTPUT_LIMIT,
+  EventEmitter,
+  adapterError,
+  appendBounded,
+  isLoopbackHostname,
+  isLocalExecutorHostname,
+  normalizeBaseUrl,
+  parseSse,
+  resolveWorkspace,
+  terminalGoosedEvent,
+};
diff --git a/services/orchestrator/executor-adapters.test.mjs b/services/orchestrator/executor-adapters.test.mjs
new file mode 100644
index 0000000..25ad14c
--- /dev/null
+++ b/services/orchestrator/executor-adapters.test.mjs
@@ -0,0 +1,177 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import {
+  createAiderExecutorAdapter,
+  createGoosedExecutorAdapter,
+  createOpenHandsExecutorAdapter,
+} from './executor-adapters.mjs';
+
+function request(executor = 'goosed') {
+  return {
+    executor,
+    task: {
+      instruction: 'Fix the validation',
+      workspaceRef: { kind: 'workspace-alias', id: 'canary' },
+    },
+  };
+}
+
+function sseResponse(events) {
+  const encoder = new TextEncoder();
+  const body = new ReadableStream({
+    start(controller) {
+      for (const event of events) {
+        controller.enqueue(encoder.encode(
+          `event: ${event.type}\ndata: ${JSON.stringify(event.data)}\n\n`,
+        ));
+      }
+      controller.close();
+    },
+  });
+  return new Response(body, {
+    status: 200,
+    headers: { 'content-type': 'text/event-stream' },
+  });
+}
+
+test('Goosed adapter uses the current session API, streams bounded metadata and returns refs', async () => {
+  const calls = [];
+  const emitted = [];
+  const adapter = createGoosedExecutorAdapter({
+    baseUrl: 'http://127.0.0.1:18006',
+    secret: 'secret',
+    workspaceResolver: async () => '/tmp/canary',
+    fetchImpl: async (url, init) => {
+      calls.push({ url, init });
+      if (url.endsWith('/agent/start')) {
+        return Response.json({ id: 'session-1' });
+      }
+      if (url.endsWith('/events')) {
+        return sseResponse([
+          { type: 'message', data: { type: 'message', secret: 'not-projected' } },
+          { type: 'finish', data: { type: 'finish' } },
+        ]);
+      }
+      if (url.endsWith('/reply')) return Response.json({ ok: true });
+      throw new Error(`Unexpected URL: ${url}`);
+    },
+  });
+  const result = await adapter.submit(request(), {
+    jobId: 'job-1',
+    emit: async (type, data) => emitted.push({ type, data }),
+  });
+  assert.deepEqual(result.artifactRefs, [{ kind: 'goosed-session', id: 'session-1' }]);
+  assert.equal(result.metrics.eventCount, 2);
+  assert.equal(calls[0].url, 'http://127.0.0.1:18006/agent/start');
+  assert.equal(calls[0].init.headers['X-Secret-Key'], 'secret');
+  assert.equal(JSON.parse(calls[0].init.body).working_dir, '/tmp/canary');
+  assert.equal(
+    JSON.parse(calls.find((call) => call.url.endsWith('/reply')).init.body)
+      .user_message.content[0].text,
+    'Fix the validation',
+  );
+  assert.deepEqual(
+    emitted.map((event) => event.type),
+    [
+      'executor_job_session_created',
+      'executor_job_adapter_event',
+      'executor_job_adapter_event',
+    ],
+  );
+  assert.equal(JSON.stringify(emitted).includes('not-projected'), false);
+});
+
+test('Goosed adapter rejects remote targets unless explicitly allowed', () => {
+  assert.throws(
+    () => createGoosedExecutorAdapter({ baseUrl: 'https://executor.example.com' }),
+    /explicit allowRemote/,
+  );
+  assert.doesNotThrow(
+    () => createGoosedExecutorAdapter({
+      baseUrl: 'https://executor.example.com',
+      allowRemote: true,
+    }),
+  );
+  assert.throws(
+    () => createGoosedExecutorAdapter({
+      baseUrl: 'https://executor.example.com',
+      allowRemote: true,
+      tlsInsecure: true,
+    }),
+    /restricted to local targets/,
+  );
+  assert.doesNotThrow(
+    () => createGoosedExecutorAdapter({
+      baseUrl: 'https://host.docker.internal:18006',
+      allowRemote: true,
+      tlsInsecure: true,
+    }),
+  );
+});
+
+test('Aider process adapter resolves a workspace alias and never invokes a shell', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'memind-executor-'));
+  const workspace = path.join(root, 'canary');
+  await fs.mkdir(workspace);
+  const spawnCalls = [];
+  const emitted = [];
+  const spawnImpl = (command, args, options) => {
+    spawnCalls.push({ command, args, options });
+    const child = new EventEmitter();
+    child.stdout = new EventEmitter();
+    child.stderr = new EventEmitter();
+    child.kill = () => {};
+    queueMicrotask(() => {
+      child.stdout.emit('data', Buffer.from('done'));
+      child.emit('exit', 0, null);
+    });
+    return child;
+  };
+  try {
+    const adapter = createAiderExecutorAdapter({
+      command: '/usr/local/bin/aider',
+      allowedRoot: root,
+      workspaceAliases: { canary: workspace },
+      spawnImpl,
+    });
+    const result = await adapter.submit(request('aider'), {
+      jobId: 'job-1',
+      emit: async (type, data) => emitted.push({ type, data }),
+    });
+    assert.equal(result.outcome, 'completed');
+    assert.deepEqual(result.artifactRefs, [{ kind: 'workspace-alias', id: 'canary' }]);
+    assert.equal(spawnCalls[0].options.cwd, await fs.realpath(workspace));
+    assert.equal(spawnCalls[0].options.shell, false);
+    assert.deepEqual(
+      spawnCalls[0].args,
+      ['--yes-always', '--message', 'Fix the validation'],
+    );
+    assert.equal(emitted[0].data.stream, 'stdout');
+    assert.equal('HOME' in spawnCalls[0].options.env, false);
+  } finally {
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
+test('OpenHands adapter refuses workspace aliases outside its isolated root', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'memind-executor-root-'));
+  const outside = await fs.mkdtemp(path.join(os.tmpdir(), 'memind-executor-outside-'));
+  try {
+    const adapter = createOpenHandsExecutorAdapter({
+      command: '/usr/local/bin/openhands',
+      allowedRoot: root,
+      workspaceAliases: { canary: outside },
+    });
+    await assert.rejects(
+      adapter.submit(request('openhands'), { jobId: 'job-1' }),
+      (error) => error.code === 'EXECUTOR_WORKSPACE_OUTSIDE_ROOT',
+    );
+  } finally {
+    await fs.rm(root, { recursive: true, force: true });
+    await fs.rm(outside, { recursive: true, force: true });
+  }
+});
diff --git a/services/orchestrator/executor-admission-policy.mjs b/services/orchestrator/executor-admission-policy.mjs
new file mode 100644
index 0000000..f39450a
--- /dev/null
+++ b/services/orchestrator/executor-admission-policy.mjs
@@ -0,0 +1,102 @@
+function clampInteger(value, fallback, min, max) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(number)));
+}
+
+function normalizeList(value) {
+  const items = Array.isArray(value)
+    ? value
+    : String(value ?? '').split(',');
+  return [...new Set(items.map((item) => String(item).trim()).filter(Boolean))];
+}
+
+export function normalizeExecutorAdmissionConfig(input = {}) {
+  return {
+    tenantAllowlist: normalizeList(input.tenantAllowlist),
+    userAllowlist: normalizeList(input.userAllowlist),
+    workspaceKindAllowlist: normalizeList(
+      input.workspaceKindAllowlist ?? ['workspace-alias'],
+    ),
+    maxGlobalActive: clampInteger(input.maxGlobalActive, 20, 1, 10_000),
+    maxTenantActive: clampInteger(input.maxTenantActive, 5, 1, 1_000),
+    maxUserActive: clampInteger(input.maxUserActive, 2, 1, 100),
+    maxTenantPerMinute: clampInteger(input.maxTenantPerMinute, 30, 1, 100_000),
+    maxUserPerMinute: clampInteger(input.maxUserPerMinute, 10, 1, 10_000),
+  };
+}
+
+export function createExecutorAdmissionPolicy({
+  store,
+  config = {},
+  nowMs = Date.now,
+} = {}) {
+  if (typeof store?.getAdmissionStats !== 'function') {
+    throw new Error('Executor admission policy requires store.getAdmissionStats');
+  }
+  const normalized = normalizeExecutorAdmissionConfig(config);
+
+  function denied(reason, details = {}) {
+    return {
+      version: 'executor-admission-v1',
+      allowed: false,
+      reason,
+      details,
+    };
+  }
+
+  return {
+    config: normalized,
+    async evaluate(request) {
+      const tenantId = request.subject?.tenantId;
+      const userId = request.subject?.userId;
+      const workspaceKind = request.task?.workspaceRef?.kind;
+      if (normalized.tenantAllowlist.length && !normalized.tenantAllowlist.includes(tenantId)) {
+        return denied('executor_tenant_not_allowed');
+      }
+      if (normalized.userAllowlist.length && !normalized.userAllowlist.includes(userId)) {
+        return denied('executor_user_not_allowed');
+      }
+      if (!normalized.workspaceKindAllowlist.includes(workspaceKind)) {
+        return denied('executor_workspace_kind_not_allowed', { workspaceKind });
+      }
+      const stats = await store.getAdmissionStats({
+        tenantId,
+        userId,
+        now: nowMs(),
+        windowMs: 60_000,
+      });
+      const checks = [
+        ['globalActive', normalized.maxGlobalActive, 'executor_global_concurrency_limited'],
+        ['tenantActive', normalized.maxTenantActive, 'executor_tenant_concurrency_limited'],
+        ['userActive', normalized.maxUserActive, 'executor_user_concurrency_limited'],
+        ['tenantRecent', normalized.maxTenantPerMinute, 'executor_tenant_rate_limited'],
+        ['userRecent', normalized.maxUserPerMinute, 'executor_user_rate_limited'],
+      ];
+      for (const [field, limit, reason] of checks) {
+        if (stats[field] >= limit) return denied(reason, { current: stats[field], limit });
+      }
+      return {
+        version: 'executor-admission-v1',
+        allowed: true,
+        reason: 'executor_admitted',
+        details: {
+          globalActive: stats.globalActive,
+          tenantActive: stats.tenantActive,
+          userActive: stats.userActive,
+        },
+      };
+    },
+    status() {
+      return {
+        version: 'executor-admission-policy-v1',
+        ...normalized,
+      };
+    },
+  };
+}
+
+export const executorAdmissionPolicyInternals = {
+  clampInteger,
+  normalizeList,
+};
diff --git a/services/orchestrator/executor-admission-policy.test.mjs b/services/orchestrator/executor-admission-policy.test.mjs
new file mode 100644
index 0000000..4916e7c
--- /dev/null
+++ b/services/orchestrator/executor-admission-policy.test.mjs
@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createExecutorAdmissionPolicy } from './executor-admission-policy.mjs';
+import {
+  createExecutorGateway,
+  createInMemoryExecutorJobStore,
+  createPhase5ExecutorAdapterRegistry,
+} from './executor-gateway.mjs';
+
+function request(overrides = {}) {
+  return {
+    jobId: 'job-1',
+    idempotencyKey: 'idem-1',
+    executor: 'goosed',
+    task: {
+      instruction: 'do it',
+      workspaceRef: { kind: 'workspace-alias', id: 'canary' },
+    },
+    subject: { tenantId: 'tenant-1', userId: 'user-1' },
+    authorization: { executionAllowed: true },
+    policy: { sideEffectsAllowed: true },
+    ...overrides,
+  };
+}
+
+test('admission policy enforces allowlists, workspace kinds and durable-store quotas', async () => {
+  const store = createInMemoryExecutorJobStore();
+  const policy = createExecutorAdmissionPolicy({
+    store,
+    config: {
+      tenantAllowlist: ['tenant-1'],
+      userAllowlist: ['user-1'],
+      maxUserActive: 1,
+    },
+  });
+  assert.equal((await policy.evaluate(request())).allowed, true);
+  assert.equal(
+    (await policy.evaluate(request({
+      subject: { tenantId: 'tenant-2', userId: 'user-1' },
+    }))).reason,
+    'executor_tenant_not_allowed',
+  );
+  assert.equal(
+    (await policy.evaluate(request({
+      task: {
+        instruction: 'do it',
+        workspaceRef: { kind: 'absolute-path', id: '/tmp/repo' },
+      },
+    }))).reason,
+    'executor_workspace_kind_not_allowed',
+  );
+
+  const gateway = createExecutorGateway({
+    store,
+    registry: createPhase5ExecutorAdapterRegistry({ enabledExecutors: ['goosed'] }),
+    executionEnabled: true,
+    admissionPolicy: policy,
+  });
+  const first = await gateway.createJob(request());
+  assert.equal(first.job.status, 'queued');
+  const second = await gateway.createJob(request({
+    jobId: 'job-2',
+    idempotencyKey: 'idem-2',
+  }));
+  assert.equal(second.job.status, 'blocked');
+  assert.equal(second.job.reason, 'executor_user_concurrency_limited');
+});
diff --git a/services/orchestrator/executor-gateway.mjs b/services/orchestrator/executor-gateway.mjs
new file mode 100644
index 0000000..8a48009
--- /dev/null
+++ b/services/orchestrator/executor-gateway.mjs
@@ -0,0 +1,798 @@
+import crypto from 'node:crypto';
+import { normalizeWorkflowEngineId } from './contracts.mjs';
+
+const EXECUTOR_JOB_REQUEST_VERSION = 'executor-job-request-v1';
+const EXECUTOR_JOB_STATE_VERSION = 'executor-job-state-v1';
+const EXECUTOR_JOB_EVENT_VERSION = 'executor-job-event-v1';
+const EXECUTOR_DISPATCH_IMPLEMENTED = true;
+const MAX_INSTRUCTION_CHARACTERS = 32_000;
+const MAX_EVENT_PAGE_SIZE = 500;
+const TERMINAL_JOB_STATUSES = new Set([
+  'succeeded',
+  'failed',
+  'cancelled',
+  'timed_out',
+  'blocked',
+]);
+
+const PHASE3_EXECUTOR_DESCRIPTORS = Object.freeze([
+  Object.freeze({
+    id: 'goosed',
+    label: 'Goosed',
+    kind: 'remote',
+    capabilities: Object.freeze(['session-execution', 'streaming', 'tools']),
+  }),
+  Object.freeze({
+    id: 'aider',
+    label: 'Aider',
+    kind: 'worker',
+    capabilities: Object.freeze(['code-edit', 'multi-file']),
+  }),
+  Object.freeze({
+    id: 'openhands',
+    label: 'OpenHands',
+    kind: 'worker',
+    capabilities: Object.freeze(['repo-task', 'code-edit', 'command-execution']),
+  }),
+]);
+
+function clone(value) {
+  return typeof structuredClone === 'function'
+    ? structuredClone(value)
+    : JSON.parse(JSON.stringify(value));
+}
+
+function clampInteger(value, fallback, min, max) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(number)));
+}
+
+function normalizeReference(value, fallbackKind) {
+  const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  const kind = String(source.kind ?? fallbackKind ?? '').trim().slice(0, 64);
+  const id = String(source.id ?? '').trim().slice(0, 256);
+  return kind && id ? { kind, id } : null;
+}
+
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(
+    Object.keys(value)
+      .sort()
+      .map((key) => [key, stableValue(value[key])]),
+  );
+}
+
+function fingerprint(value) {
+  return crypto
+    .createHash('sha256')
+    .update(JSON.stringify(stableValue(value)))
+    .digest('hex');
+}
+
+function gatewayError(code, message, status = 409) {
+  const error = new Error(message);
+  error.code = code;
+  error.status = status;
+  return error;
+}
+
+export function buildExecutorJobEvent({
+  eventId = crypto.randomUUID(),
+  jobId,
+  sequence = 0,
+  type,
+  timestamp = Date.now(),
+  data = null,
+} = {}) {
+  const normalizedJobId = String(jobId ?? '').trim();
+  const normalizedType = String(type ?? '').trim();
+  if (!normalizedJobId) {
+    throw gatewayError('EXECUTOR_EVENT_JOB_ID_REQUIRED', 'Executor event requires jobId', 422);
+  }
+  if (!normalizedType) {
+    throw gatewayError('EXECUTOR_EVENT_TYPE_REQUIRED', 'Executor event requires type', 422);
+  }
+  return {
+    version: EXECUTOR_JOB_EVENT_VERSION,
+    eventId: String(eventId),
+    jobId: normalizedJobId,
+    sequence: Math.max(0, Number(sequence) || 0),
+    type: normalizedType,
+    timestamp: Number(timestamp) || Date.now(),
+    data: data == null ? null : clone(data),
+  };
+}
+
+export function normalizeExecutorJobRequest(input = {}) {
+  const source = input && typeof input === 'object' && !Array.isArray(input) ? input : {};
+  const jobId = String(source.jobId ?? crypto.randomUUID()).trim();
+  const idempotencyKey = String(source.idempotencyKey ?? '').trim().slice(0, 200);
+  const executor = normalizeWorkflowEngineId(source.executor, '');
+  const instruction = String(source.task?.instruction ?? source.instruction ?? '')
+    .trim()
+    .slice(0, MAX_INSTRUCTION_CHARACTERS);
+  if (!jobId) throw gatewayError('EXECUTOR_JOB_ID_REQUIRED', 'Executor job requires jobId', 422);
+  if (!/^[a-zA-Z0-9:_-]{1,128}$/.test(jobId)) {
+    throw gatewayError(
+      'EXECUTOR_JOB_ID_INVALID',
+      'Executor jobId must be a safe identifier no longer than 128 characters',
+      422,
+    );
+  }
+  if (!idempotencyKey) {
+    throw gatewayError(
+      'EXECUTOR_IDEMPOTENCY_KEY_REQUIRED',
+      'Executor job requires idempotencyKey',
+      422,
+    );
+  }
+  if (!executor) {
+    throw gatewayError('EXECUTOR_ID_REQUIRED', 'Executor job requires executor', 422);
+  }
+  if (!instruction) {
+    throw gatewayError('EXECUTOR_INSTRUCTION_REQUIRED', 'Executor job requires instruction', 422);
+  }
+  return {
+    version: EXECUTOR_JOB_REQUEST_VERSION,
+    jobId,
+    idempotencyKey,
+    executor,
+    task: {
+      type: String(source.task?.type ?? 'code_task').trim().slice(0, 128) || 'code_task',
+      instruction,
+      workspaceRef: normalizeReference(source.task?.workspaceRef, 'workspace'),
+      inputRefs: Array.isArray(source.task?.inputRefs)
+        ? source.task.inputRefs
+          .map((item) => normalizeReference(item, 'artifact'))
+          .filter(Boolean)
+          .slice(0, 100)
+        : [],
+    },
+    subject: {
+      tenantId: String(source.subject?.tenantId ?? '').trim() || null,
+      userId: String(source.subject?.userId ?? '').trim() || null,
+    },
+    authorization: {
+      executionAllowed: source.authorization?.executionAllowed === true,
+      actorId: String(source.authorization?.actorId ?? '').trim() || null,
+    },
+    policy: {
+      sideEffectsAllowed: source.policy?.sideEffectsAllowed === true,
+      networkAllowed: source.policy?.networkAllowed === true,
+    },
+    controls: {
+      timeoutMs: clampInteger(source.controls?.timeoutMs, 15 * 60_000, 500, 60 * 60_000),
+      cancellationAllowed: source.controls?.cancellationAllowed !== false,
+      fallbackExecutor: normalizeWorkflowEngineId(source.controls?.fallbackExecutor, ''),
+      maxAttempts: clampInteger(source.controls?.maxAttempts, 3, 1, 20),
+    },
+    metadata: source.metadata && typeof source.metadata === 'object'
+      ? clone(source.metadata)
+      : {},
+  };
+}
+
+function validateExecutorAdapter(adapter) {
+  if (!adapter || typeof adapter !== 'object') {
+    throw new Error('Executor adapter must be an object');
+  }
+  const id = normalizeWorkflowEngineId(adapter.id, '');
+  if (!id) throw new Error('Executor adapter requires a valid id');
+  for (const method of ['submit', 'cancel', 'getState', 'streamEvents']) {
+    if (typeof adapter[method] !== 'function') {
+      throw new Error(`Executor adapter ${id} missing method: ${method}`);
+    }
+  }
+  return id;
+}
+
+export function createExecutorAdapterRegistry(initialAdapters = []) {
+  const adapters = new Map();
+
+  function register(adapter) {
+    const id = validateExecutorAdapter(adapter);
+    if (adapters.has(id)) throw new Error(`Executor adapter already registered: ${id}`);
+    adapters.set(id, adapter);
+    return adapter;
+  }
+
+  for (const adapter of initialAdapters) register(adapter);
+
+  return {
+    register,
+    has(id) {
+      return adapters.has(normalizeWorkflowEngineId(id, ''));
+    },
+    get(id) {
+      return adapters.get(normalizeWorkflowEngineId(id, '')) ?? null;
+    },
+    list() {
+      return [...adapters.values()].map((adapter) => ({
+        id: adapter.id,
+        label: adapter.label ?? adapter.id,
+        kind: adapter.kind ?? 'plugin',
+        enabled: adapter.enabled === true,
+        dispatchImplemented: adapter.dispatchImplemented === true,
+        status: adapter.status ?? 'unknown',
+        capabilities: Array.isArray(adapter.capabilities)
+          ? [...adapter.capabilities]
+          : [],
+      }));
+    },
+  };
+}
+
+export function createDisabledExecutorAdapter(descriptor) {
+  const id = normalizeWorkflowEngineId(descriptor?.id, '');
+  if (!id) throw new Error('Disabled executor adapter requires a valid id');
+  const reject = () => {
+    throw gatewayError(
+      'EXECUTOR_ADAPTER_DISABLED',
+      `Executor adapter ${id} is contract-only and cannot dispatch`,
+    );
+  };
+  return {
+    id,
+    label: descriptor.label ?? id,
+    kind: descriptor.kind ?? 'plugin',
+    enabled: false,
+    dispatchImplemented: false,
+    status: 'contract-only',
+    capabilities: Array.isArray(descriptor.capabilities)
+      ? [...descriptor.capabilities]
+      : [],
+    submit: reject,
+    cancel: reject,
+    getState: reject,
+    async *streamEvents() {
+      reject();
+    },
+  };
+}
+
+export function createWorkerQueueExecutorAdapter(descriptor, { enabled = false } = {}) {
+  const id = normalizeWorkflowEngineId(descriptor?.id, '');
+  if (!id) throw new Error('Worker queue executor adapter requires a valid id');
+  const reject = () => {
+    throw gatewayError(
+      'EXECUTOR_WORKER_CLAIM_REQUIRED',
+      `Executor adapter ${id} is dispatched through the worker claim protocol`,
+    );
+  };
+  return {
+    id,
+    label: descriptor.label ?? id,
+    kind: descriptor.kind ?? 'worker',
+    enabled,
+    dispatchImplemented: true,
+    status: enabled ? 'worker-queue' : 'disabled',
+    capabilities: Array.isArray(descriptor.capabilities)
+      ? [...descriptor.capabilities, 'lease-fencing']
+      : ['lease-fencing'],
+    submit: reject,
+    cancel: reject,
+    getState: reject,
+    async *streamEvents() {
+      reject();
+    },
+  };
+}
+
+export function createPhase3ExecutorAdapterRegistry() {
+  return createExecutorAdapterRegistry(
+    PHASE3_EXECUTOR_DESCRIPTORS.map(createDisabledExecutorAdapter),
+  );
+}
+
+export function listPhase3ExecutorAdapters() {
+  return createPhase3ExecutorAdapterRegistry().list();
+}
+
+export function createPhase5ExecutorAdapterRegistry({ enabledExecutors = [] } = {}) {
+  const enabled = new Set(
+    (Array.isArray(enabledExecutors) ? enabledExecutors : [])
+      .map((id) => normalizeWorkflowEngineId(id, ''))
+      .filter(Boolean),
+  );
+  return createExecutorAdapterRegistry(
+    PHASE3_EXECUTOR_DESCRIPTORS.map((descriptor) => (
+      createWorkerQueueExecutorAdapter(descriptor, { enabled: enabled.has(descriptor.id) })
+    )),
+  );
+}
+
+export function listPhase5ExecutorAdapters(options = {}) {
+  return createPhase5ExecutorAdapterRegistry(options).list();
+}
+
+export function projectExecutorJobForRead(record) {
+  if (!record) return null;
+  const {
+    request: _request,
+    requestFingerprint: _requestFingerprint,
+    lease,
+    ...safe
+  } = clone(record);
+  return {
+    ...safe,
+    lease: lease
+      ? {
+          workerId: lease.workerId ?? null,
+          acquiredAt: lease.acquiredAt ?? null,
+          heartbeatAt: lease.heartbeatAt ?? null,
+          expiresAt: lease.expiresAt ?? null,
+        }
+      : null,
+  };
+}
+
+export function createInMemoryExecutorJobStore() {
+  const byId = new Map();
+  const byIdempotencyKey = new Map();
+  const eventsByJobId = new Map();
+  const workersById = new Map();
+
+  function appendEvent(jobId, event) {
+    if (!event) return;
+    const events = eventsByJobId.get(jobId) ?? [];
+    events.push({
+      ...clone(event),
+      jobId,
+      sequence: events.length + 1,
+    });
+    eventsByJobId.set(jobId, events);
+  }
+
+  function transitionResult(applied, record, reason = null) {
+    return {
+      applied,
+      record: record ? clone(record) : null,
+      reason,
+    };
+  }
+
+  return {
+    kind: 'memory',
+    durable: false,
+    async getById(jobId) {
+      const value = byId.get(String(jobId ?? '').trim());
+      return value ? clone(value) : null;
+    },
+    async getByIdempotencyKey(key) {
+      const jobId = byIdempotencyKey.get(String(key ?? '').trim());
+      const value = jobId ? byId.get(jobId) : null;
+      return value ? clone(value) : null;
+    },
+    async createIfAbsent(record, { initialEvent = null } = {}) {
+      const existingId = byIdempotencyKey.get(record.idempotencyKey);
+      if (existingId) return { created: false, record: clone(byId.get(existingId)) };
+      if (byId.has(record.jobId)) {
+        throw gatewayError('EXECUTOR_JOB_ID_CONFLICT', `Executor job id already exists: ${record.jobId}`);
+      }
+      byId.set(record.jobId, clone(record));
+      byIdempotencyKey.set(record.idempotencyKey, record.jobId);
+      appendEvent(record.jobId, initialEvent);
+      return { created: true, record: clone(record) };
+    },
+    async update(record, { event = null } = {}) {
+      if (!byId.has(record.jobId)) return null;
+      byId.set(record.jobId, clone(record));
+      appendEvent(record.jobId, event);
+      return clone(record);
+    },
+    async claimNext({
+      workerId,
+      executors,
+      now,
+      leaseToken,
+      leaseDurationMs,
+      eventFactory,
+    }) {
+      const allowedExecutors = new Set(executors);
+      const candidate = [...byId.values()]
+        .filter((record) => (
+          allowedExecutors.has(record.executor)
+          && (
+            record.status === 'queued'
+            || (
+              record.status === 'retryable'
+              && Number(record.nextAttemptAt ?? 0) <= now
+            )
+          )
+        ))
+        .sort((left, right) => (
+          Number(left.createdAt ?? 0) - Number(right.createdAt ?? 0)
+          || String(left.jobId).localeCompare(String(right.jobId))
+        ))[0];
+      if (!candidate) return null;
+      const updated = {
+        ...clone(candidate),
+        status: 'leased',
+        reason: null,
+        attempts: Number(candidate.attempts ?? 0) + 1,
+        nextAttemptAt: null,
+        lease: {
+          token: leaseToken,
+          workerId,
+          acquiredAt: now,
+          heartbeatAt: now,
+          expiresAt: now + leaseDurationMs,
+        },
+        updatedAt: now,
+        completedAt: null,
+      };
+      byId.set(updated.jobId, clone(updated));
+      appendEvent(
+        updated.jobId,
+        typeof eventFactory === 'function' ? eventFactory(updated, candidate) : null,
+      );
+      return clone(updated);
+    },
+    async transition(jobId, {
+      expectedStatuses = [],
+      leaseToken = null,
+      updater,
+      eventFactory = null,
+    } = {}) {
+      const normalizedJobId = String(jobId ?? '').trim();
+      const current = byId.get(normalizedJobId);
+      if (!current) return transitionResult(false, null, 'not_found');
+      if (expectedStatuses.length && !expectedStatuses.includes(current.status)) {
+        return transitionResult(false, current, 'status_mismatch');
+      }
+      if (leaseToken != null && current.lease?.token !== leaseToken) {
+        return transitionResult(false, current, 'lease_mismatch');
+      }
+      const updated = updater(clone(current));
+      if (!updated || updated.jobId !== current.jobId) {
+        throw new Error('Executor job transition must preserve job identity');
+      }
+      byId.set(normalizedJobId, clone(updated));
+      appendEvent(
+        normalizedJobId,
+        typeof eventFactory === 'function' ? eventFactory(updated, current) : null,
+      );
+      return transitionResult(true, updated);
+    },
+    async listExpiredLeases({ now, limit = 100 } = {}) {
+      return [...byId.values()]
+        .filter((record) => (
+          ['leased', 'running'].includes(record.status)
+          && Number(record.lease?.expiresAt ?? 0) <= now
+        ))
+        .sort((left, right) => (
+          Number(left.lease?.expiresAt ?? 0) - Number(right.lease?.expiresAt ?? 0)
+        ))
+        .slice(0, clampInteger(limit, 100, 1, 500))
+        .map(clone);
+    },
+    async getQueueStats({ now = Date.now() } = {}) {
+      const records = [...byId.values()];
+      const counts = {};
+      for (const record of records) {
+        counts[record.status] = Number(counts[record.status] ?? 0) + 1;
+      }
+      return {
+        total: records.length,
+        counts,
+        claimable: records.filter((record) => (
+          record.status === 'queued'
+          || (
+            record.status === 'retryable'
+            && Number(record.nextAttemptAt ?? 0) <= now
+          )
+        )).length,
+        expiredLeases: records.filter((record) => (
+          ['leased', 'running'].includes(record.status)
+          && Number(record.lease?.expiresAt ?? 0) <= now
+        )).length,
+      };
+    },
+    async getAdmissionStats({
+      tenantId = null,
+      userId = null,
+      now = Date.now(),
+      windowMs = 60_000,
+    } = {}) {
+      const activeStatuses = new Set(['queued', 'retryable', 'leased', 'running']);
+      const records = [...byId.values()];
+      const matchesTenant = (record) => (
+        tenantId != null && record.request?.subject?.tenantId === tenantId
+      );
+      const matchesUser = (record) => (
+        userId != null && record.request?.subject?.userId === userId
+      );
+      return {
+        globalActive: records.filter((record) => activeStatuses.has(record.status)).length,
+        tenantActive: tenantId == null
+          ? 0
+          : records.filter((record) => activeStatuses.has(record.status) && matchesTenant(record)).length,
+        userActive: userId == null
+          ? 0
+          : records.filter((record) => activeStatuses.has(record.status) && matchesUser(record)).length,
+        tenantRecent: tenantId == null
+          ? 0
+          : records.filter((record) => (
+              matchesTenant(record) && Number(record.createdAt ?? 0) >= now - windowMs
+            )).length,
+        userRecent: userId == null
+          ? 0
+          : records.filter((record) => (
+              matchesUser(record) && Number(record.createdAt ?? 0) >= now - windowMs
+            )).length,
+      };
+    },
+    async recordWorkerHeartbeat(record) {
+      workersById.set(record.workerId, clone(record));
+      return clone(record);
+    },
+    async listWorkers({ now = Date.now(), staleAfterMs = 60_000 } = {}) {
+      return [...workersById.values()]
+        .sort((left, right) => Number(right.lastSeenAt) - Number(left.lastSeenAt))
+        .map((worker) => ({
+          ...clone(worker),
+          stale: Number(worker.lastSeenAt ?? 0) < now - staleAfterMs,
+        }));
+    },
+    async listEvents(jobId, { after = 0, limit = MAX_EVENT_PAGE_SIZE } = {}) {
+      const cursor = Math.max(0, Number(after) || 0);
+      const pageSize = clampInteger(limit, MAX_EVENT_PAGE_SIZE, 1, MAX_EVENT_PAGE_SIZE);
+      return (eventsByJobId.get(String(jobId ?? '').trim()) ?? [])
+        .filter((event) => event.sequence > cursor)
+        .slice(0, pageSize)
+        .map(clone);
+    },
+  };
+}
+
+function validateJobStore(store) {
+  for (const method of [
+    'getById',
+    'getByIdempotencyKey',
+    'createIfAbsent',
+    'update',
+    'listEvents',
+  ]) {
+    if (typeof store?.[method] !== 'function') {
+      throw new Error(`Executor job store missing method: ${method}`);
+    }
+  }
+}
+
+export function createExecutorGateway({
+  registry = createPhase3ExecutorAdapterRegistry(),
+  store = createInMemoryExecutorJobStore(),
+  nowMs = Date.now,
+  executionEnabled = false,
+  admissionPolicy = null,
+} = {}) {
+  if (!registry?.has || !registry?.list) {
+    throw new Error('Executor Gateway requires an adapter registry');
+  }
+  validateJobStore(store);
+
+  function previewNormalized(request) {
+    const adapter = registry.get(request.executor);
+    const fallbackAdapter = request.controls.fallbackExecutor
+      ? registry.get(request.controls.fallbackExecutor)
+      : null;
+    const fallbackRegistered = Boolean(fallbackAdapter);
+    const fallbackAvailable = fallbackAdapter?.enabled === true
+      && fallbackAdapter?.dispatchImplemented === true;
+    const gates = {
+      implementation: EXECUTOR_DISPATCH_IMPLEMENTED,
+      serviceEnabled: executionEnabled === true,
+      adapterRegistered: Boolean(adapter),
+      adapterEnabled: adapter?.enabled === true,
+      executionAuthorized: request.authorization.executionAllowed,
+      sideEffectsAllowed: request.policy.sideEffectsAllowed,
+      idempotencyKeyPresent: Boolean(request.idempotencyKey),
+      workspaceReferencePresent: Boolean(request.task.workspaceRef),
+    };
+    return {
+      version: 'executor-dispatch-decision-v1',
+      jobId: request.jobId,
+      executor: request.executor,
+      fallbackExecutor: request.controls.fallbackExecutor || null,
+      fallbackRegistered,
+      fallbackAvailable,
+      dispatchAllowed: Object.values(gates).every(Boolean),
+      reason: !EXECUTOR_DISPATCH_IMPLEMENTED
+        ? 'executor_dispatch_not_implemented'
+        : executionEnabled !== true
+          ? 'executor_execution_disabled'
+          : !adapter
+            ? 'executor_adapter_unregistered'
+            : adapter.enabled !== true
+              ? 'executor_adapter_disabled'
+              : !request.authorization.executionAllowed
+                ? 'executor_execution_unauthorized'
+                : !request.policy.sideEffectsAllowed
+                  ? 'executor_side_effects_not_allowed'
+                  : !request.task.workspaceRef
+                    ? 'executor_workspace_required'
+                    : 'queued_for_worker',
+      gates,
+    };
+  }
+
+  async function preview(input) {
+    return previewNormalized(normalizeExecutorJobRequest(input));
+  }
+
+  async function createJob(input) {
+    const request = normalizeExecutorJobRequest(input);
+    const {
+      jobId: _jobId,
+      idempotencyKey: _idempotencyKey,
+      ...semanticRequest
+    } = request;
+    const requestFingerprint = fingerprint(semanticRequest);
+    const existing = await store.getByIdempotencyKey(request.idempotencyKey);
+    if (existing) {
+      if (existing.requestFingerprint !== requestFingerprint) {
+        throw gatewayError(
+          'EXECUTOR_IDEMPOTENCY_CONFLICT',
+          `Idempotency key already belongs to executor job ${existing.jobId}`,
+        );
+      }
+      return { created: false, job: existing };
+    }
+    let decision = previewNormalized(request);
+    if (decision.dispatchAllowed && admissionPolicy?.evaluate) {
+      const admission = await admissionPolicy.evaluate(request);
+      if (!admission.allowed) {
+        decision = {
+          ...decision,
+          dispatchAllowed: false,
+          reason: admission.reason,
+          admission,
+        };
+      } else {
+        decision = { ...decision, admission };
+      }
+    }
+    const now = nowMs();
+    const dispatchAllowed = decision.dispatchAllowed;
+    const record = {
+      version: EXECUTOR_JOB_STATE_VERSION,
+      jobId: request.jobId,
+      idempotencyKey: request.idempotencyKey,
+      requestFingerprint,
+      executor: request.executor,
+      status: dispatchAllowed ? 'queued' : 'blocked',
+      reason: decision.reason,
+      attempts: 0,
+      maxAttempts: request.controls.maxAttempts,
+      dispatchAllowed,
+      cancellationAllowed: request.controls.cancellationAllowed,
+      timeoutMs: request.controls.timeoutMs,
+      fallbackExecutor: decision.fallbackExecutor,
+      fallbackRegistered: decision.fallbackRegistered,
+      fallbackAvailable: decision.fallbackAvailable,
+      decision,
+      request: dispatchAllowed ? request : null,
+      createdAt: now,
+      updatedAt: now,
+      startedAt: null,
+      completedAt: dispatchAllowed ? null : now,
+    };
+    const result = await store.createIfAbsent(record, {
+      initialEvent: buildExecutorJobEvent({
+        jobId: request.jobId,
+        sequence: 1,
+        type: dispatchAllowed ? 'executor_job_queued' : 'executor_job_blocked',
+        timestamp: now,
+        data: {
+          executor: request.executor,
+          status: record.status,
+          reason: record.reason,
+          dispatchAllowed,
+        },
+      }),
+    });
+    if (
+      !result.created
+      && result.record.requestFingerprint !== requestFingerprint
+    ) {
+      throw gatewayError(
+        'EXECUTOR_IDEMPOTENCY_CONFLICT',
+        `Idempotency key already belongs to executor job ${result.record.jobId}`,
+      );
+    }
+    return { created: result.created, job: result.record };
+  }
+
+  async function cancel(jobId, { reason = 'cancelled_by_request' } = {}) {
+    const current = await store.getById(jobId);
+    if (!current) return null;
+    if (current.status === 'cancelled' || !current.cancellationAllowed) return current;
+    if (TERMINAL_JOB_STATUSES.has(current.status) && current.status !== 'blocked') return current;
+    const now = nowMs();
+    const applyCancellation = (record) => ({
+      ...record,
+      status: 'cancelled',
+      reason: String(reason).slice(0, 256),
+      lease: null,
+      updatedAt: now,
+      completedAt: now,
+    });
+    const eventForCancellation = (updated) => buildExecutorJobEvent({
+      jobId: updated.jobId,
+      type: 'executor_job_cancelled',
+      timestamp: now,
+      data: {
+        status: updated.status,
+        reason: updated.reason,
+      },
+    });
+    if (typeof store.transition === 'function') {
+      const result = await store.transition(current.jobId, {
+        expectedStatuses: ['blocked', 'queued', 'retryable', 'leased', 'running'],
+        updater: applyCancellation,
+        eventFactory: eventForCancellation,
+      });
+      return result.applied ? result.record : result.record;
+    }
+    const updated = applyCancellation(current);
+    return store.update(updated, { event: eventForCancellation(updated) });
+  }
+
+  return {
+    preview,
+    createJob,
+    cancel,
+    async getJob(jobId, { includeRequest = false } = {}) {
+      const record = await store.getById(jobId);
+      return includeRequest ? record : projectExecutorJobForRead(record);
+    },
+    async listEvents(jobId, { after = 0, limit = MAX_EVENT_PAGE_SIZE } = {}) {
+      const normalizedJobId = String(jobId ?? '').trim();
+      if (!normalizedJobId) return null;
+      const job = await store.getById(normalizedJobId);
+      if (!job) return null;
+      const cursor = Math.max(0, Number(after) || 0);
+      const events = await store.listEvents(normalizedJobId, {
+        after: cursor,
+        limit: clampInteger(limit, MAX_EVENT_PAGE_SIZE, 1, MAX_EVENT_PAGE_SIZE),
+      });
+      return {
+        jobId: normalizedJobId,
+        events,
+        nextCursor: events.at(-1)?.sequence ?? cursor,
+      };
+    },
+    listAdapters() {
+      return registry.list();
+    },
+    status() {
+      return {
+        version: 'executor-gateway-status-v1',
+        dispatchImplemented: EXECUTOR_DISPATCH_IMPLEMENTED,
+        executionEnabled: executionEnabled === true,
+        store: {
+          kind: String(store.kind ?? (store.durable ? 'durable' : 'memory')),
+          durable: store.durable === true,
+        },
+        adapters: registry.list(),
+      };
+    },
+  };
+}
+
+export const executorGatewayInternals = {
+  EXECUTOR_DISPATCH_IMPLEMENTED,
+  EXECUTOR_JOB_EVENT_VERSION,
+  EXECUTOR_JOB_REQUEST_VERSION,
+  EXECUTOR_JOB_STATE_VERSION,
+  MAX_EVENT_PAGE_SIZE,
+  MAX_INSTRUCTION_CHARACTERS,
+  PHASE3_EXECUTOR_DESCRIPTORS,
+  TERMINAL_JOB_STATUSES,
+  fingerprint,
+  projectExecutorJobForRead,
+  stableValue,
+};
diff --git a/services/orchestrator/executor-gateway.test.mjs b/services/orchestrator/executor-gateway.test.mjs
new file mode 100644
index 0000000..8f6af2f
--- /dev/null
+++ b/services/orchestrator/executor-gateway.test.mjs
@@ -0,0 +1,192 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildExecutorJobEvent,
+  createExecutorAdapterRegistry,
+  createExecutorGateway,
+  createInMemoryExecutorJobStore,
+  createPhase3ExecutorAdapterRegistry,
+  createPhase5ExecutorAdapterRegistry,
+  normalizeExecutorJobRequest,
+} from './executor-gateway.mjs';
+
+function request(overrides = {}) {
+  return {
+    jobId: 'job-1',
+    idempotencyKey: 'run-1:node-execute:attempt-1',
+    executor: 'aider',
+    task: {
+      type: 'code_change',
+      instruction: 'Fix the login form validation',
+      workspaceRef: { kind: 'mindspace-workspace', id: 'workspace-1' },
+    },
+    subject: { userId: 'user-1' },
+    authorization: { executionAllowed: true, actorId: 'user-1' },
+    policy: { sideEffectsAllowed: true, networkAllowed: false },
+    controls: {
+      timeoutMs: 20_000,
+      cancellationAllowed: true,
+      fallbackExecutor: 'goosed',
+    },
+    ...overrides,
+  };
+}
+
+test('executor job contract uses resource references and bounded controls', () => {
+  const normalized = normalizeExecutorJobRequest(request({
+    task: {
+      instruction: 'x'.repeat(40_000),
+      workspaceRef: { kind: 'workspace', id: 'workspace-1' },
+      inputRefs: [
+        { kind: 'artifact', id: 'artifact-1' },
+        { kind: '', id: 'invalid' },
+      ],
+    },
+    controls: { timeoutMs: 100, fallbackExecutor: 'openhands' },
+  }));
+  assert.equal(normalized.version, 'executor-job-request-v1');
+  assert.equal(normalized.task.instruction.length, 32_000);
+  assert.deepEqual(normalized.task.workspaceRef, { kind: 'workspace', id: 'workspace-1' });
+  assert.deepEqual(normalized.task.inputRefs, [{ kind: 'artifact', id: 'artifact-1' }]);
+  assert.equal(normalized.controls.timeoutMs, 500);
+  assert.equal(normalized.controls.fallbackExecutor, 'openhands');
+  assert.equal('cwd' in normalized.task, false);
+  assert.throws(
+    () => normalizeExecutorJobRequest(request({ jobId: '../unsafe' })),
+    (error) => error.code === 'EXECUTOR_JOB_ID_INVALID',
+  );
+
+  const event = buildExecutorJobEvent({
+    eventId: 'event-1',
+    jobId: 'job-1',
+    sequence: 1,
+    type: 'executor_job_blocked',
+    timestamp: 1234,
+    data: { status: 'blocked' },
+  });
+  assert.equal(event.version, 'executor-job-event-v1');
+  assert.equal(event.sequence, 1);
+  assert.deepEqual(event.data, { status: 'blocked' });
+});
+
+test('Phase 3 executor catalog exposes disabled Goosed, Aider and OpenHands adapters', () => {
+  const registry = createPhase3ExecutorAdapterRegistry();
+  assert.deepEqual(
+    registry.list().map((adapter) => adapter.id),
+    ['goosed', 'aider', 'openhands'],
+  );
+  for (const adapter of registry.list()) {
+    assert.equal(adapter.enabled, false);
+    assert.equal(adapter.dispatchImplemented, false);
+    assert.equal(adapter.status, 'contract-only');
+  }
+});
+
+test('executor adapter registry rejects incomplete and duplicate adapters', () => {
+  const registry = createExecutorAdapterRegistry();
+  assert.throws(() => registry.register({ id: 'broken' }), /missing method/);
+  const adapter = {
+    id: 'custom',
+    submit() {},
+    cancel() {},
+    getState() {},
+    async *streamEvents() {},
+  };
+  registry.register(adapter);
+  assert.throws(() => registry.register(adapter), /already registered/);
+});
+
+test('Executor Gateway records a blocked idempotent job without calling an adapter', async () => {
+  let now = 1000;
+  const gateway = createExecutorGateway({
+    store: createInMemoryExecutorJobStore(),
+    nowMs: () => now,
+  });
+  const preview = await gateway.preview(request());
+  assert.equal(preview.executor, 'aider');
+  assert.equal(preview.fallbackExecutor, 'goosed');
+  assert.equal(preview.fallbackRegistered, true);
+  assert.equal(preview.fallbackAvailable, false);
+  assert.equal(preview.dispatchAllowed, false);
+  assert.equal(preview.gates.implementation, true);
+  assert.equal(preview.gates.serviceEnabled, false);
+  assert.equal(preview.gates.adapterEnabled, false);
+
+  const first = await gateway.createJob(request());
+  assert.equal(first.created, true);
+  assert.equal(first.job.status, 'blocked');
+  assert.equal(first.job.attempts, 0);
+  assert.equal(first.job.reason, 'executor_execution_disabled');
+
+  now = 2000;
+  const repeated = await gateway.createJob(request());
+  assert.equal(repeated.created, false);
+  assert.equal(repeated.job.jobId, first.job.jobId);
+  assert.equal(repeated.job.createdAt, 1000);
+  const eventPage = await gateway.listEvents('job-1');
+  assert.deepEqual(eventPage.events.map((event) => event.type), ['executor_job_blocked']);
+  assert.equal(eventPage.nextCursor, 1);
+});
+
+test('Executor Gateway rejects idempotency key reuse with a different payload', async () => {
+  const gateway = createExecutorGateway();
+  await gateway.createJob(request());
+  await assert.rejects(
+    () => gateway.createJob(request({
+      jobId: 'job-2',
+      task: {
+        type: 'code_change',
+        instruction: 'A different instruction',
+        workspaceRef: { kind: 'mindspace-workspace', id: 'workspace-1' },
+      },
+    })),
+    (error) => error.code === 'EXECUTOR_IDEMPOTENCY_CONFLICT',
+  );
+});
+
+test('Executor Gateway cancellation is idempotent and never invokes a disabled adapter', async () => {
+  let now = 1000;
+  const gateway = createExecutorGateway({ nowMs: () => now });
+  await gateway.createJob(request());
+  now = 1500;
+  const cancelled = await gateway.cancel('job-1', { reason: 'user_cancelled' });
+  assert.equal(cancelled.status, 'cancelled');
+  assert.equal(cancelled.reason, 'user_cancelled');
+  assert.equal(cancelled.completedAt, 1500);
+  assert.deepEqual(await gateway.cancel('job-1'), cancelled);
+  assert.equal(await gateway.cancel('missing-job'), null);
+  const eventPage = await gateway.listEvents('job-1', { after: 1 });
+  assert.deepEqual(eventPage.events.map((event) => event.type), ['executor_job_cancelled']);
+  assert.equal(eventPage.events[0].sequence, 2);
+  assert.equal(eventPage.nextCursor, 2);
+  assert.equal(await gateway.listEvents('missing-job'), null);
+});
+
+test('Executor Gateway reports implemented capability while execution remains disabled', () => {
+  const status = createExecutorGateway().status();
+  assert.equal(status.version, 'executor-gateway-status-v1');
+  assert.equal(status.dispatchImplemented, true);
+  assert.equal(status.executionEnabled, false);
+  assert.deepEqual(status.store, { kind: 'memory', durable: false });
+});
+
+test('Executor Gateway queues only explicitly enabled and authorized worker jobs', async () => {
+  const gateway = createExecutorGateway({
+    registry: createPhase5ExecutorAdapterRegistry({ enabledExecutors: ['aider'] }),
+    executionEnabled: true,
+  });
+  const created = await gateway.createJob(request());
+  assert.equal(created.job.status, 'queued');
+  assert.equal(created.job.reason, 'queued_for_worker');
+  assert.equal(created.job.dispatchAllowed, true);
+  assert.equal(created.job.maxAttempts, 3);
+  assert.equal(created.job.request.task.instruction, 'Fix the login form validation');
+
+  const projected = await gateway.getJob('job-1');
+  assert.equal('request' in projected, false);
+  assert.equal('requestFingerprint' in projected, false);
+  assert.deepEqual(
+    (await gateway.listEvents('job-1')).events.map((event) => event.type),
+    ['executor_job_queued'],
+  );
+});
diff --git a/services/orchestrator/executor-job-store.mjs b/services/orchestrator/executor-job-store.mjs
new file mode 100644
index 0000000..21eb85d
--- /dev/null
+++ b/services/orchestrator/executor-job-store.mjs
@@ -0,0 +1,580 @@
+import pg from 'pg';
+import { createInMemoryExecutorJobStore } from './executor-gateway.mjs';
+
+const { Pool } = pg;
+const DEFAULT_EXECUTOR_SCHEMA = 'memind_orchestrator';
+const EXECUTOR_JOB_TABLE = 'executor_jobs';
+const EXECUTOR_JOB_EVENT_TABLE = 'executor_job_events';
+const EXECUTOR_WORKER_TABLE = 'executor_workers';
+
+function normalizeMode(value) {
+  const mode = String(value ?? 'postgres').trim().toLowerCase();
+  if (mode === 'memory' || mode === 'postgres') return mode;
+  throw new Error(`Unsupported executor job store mode: ${value}`);
+}
+
+function normalizeSchema(value) {
+  const schema = String(value ?? DEFAULT_EXECUTOR_SCHEMA).trim();
+  if (!/^[a-z_][a-z0-9_]{0,62}$/i.test(schema)) {
+    throw new Error('Invalid Executor Gateway PostgreSQL schema');
+  }
+  return schema;
+}
+
+function parseState(value) {
+  if (value == null) return null;
+  if (typeof value === 'object') return structuredClone(value);
+  try {
+    return JSON.parse(String(value));
+  } catch {
+    return null;
+  }
+}
+
+function projectRow(row) {
+  return parseState(row?.state_json);
+}
+
+function projectEventRow(row) {
+  return parseState(row?.event_json);
+}
+
+function eventWithSequence(event, jobId, sequence) {
+  return {
+    ...structuredClone(event),
+    jobId,
+    sequence,
+  };
+}
+
+async function appendEvent(client, eventTable, jobId, event) {
+  if (!event) return null;
+  const sequenceResult = await client.query(
+    `SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence
+       FROM ${eventTable}
+      WHERE job_id = $1`,
+    [jobId],
+  );
+  const sequence = Number(sequenceResult.rows?.[0]?.next_sequence ?? 1);
+  const persistedEvent = eventWithSequence(event, jobId, sequence);
+  await client.query(
+    `INSERT INTO ${eventTable}
+      (event_id, job_id, sequence, event_json, created_at)
+     VALUES ($1, $2, $3, $4::jsonb, $5)`,
+    [
+      persistedEvent.eventId,
+      jobId,
+      sequence,
+      JSON.stringify(persistedEvent),
+      persistedEvent.timestamp,
+    ],
+  );
+  return persistedEvent;
+}
+
+async function withTransaction(pool, operation) {
+  if (typeof pool?.connect !== 'function') {
+    throw new Error('PostgreSQL Executor Job Store requires transactional pool.connect');
+  }
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+    const result = await operation(client);
+    await client.query('COMMIT');
+    return result;
+  } catch (error) {
+    try {
+      await client.query('ROLLBACK');
+    } catch {
+      // Preserve the transactional operation failure.
+    }
+    throw error;
+  } finally {
+    client.release?.();
+  }
+}
+
+export function createPostgresExecutorJobStore({
+  pool,
+  schema = DEFAULT_EXECUTOR_SCHEMA,
+} = {}) {
+  if (!pool?.query) throw new Error('PostgreSQL Executor Job Store requires a pool');
+  const normalizedSchema = normalizeSchema(schema);
+  const table = `"${normalizedSchema}"."${EXECUTOR_JOB_TABLE}"`;
+  const eventTable = `"${normalizedSchema}"."${EXECUTOR_JOB_EVENT_TABLE}"`;
+  const workerTable = `"${normalizedSchema}"."${EXECUTOR_WORKER_TABLE}"`;
+
+  return {
+    kind: 'postgres',
+    durable: true,
+
+    async ensureSchema() {
+      await pool.query(`CREATE SCHEMA IF NOT EXISTS "${normalizedSchema}"`);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS ${table} (
+          job_id VARCHAR(128) PRIMARY KEY,
+          idempotency_key VARCHAR(200) NOT NULL UNIQUE,
+          request_fingerprint CHAR(64) NOT NULL,
+          state_json JSONB NOT NULL,
+          created_at BIGINT NOT NULL,
+          updated_at BIGINT NOT NULL
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS executor_jobs_updated_at_idx
+          ON ${table} (updated_at DESC)
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS ${eventTable} (
+          event_id VARCHAR(128) PRIMARY KEY,
+          job_id VARCHAR(128) NOT NULL REFERENCES ${table} (job_id) ON DELETE CASCADE,
+          sequence INTEGER NOT NULL,
+          event_json JSONB NOT NULL,
+          created_at BIGINT NOT NULL,
+          UNIQUE (job_id, sequence)
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS executor_job_events_job_sequence_idx
+          ON ${eventTable} (job_id, sequence)
+      `);
+      await pool.query(`
+        INSERT INTO ${eventTable} (event_id, job_id, sequence, event_json, created_at)
+        SELECT
+          'evt_' || md5(job_id || ':snapshot-import'),
+          job_id,
+          1,
+          jsonb_build_object(
+            'version', 'executor-job-event-v1',
+            'eventId', 'evt_' || md5(job_id || ':snapshot-import'),
+            'jobId', job_id,
+            'sequence', 1,
+            'type', 'executor_job_snapshot_imported',
+            'timestamp', created_at,
+            'data', jsonb_build_object(
+              'status', state_json->>'status',
+              'reason', state_json->>'reason'
+            )
+          ),
+          created_at
+        FROM ${table} jobs
+        WHERE NOT EXISTS (
+          SELECT 1 FROM ${eventTable} events WHERE events.job_id = jobs.job_id
+        )
+        ON CONFLICT DO NOTHING
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS ${workerTable} (
+          worker_id VARCHAR(128) PRIMARY KEY,
+          state_json JSONB NOT NULL,
+          last_seen_at BIGINT NOT NULL
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS executor_workers_last_seen_idx
+          ON ${workerTable} (last_seen_at DESC)
+      `);
+    },
+
+    async getById(jobId) {
+      const result = await pool.query(
+        `SELECT state_json FROM ${table} WHERE job_id = $1 LIMIT 1`,
+        [String(jobId ?? '').trim()],
+      );
+      return projectRow(result.rows?.[0]);
+    },
+
+    async getByIdempotencyKey(key) {
+      const result = await pool.query(
+        `SELECT state_json FROM ${table} WHERE idempotency_key = $1 LIMIT 1`,
+        [String(key ?? '').trim()],
+      );
+      return projectRow(result.rows?.[0]);
+    },
+
+    async createIfAbsent(record, { initialEvent = null } = {}) {
+      const created = await withTransaction(pool, async (client) => {
+        const inserted = await client.query(
+          `INSERT INTO ${table}
+            (job_id, idempotency_key, request_fingerprint, state_json, created_at, updated_at)
+           VALUES ($1, $2, $3, $4::jsonb, $5, $6)
+           ON CONFLICT DO NOTHING
+           RETURNING state_json`,
+          [
+            record.jobId,
+            record.idempotencyKey,
+            record.requestFingerprint,
+            JSON.stringify(record),
+            record.createdAt,
+            record.updatedAt,
+          ],
+        );
+        const insertedRecord = projectRow(inserted.rows?.[0]);
+        if (!insertedRecord || !initialEvent) return insertedRecord;
+        const event = eventWithSequence(initialEvent, record.jobId, 1);
+        await client.query(
+          `INSERT INTO ${eventTable}
+            (event_id, job_id, sequence, event_json, created_at)
+           VALUES ($1, $2, $3, $4::jsonb, $5)`,
+          [
+            event.eventId,
+            record.jobId,
+            event.sequence,
+            JSON.stringify(event),
+            event.timestamp,
+          ],
+        );
+        return insertedRecord;
+      });
+      if (created) return { created: true, record: created };
+
+      const existingResult = await pool.query(
+        `SELECT state_json FROM ${table} WHERE idempotency_key = $1 LIMIT 1`,
+        [record.idempotencyKey],
+      );
+      const existing = projectRow(existingResult.rows?.[0]);
+      if (existing) return { created: false, record: existing };
+
+      const error = new Error(`Executor job id already exists: ${record.jobId}`);
+      error.code = 'EXECUTOR_JOB_ID_CONFLICT';
+      error.status = 409;
+      throw error;
+    },
+
+    async update(record, { event = null } = {}) {
+      return withTransaction(pool, async (client) => {
+        const locked = await client.query(
+          `SELECT job_id FROM ${table} WHERE job_id = $1 FOR UPDATE`,
+          [record.jobId],
+        );
+        if (!locked.rows?.[0]) return null;
+        const result = await client.query(
+          `UPDATE ${table}
+              SET state_json = $2::jsonb,
+                  updated_at = $3
+            WHERE job_id = $1
+            RETURNING state_json`,
+          [record.jobId, JSON.stringify(record), record.updatedAt],
+        );
+        await appendEvent(client, eventTable, record.jobId, event);
+        return projectRow(result.rows?.[0]);
+      });
+    },
+
+    async claimNext({
+      workerId,
+      executors,
+      now,
+      leaseToken,
+      leaseDurationMs,
+      eventFactory,
+    }) {
+      return withTransaction(pool, async (client) => {
+        const selected = await client.query(
+          `SELECT state_json
+             FROM ${table}
+            WHERE (
+                state_json->>'status' = 'queued'
+                OR (
+                  state_json->>'status' = 'retryable'
+                  AND COALESCE((state_json->>'nextAttemptAt')::BIGINT, 0) <= $1
+                )
+              )
+              AND state_json->>'executor' = ANY($2::text[])
+            ORDER BY created_at ASC, job_id ASC
+            FOR UPDATE SKIP LOCKED
+            LIMIT 1`,
+          [now, executors],
+        );
+        const current = projectRow(selected.rows?.[0]);
+        if (!current) return null;
+        const updated = {
+          ...current,
+          status: 'leased',
+          reason: null,
+          attempts: Number(current.attempts ?? 0) + 1,
+          nextAttemptAt: null,
+          lease: {
+            token: leaseToken,
+            workerId,
+            acquiredAt: now,
+            heartbeatAt: now,
+            expiresAt: now + leaseDurationMs,
+          },
+          updatedAt: now,
+          completedAt: null,
+        };
+        const result = await client.query(
+          `UPDATE ${table}
+              SET state_json = $2::jsonb,
+                  updated_at = $3
+            WHERE job_id = $1
+            RETURNING state_json`,
+          [updated.jobId, JSON.stringify(updated), updated.updatedAt],
+        );
+        await appendEvent(
+          client,
+          eventTable,
+          updated.jobId,
+          typeof eventFactory === 'function' ? eventFactory(updated, current) : null,
+        );
+        return projectRow(result.rows?.[0]);
+      });
+    },
+
+    async transition(jobId, {
+      expectedStatuses = [],
+      leaseToken = null,
+      updater,
+      eventFactory = null,
+    } = {}) {
+      return withTransaction(pool, async (client) => {
+        const locked = await client.query(
+          `SELECT state_json FROM ${table} WHERE job_id = $1 FOR UPDATE`,
+          [String(jobId ?? '').trim()],
+        );
+        const current = projectRow(locked.rows?.[0]);
+        if (!current) return { applied: false, record: null, reason: 'not_found' };
+        if (expectedStatuses.length && !expectedStatuses.includes(current.status)) {
+          return { applied: false, record: current, reason: 'status_mismatch' };
+        }
+        if (leaseToken != null && current.lease?.token !== leaseToken) {
+          return { applied: false, record: current, reason: 'lease_mismatch' };
+        }
+        const updated = updater(structuredClone(current));
+        if (!updated || updated.jobId !== current.jobId) {
+          throw new Error('Executor job transition must preserve job identity');
+        }
+        const result = await client.query(
+          `UPDATE ${table}
+              SET state_json = $2::jsonb,
+                  updated_at = $3
+            WHERE job_id = $1
+            RETURNING state_json`,
+          [current.jobId, JSON.stringify(updated), updated.updatedAt],
+        );
+        await appendEvent(
+          client,
+          eventTable,
+          current.jobId,
+          typeof eventFactory === 'function' ? eventFactory(updated, current) : null,
+        );
+        return {
+          applied: true,
+          record: projectRow(result.rows?.[0]),
+          reason: null,
+        };
+      });
+    },
+
+    async listExpiredLeases({ now, limit = 100 } = {}) {
+      const pageSize = Math.min(500, Math.max(1, Number(limit) || 100));
+      const result = await pool.query(
+        `SELECT state_json
+           FROM ${table}
+          WHERE state_json->>'status' = ANY($1::text[])
+            AND COALESCE((state_json->'lease'->>'expiresAt')::BIGINT, 0) <= $2
+          ORDER BY COALESCE((state_json->'lease'->>'expiresAt')::BIGINT, 0) ASC
+          LIMIT $3`,
+        [['leased', 'running'], now, pageSize],
+      );
+      return (result.rows ?? []).map(projectRow).filter(Boolean);
+    },
+
+    async getQueueStats({ now = Date.now() } = {}) {
+      const result = await pool.query(
+        `SELECT
+            COUNT(*)::BIGINT AS total,
+            COUNT(*) FILTER (
+              WHERE state_json->>'status' = 'queued'
+                 OR (
+                   state_json->>'status' = 'retryable'
+                   AND COALESCE((state_json->>'nextAttemptAt')::BIGINT, 0) <= $1
+                 )
+            )::BIGINT AS claimable,
+            COUNT(*) FILTER (
+              WHERE state_json->>'status' = ANY($2::text[])
+                AND COALESCE((state_json->'lease'->>'expiresAt')::BIGINT, 0) <= $1
+            )::BIGINT AS expired_leases,
+            state_json->>'status' AS status,
+            COUNT(*)::BIGINT AS status_count
+           FROM ${table}
+          GROUP BY state_json->>'status'`,
+        [now, ['leased', 'running']],
+      );
+      const counts = {};
+      let total = 0;
+      let claimable = 0;
+      let expiredLeases = 0;
+      for (const row of result.rows ?? []) {
+        if (row.status) counts[row.status] = Number(row.status_count ?? 0);
+        total += Number(row.status_count ?? 0);
+        claimable += Number(row.claimable ?? 0);
+        expiredLeases += Number(row.expired_leases ?? 0);
+      }
+      return { total, counts, claimable, expiredLeases };
+    },
+
+    async getAdmissionStats({
+      tenantId = null,
+      userId = null,
+      now = Date.now(),
+      windowMs = 60_000,
+    } = {}) {
+      const result = await pool.query(
+        `SELECT
+            COUNT(*) FILTER (
+              WHERE state_json->>'status' = ANY($1::text[])
+            )::BIGINT AS global_active,
+            COUNT(*) FILTER (
+              WHERE state_json->>'status' = ANY($1::text[])
+                AND $2::text IS NOT NULL
+                AND state_json->'request'->'subject'->>'tenantId' = $2
+            )::BIGINT AS tenant_active,
+            COUNT(*) FILTER (
+              WHERE state_json->>'status' = ANY($1::text[])
+                AND $3::text IS NOT NULL
+                AND state_json->'request'->'subject'->>'userId' = $3
+            )::BIGINT AS user_active,
+            COUNT(*) FILTER (
+              WHERE $2::text IS NOT NULL
+                AND state_json->'request'->'subject'->>'tenantId' = $2
+                AND created_at >= $4
+            )::BIGINT AS tenant_recent,
+            COUNT(*) FILTER (
+              WHERE $3::text IS NOT NULL
+                AND state_json->'request'->'subject'->>'userId' = $3
+                AND created_at >= $4
+            )::BIGINT AS user_recent
+           FROM ${table}`,
+        [
+          ['queued', 'retryable', 'leased', 'running'],
+          tenantId,
+          userId,
+          now - windowMs,
+        ],
+      );
+      const row = result.rows?.[0] ?? {};
+      return {
+        globalActive: Number(row.global_active ?? 0),
+        tenantActive: Number(row.tenant_active ?? 0),
+        userActive: Number(row.user_active ?? 0),
+        tenantRecent: Number(row.tenant_recent ?? 0),
+        userRecent: Number(row.user_recent ?? 0),
+      };
+    },
+
+    async recordWorkerHeartbeat(record) {
+      await pool.query(
+        `INSERT INTO ${workerTable} (worker_id, state_json, last_seen_at)
+         VALUES ($1, $2::jsonb, $3)
+         ON CONFLICT (worker_id) DO UPDATE
+           SET state_json = EXCLUDED.state_json,
+               last_seen_at = EXCLUDED.last_seen_at`,
+        [record.workerId, JSON.stringify(record), record.lastSeenAt],
+      );
+      return structuredClone(record);
+    },
+
+    async listWorkers({ now = Date.now(), staleAfterMs = 60_000 } = {}) {
+      const result = await pool.query(
+        `SELECT state_json
+           FROM ${workerTable}
+          ORDER BY last_seen_at DESC
+          LIMIT 500`,
+      );
+      return (result.rows ?? [])
+        .map(projectRow)
+        .filter(Boolean)
+        .map((worker) => ({
+          ...worker,
+          stale: Number(worker.lastSeenAt ?? 0) < now - staleAfterMs,
+        }));
+    },
+
+    async listEvents(jobId, { after = 0, limit = 500 } = {}) {
+      const cursor = Math.max(0, Number(after) || 0);
+      const pageSize = Math.min(500, Math.max(1, Number(limit) || 500));
+      const result = await pool.query(
+        `SELECT event_json
+           FROM ${eventTable}
+          WHERE job_id = $1 AND sequence > $2
+          ORDER BY sequence ASC
+          LIMIT $3`,
+        [String(jobId ?? '').trim(), cursor, pageSize],
+      );
+      return (result.rows ?? []).map(projectEventRow).filter(Boolean);
+    },
+  };
+}
+
+export async function createExecutorJobPersistence({
+  mode = process.env.MEMIND_ORCHESTRATOR_CHECKPOINT_MODE,
+  connectionString = process.env.MEMIND_ORCHESTRATOR_DATABASE_URL,
+  schema = process.env.MEMIND_ORCHESTRATOR_DATABASE_SCHEMA,
+  poolFactory = (config) => new Pool(config),
+} = {}) {
+  const normalizedMode = normalizeMode(mode);
+  if (normalizedMode === 'memory') {
+    const store = createInMemoryExecutorJobStore();
+    return {
+      kind: 'memory',
+      durable: false,
+      store,
+      async probe() {
+        return true;
+      },
+      async close() {},
+    };
+  }
+
+  const normalizedConnectionString = String(connectionString ?? '').trim();
+  if (!normalizedConnectionString) {
+    const error = new Error(
+      'MEMIND_ORCHESTRATOR_DATABASE_URL is required for PostgreSQL Executor Job Store',
+    );
+    error.code = 'ORCHESTRATOR_DATABASE_URL_REQUIRED';
+    throw error;
+  }
+
+  const normalizedSchema = normalizeSchema(schema);
+  const pool = poolFactory({ connectionString: normalizedConnectionString });
+  const store = createPostgresExecutorJobStore({ pool, schema: normalizedSchema });
+  try {
+    await store.ensureSchema();
+  } catch (error) {
+    try {
+      await pool.end?.();
+    } catch {
+      // Preserve the schema initialization failure.
+    }
+    throw error;
+  }
+  return {
+    kind: 'postgres',
+    durable: true,
+    store,
+    async probe() {
+      await pool.query('SELECT 1 AS ok');
+      return true;
+    },
+    async close() {
+      await pool.end?.();
+    },
+  };
+}
+
+export const executorJobStoreInternals = {
+  DEFAULT_EXECUTOR_SCHEMA,
+  EXECUTOR_JOB_TABLE,
+  EXECUTOR_JOB_EVENT_TABLE,
+  EXECUTOR_WORKER_TABLE,
+  appendEvent,
+  eventWithSequence,
+  normalizeMode,
+  normalizeSchema,
+  parseState,
+  projectEventRow,
+  projectRow,
+  withTransaction,
+};
diff --git a/services/orchestrator/executor-job-store.test.mjs b/services/orchestrator/executor-job-store.test.mjs
new file mode 100644
index 0000000..ae9c890
--- /dev/null
+++ b/services/orchestrator/executor-job-store.test.mjs
@@ -0,0 +1,260 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  createExecutorJobPersistence,
+  createPostgresExecutorJobStore,
+  executorJobStoreInternals,
+} from './executor-job-store.mjs';
+
+function record(overrides = {}) {
+  return {
+    version: 'executor-job-state-v1',
+    jobId: 'job-1',
+    idempotencyKey: 'idem-1',
+    requestFingerprint: 'a'.repeat(64),
+    status: 'blocked',
+    createdAt: 1000,
+    updatedAt: 1000,
+    ...overrides,
+  };
+}
+
+function transactionalPool(query) {
+  return {
+    query,
+    async connect() {
+      return {
+        query,
+        release() {},
+      };
+    },
+  };
+}
+
+test('PostgreSQL Executor Job Store creates an isolated schema and job table', async () => {
+  const queries = [];
+  const store = createPostgresExecutorJobStore({
+    schema: 'memind_orchestrator_test',
+    pool: {
+      async query(sql, params = []) {
+        queries.push({ sql, params });
+        return { rows: [] };
+      },
+    },
+  });
+  await store.ensureSchema();
+  assert.equal(store.kind, 'postgres');
+  assert.equal(store.durable, true);
+  assert.match(queries[0].sql, /CREATE SCHEMA IF NOT EXISTS "memind_orchestrator_test"/);
+  assert.match(queries[1].sql, /"memind_orchestrator_test"\."executor_jobs"/);
+  assert.match(queries[1].sql, /idempotency_key VARCHAR\(200\) NOT NULL UNIQUE/);
+  assert.match(queries[2].sql, /executor_jobs_updated_at_idx/);
+  assert.match(queries[3].sql, /"memind_orchestrator_test"\."executor_job_events"/);
+  assert.match(queries[3].sql, /UNIQUE \(job_id, sequence\)/);
+  assert.match(queries[5].sql, /executor_job_snapshot_imported/);
+  assert.match(queries[6].sql, /executor_workers/);
+  assert.match(queries[7].sql, /executor_workers_last_seen_idx/);
+});
+
+test('PostgreSQL Executor Job Store atomically creates and reloads idempotent state', async () => {
+  const stored = record();
+  const blockedEvent = {
+    version: 'executor-job-event-v1',
+    eventId: 'event-1',
+    jobId: 'job-1',
+    sequence: 1,
+    type: 'executor_job_blocked',
+    timestamp: 1000,
+    data: { status: 'blocked' },
+  };
+  const calls = [];
+  const store = createPostgresExecutorJobStore({
+    pool: transactionalPool(async (sql, params = []) => {
+      calls.push({ sql, params });
+      if (sql.includes('INSERT INTO') && sql.includes('executor_jobs')) {
+        return { rows: [{ state_json: stored }] };
+      }
+      if (sql.includes('INSERT INTO') && sql.includes('executor_job_events')) {
+        return { rows: [] };
+      }
+      if (sql.includes('SELECT job_id') && sql.includes('FOR UPDATE')) {
+        return { rows: [{ job_id: 'job-1' }] };
+      }
+      if (sql.includes('UPDATE')) {
+        return { rows: [{ state_json: { ...stored, status: 'cancelled' } }] };
+      }
+      if (sql.includes('MAX(sequence)')) {
+        return { rows: [{ next_sequence: 2 }] };
+      }
+      if (sql.includes('SELECT event_json')) {
+        return { rows: [{ event_json: blockedEvent }] };
+      }
+      if (sql.includes('WHERE job_id =')) {
+        return { rows: [{ state_json: JSON.stringify(stored) }] };
+      }
+      if (sql.includes('WHERE idempotency_key =')) {
+        return { rows: [{ state_json: stored }] };
+      }
+      return { rows: [] };
+    }),
+  });
+
+  const created = await store.createIfAbsent(stored, { initialEvent: blockedEvent });
+  assert.equal(created.created, true);
+  assert.deepEqual(created.record, stored);
+  assert.deepEqual(await store.getById('job-1'), stored);
+  assert.deepEqual(await store.getByIdempotencyKey('idem-1'), stored);
+  assert.equal(
+    (await store.update(
+      { ...stored, status: 'cancelled' },
+      { event: { ...blockedEvent, eventId: 'event-2', type: 'executor_job_cancelled' } },
+    )).status,
+    'cancelled',
+  );
+  assert.deepEqual(await store.listEvents('job-1'), [blockedEvent]);
+  const jobInsert = calls.find((call) => (
+    call.sql.includes('INSERT INTO') && call.sql.includes('executor_jobs')
+  ));
+  assert.equal(JSON.parse(jobInsert.params[3]).jobId, 'job-1');
+  assert.equal(calls.filter((call) => call.sql.trim() === 'BEGIN').length, 2);
+  assert.equal(calls.filter((call) => call.sql.trim() === 'COMMIT').length, 2);
+});
+
+test('PostgreSQL Executor Job Store returns the existing idempotent record after conflict', async () => {
+  const stored = record();
+  const store = createPostgresExecutorJobStore({
+    pool: transactionalPool(async (sql) => {
+      if (sql.includes('INSERT INTO')) return { rows: [] };
+      if (sql.includes('WHERE idempotency_key =')) {
+        return { rows: [{ state_json: stored }] };
+      }
+      return { rows: [] };
+    }),
+  });
+  assert.deepEqual(
+    await store.createIfAbsent(stored),
+    { created: false, record: stored },
+  );
+});
+
+test('PostgreSQL Executor Job Store rolls back job creation when its initial event fails', async () => {
+  const calls = [];
+  const eventError = new Error('event insert unavailable');
+  const store = createPostgresExecutorJobStore({
+    pool: transactionalPool(async (sql) => {
+      calls.push(sql.trim());
+      if (sql.includes('INSERT INTO') && sql.includes('executor_jobs')) {
+        return { rows: [{ state_json: record() }] };
+      }
+      if (sql.includes('INSERT INTO') && sql.includes('executor_job_events')) {
+        throw eventError;
+      }
+      return { rows: [] };
+    }),
+  });
+
+  await assert.rejects(
+    store.createIfAbsent(record(), {
+      initialEvent: {
+        eventId: 'event-failing',
+        jobId: 'job-1',
+        timestamp: 1000,
+      },
+    }),
+    eventError,
+  );
+  assert.ok(calls.includes('BEGIN'));
+  assert.ok(calls.includes('ROLLBACK'));
+  assert.ok(!calls.includes('COMMIT'));
+});
+
+test('Executor Job persistence supports explicit non-durable memory mode', async () => {
+  const persistence = await createExecutorJobPersistence({ mode: 'memory' });
+  assert.equal(persistence.kind, 'memory');
+  assert.equal(persistence.durable, false);
+  assert.equal(persistence.store.durable, false);
+  assert.equal(persistence.store.kind, 'memory');
+  assert.equal(await persistence.probe(), true);
+  await persistence.close();
+});
+
+test('Executor Job persistence initializes and closes its PostgreSQL pool', async () => {
+  const queries = [];
+  let closed = false;
+  const pool = {
+    async query(sql) {
+      queries.push(sql);
+      return { rows: [] };
+    },
+    async end() {
+      closed = true;
+    },
+  };
+  const persistence = await createExecutorJobPersistence({
+    mode: 'postgres',
+    connectionString: 'postgresql://orchestrator:test@postgres/orchestrator',
+    schema: 'memind_orchestrator',
+    poolFactory(config) {
+      assert.equal(
+        config.connectionString,
+        'postgresql://orchestrator:test@postgres/orchestrator',
+      );
+      return pool;
+    },
+  });
+  assert.equal(persistence.kind, 'postgres');
+  assert.equal(persistence.durable, true);
+  assert.equal(persistence.store.kind, 'postgres');
+  assert.equal(await persistence.probe(), true);
+  assert.match(queries.at(-1), /SELECT 1 AS ok/);
+  await persistence.close();
+  assert.equal(closed, true);
+});
+
+test('Executor Job persistence rejects missing PostgreSQL config and unsafe schema names', async () => {
+  let poolCreated = false;
+  await assert.rejects(
+    createExecutorJobPersistence({ mode: 'postgres', connectionString: '' }),
+    (error) => error.code === 'ORCHESTRATOR_DATABASE_URL_REQUIRED',
+  );
+  await assert.rejects(
+    createExecutorJobPersistence({
+      mode: 'postgres',
+      connectionString: 'postgresql://orchestrator:test@postgres/orchestrator',
+      schema: 'public; drop schema public',
+      poolFactory() {
+        poolCreated = true;
+        return null;
+      },
+    }),
+    /Invalid Executor Gateway PostgreSQL schema/,
+  );
+  assert.equal(poolCreated, false);
+  assert.throws(
+    () => executorJobStoreInternals.normalizeSchema('public; drop schema public'),
+    /Invalid Executor Gateway PostgreSQL schema/,
+  );
+});
+
+test('Executor Job persistence closes its pool when schema initialization fails', async () => {
+  let closed = false;
+  const initializationError = new Error('schema unavailable');
+  await assert.rejects(
+    createExecutorJobPersistence({
+      mode: 'postgres',
+      connectionString: 'postgresql://orchestrator:test@postgres/orchestrator',
+      poolFactory() {
+        return {
+          async query() {
+            throw initializationError;
+          },
+          async end() {
+            closed = true;
+          },
+        };
+      },
+    }),
+    initializationError,
+  );
+  assert.equal(closed, true);
+});
diff --git a/services/orchestrator/executor-worker-protocol.mjs b/services/orchestrator/executor-worker-protocol.mjs
new file mode 100644
index 0000000..3011987
--- /dev/null
+++ b/services/orchestrator/executor-worker-protocol.mjs
@@ -0,0 +1,462 @@
+import crypto from 'node:crypto';
+import {
+  buildExecutorJobEvent,
+  executorGatewayInternals,
+} from './executor-gateway.mjs';
+
+const WORKER_PROTOCOL_VERSION = 'executor-worker-v1';
+const DEFAULT_LEASE_DURATION_MS = 30_000;
+const DEFAULT_MAX_ATTEMPTS = 3;
+const MAX_PROGRESS_DATA_BYTES = 16 * 1024;
+const ACTIVE_STATUSES = Object.freeze(['leased', 'running']);
+
+function clampInteger(value, fallback, min, max) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(number)));
+}
+
+function protocolError(code, message, status = 409, details = null) {
+  const error = new Error(message);
+  error.code = code;
+  error.status = status;
+  error.details = details;
+  return error;
+}
+
+function requiredIdentifier(value, name, max = 128) {
+  const normalized = String(value ?? '').trim();
+  if (!normalized || !/^[a-zA-Z0-9:_-]+$/.test(normalized) || normalized.length > max) {
+    throw protocolError(
+      `EXECUTOR_${name.toUpperCase()}_INVALID`,
+      `${name} must be a safe identifier no longer than ${max} characters`,
+      422,
+    );
+  }
+  return normalized;
+}
+
+function sanitizeData(value, maxBytes = MAX_PROGRESS_DATA_BYTES) {
+  if (value == null) return null;
+  const encoded = JSON.stringify(value);
+  if (Buffer.byteLength(encoded, 'utf8') > maxBytes) {
+    throw protocolError(
+      'EXECUTOR_EVENT_DATA_TOO_LARGE',
+      `Executor event data exceeds ${maxBytes} bytes`,
+      413,
+    );
+  }
+  return structuredClone(value);
+}
+
+function sanitizeError(error) {
+  const source = error && typeof error === 'object' ? error : {};
+  return {
+    code: String(source.code ?? 'EXECUTOR_FAILED').trim().slice(0, 128),
+    message: String(source.message ?? error ?? 'Executor failed').trim().slice(0, 2048),
+    retryable: source.retryable === true,
+  };
+}
+
+function sanitizeResult(result) {
+  const source = result && typeof result === 'object' ? result : {};
+  const artifactRefs = Array.isArray(source.artifactRefs)
+    ? source.artifactRefs
+      .map((reference) => {
+        const kind = String(reference?.kind ?? '').trim().slice(0, 64);
+        const id = String(reference?.id ?? '').trim().slice(0, 256);
+        return kind && id ? { kind, id } : null;
+      })
+      .filter(Boolean)
+      .slice(0, 100)
+    : [];
+  return {
+    outcome: String(source.outcome ?? 'completed').trim().slice(0, 128) || 'completed',
+    summary: String(source.summary ?? '').trim().slice(0, 4096) || null,
+    artifactRefs,
+    metrics: source.metrics && typeof source.metrics === 'object'
+      ? sanitizeData(source.metrics, 4096)
+      : {},
+  };
+}
+
+function requireWorkerStore(store) {
+  for (const method of [
+    'claimNext',
+    'transition',
+    'listExpiredLeases',
+    'getQueueStats',
+  ]) {
+    if (typeof store?.[method] !== 'function') {
+      throw new Error(`Executor Worker store missing method: ${method}`);
+    }
+  }
+}
+
+function requireApplied(result, action) {
+  if (result?.applied) return result.record;
+  const code = result?.reason === 'not_found'
+    ? 'EXECUTOR_JOB_NOT_FOUND'
+    : result?.reason === 'lease_mismatch'
+      ? 'EXECUTOR_LEASE_LOST'
+      : 'EXECUTOR_JOB_STATE_CONFLICT';
+  const status = result?.reason === 'not_found' ? 404 : 409;
+  throw protocolError(code, `Cannot ${action} executor job: ${result?.reason ?? 'conflict'}`, status, {
+    currentStatus: result?.record?.status ?? null,
+  });
+}
+
+export function createExecutorWorkerCoordinator({
+  store,
+  nowMs = Date.now,
+  randomUUID = crypto.randomUUID,
+  defaultLeaseDurationMs = DEFAULT_LEASE_DURATION_MS,
+  defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS,
+  workerStaleAfterMs = 60_000,
+} = {}) {
+  requireWorkerStore(store);
+
+  async function claim({
+    workerId,
+    executors,
+    leaseDurationMs = defaultLeaseDurationMs,
+    draining = false,
+    adapterHealth = {},
+  } = {}) {
+    const normalizedWorkerId = requiredIdentifier(workerId, 'worker_id');
+    const normalizedExecutors = [...new Set(
+      (Array.isArray(executors) ? executors : [executors])
+        .map((executor) => String(executor ?? '').trim().toLowerCase())
+        .filter(Boolean),
+    )].slice(0, 20);
+    if (!normalizedExecutors.length) {
+      throw protocolError(
+        'EXECUTOR_WORKER_EXECUTORS_REQUIRED',
+        'Worker claim requires at least one executor',
+        422,
+      );
+    }
+    const now = nowMs();
+    await store.recordWorkerHeartbeat?.({
+      version: WORKER_PROTOCOL_VERSION,
+      workerId: normalizedWorkerId,
+      executors: normalizedExecutors,
+      draining: draining === true,
+      adapterHealth: Object.fromEntries(
+        normalizedExecutors.map((executor) => [
+          executor,
+          {
+            ok: adapterHealth?.[executor]?.ok === true,
+            code: adapterHealth?.[executor]?.code == null
+              ? null
+              : String(adapterHealth[executor].code).slice(0, 128),
+          },
+        ]),
+      ),
+      lastSeenAt: now,
+    });
+    if (draining === true) return null;
+    const duration = clampInteger(leaseDurationMs, defaultLeaseDurationMs, 5_000, 5 * 60_000);
+    const leaseToken = randomUUID();
+    const claimed = await store.claimNext({
+      workerId: normalizedWorkerId,
+      executors: normalizedExecutors,
+      now,
+      leaseToken,
+      leaseDurationMs: duration,
+      eventFactory: (updated) => buildExecutorJobEvent({
+        jobId: updated.jobId,
+        type: 'executor_job_leased',
+        timestamp: now,
+        data: {
+          workerId: normalizedWorkerId,
+          executor: updated.executor,
+          attempt: updated.attempts,
+          leaseExpiresAt: updated.lease.expiresAt,
+        },
+      }),
+    });
+    return claimed
+      ? {
+          version: WORKER_PROTOCOL_VERSION,
+          job: claimed,
+          leaseToken,
+        }
+      : null;
+  }
+
+  async function start(jobId, { leaseToken } = {}) {
+    const normalizedJobId = requiredIdentifier(jobId, 'job_id');
+    const normalizedLeaseToken = requiredIdentifier(leaseToken, 'lease_token');
+    const now = nowMs();
+    const result = await store.transition(normalizedJobId, {
+      expectedStatuses: ['leased'],
+      leaseToken: normalizedLeaseToken,
+      updater(current) {
+        return {
+          ...current,
+          status: 'running',
+          startedAt: current.startedAt ?? now,
+          updatedAt: now,
+        };
+      },
+      eventFactory: (updated) => buildExecutorJobEvent({
+        jobId: updated.jobId,
+        type: 'executor_job_started',
+        timestamp: now,
+        data: {
+          workerId: updated.lease.workerId,
+          attempt: updated.attempts,
+        },
+      }),
+    });
+    return requireApplied(result, 'start');
+  }
+
+  async function heartbeat(jobId, {
+    leaseToken,
+    leaseDurationMs = defaultLeaseDurationMs,
+  } = {}) {
+    const normalizedJobId = requiredIdentifier(jobId, 'job_id');
+    const normalizedLeaseToken = requiredIdentifier(leaseToken, 'lease_token');
+    const now = nowMs();
+    const duration = clampInteger(leaseDurationMs, defaultLeaseDurationMs, 5_000, 5 * 60_000);
+    const result = await store.transition(normalizedJobId, {
+      expectedStatuses: [...ACTIVE_STATUSES],
+      leaseToken: normalizedLeaseToken,
+      updater(current) {
+        return {
+          ...current,
+          lease: {
+            ...current.lease,
+            heartbeatAt: now,
+            expiresAt: now + duration,
+          },
+          updatedAt: now,
+        };
+      },
+      eventFactory: (updated) => buildExecutorJobEvent({
+        jobId: updated.jobId,
+        type: 'executor_job_heartbeat',
+        timestamp: now,
+        data: {
+          workerId: updated.lease.workerId,
+          leaseExpiresAt: updated.lease.expiresAt,
+        },
+      }),
+    });
+    return requireApplied(result, 'heartbeat');
+  }
+
+  async function progress(jobId, {
+    leaseToken,
+    type = 'executor_job_progress',
+    data = null,
+  } = {}) {
+    const normalizedJobId = requiredIdentifier(jobId, 'job_id');
+    const normalizedLeaseToken = requiredIdentifier(leaseToken, 'lease_token');
+    const normalizedType = String(type ?? '').trim();
+    if (!/^executor_job_[a-z0-9_]{1,96}$/.test(normalizedType)) {
+      throw protocolError(
+        'EXECUTOR_PROGRESS_TYPE_INVALID',
+        'Progress event type must use the executor_job_ namespace',
+        422,
+      );
+    }
+    const safeData = sanitizeData(data);
+    const now = nowMs();
+    const result = await store.transition(normalizedJobId, {
+      expectedStatuses: [...ACTIVE_STATUSES],
+      leaseToken: normalizedLeaseToken,
+      updater(current) {
+        return { ...current, updatedAt: now };
+      },
+      eventFactory: (updated) => buildExecutorJobEvent({
+        jobId: updated.jobId,
+        type: normalizedType,
+        timestamp: now,
+        data: safeData,
+      }),
+    });
+    return requireApplied(result, 'append progress');
+  }
+
+  async function complete(jobId, { leaseToken, result: output = null } = {}) {
+    const normalizedJobId = requiredIdentifier(jobId, 'job_id');
+    const normalizedLeaseToken = requiredIdentifier(leaseToken, 'lease_token');
+    const safeResult = sanitizeResult(output);
+    const now = nowMs();
+    const transition = await store.transition(normalizedJobId, {
+      expectedStatuses: [...ACTIVE_STATUSES],
+      leaseToken: normalizedLeaseToken,
+      updater(current) {
+        return {
+          ...current,
+          status: 'succeeded',
+          reason: null,
+          result: safeResult,
+          lease: null,
+          updatedAt: now,
+          completedAt: now,
+        };
+      },
+      eventFactory: (updated) => buildExecutorJobEvent({
+        jobId: updated.jobId,
+        type: 'executor_job_succeeded',
+        timestamp: now,
+        data: safeResult,
+      }),
+    });
+    return requireApplied(transition, 'complete');
+  }
+
+  async function fail(jobId, {
+    leaseToken,
+    error,
+    retryDelayMs = 1_000,
+  } = {}) {
+    const normalizedJobId = requiredIdentifier(jobId, 'job_id');
+    const normalizedLeaseToken = requiredIdentifier(leaseToken, 'lease_token');
+    const safeError = sanitizeError(error);
+    const now = nowMs();
+    const transition = await store.transition(normalizedJobId, {
+      expectedStatuses: [...ACTIVE_STATUSES],
+      leaseToken: normalizedLeaseToken,
+      updater(current) {
+        const maxAttempts = clampInteger(
+          current.maxAttempts,
+          defaultMaxAttempts,
+          1,
+          20,
+        );
+        const retryable = safeError.retryable && Number(current.attempts ?? 0) < maxAttempts;
+        return {
+          ...current,
+          status: retryable ? 'retryable' : 'failed',
+          reason: safeError.code,
+          error: safeError,
+          lease: null,
+          nextAttemptAt: retryable
+            ? now + clampInteger(retryDelayMs, 1_000, 0, 60 * 60_000)
+            : null,
+          updatedAt: now,
+          completedAt: retryable ? null : now,
+        };
+      },
+      eventFactory: (updated) => buildExecutorJobEvent({
+        jobId: updated.jobId,
+        type: updated.status === 'retryable'
+          ? 'executor_job_retry_scheduled'
+          : 'executor_job_failed',
+        timestamp: now,
+        data: {
+          status: updated.status,
+          error: safeError,
+          nextAttemptAt: updated.nextAttemptAt,
+        },
+      }),
+    });
+    return requireApplied(transition, 'fail');
+  }
+
+  async function recoverExpired({ limit = 100 } = {}) {
+    const now = nowMs();
+    const expired = await store.listExpiredLeases({
+      now,
+      limit: clampInteger(limit, 100, 1, 500),
+    });
+    const recovered = [];
+    for (const candidate of expired) {
+      const leaseToken = candidate.lease?.token;
+      if (!leaseToken) continue;
+      const transition = await store.transition(candidate.jobId, {
+        expectedStatuses: [...ACTIVE_STATUSES],
+        leaseToken,
+        updater(current) {
+          const maxAttempts = clampInteger(
+            current.maxAttempts,
+            defaultMaxAttempts,
+            1,
+            20,
+          );
+          const retryable = Number(current.attempts ?? 0) < maxAttempts;
+          return {
+            ...current,
+            status: retryable ? 'retryable' : 'timed_out',
+            reason: 'executor_lease_expired',
+            error: {
+              code: 'EXECUTOR_LEASE_EXPIRED',
+              message: 'Worker lease expired before completion',
+              retryable,
+            },
+            lease: null,
+            nextAttemptAt: retryable ? now : null,
+            updatedAt: now,
+            completedAt: retryable ? null : now,
+          };
+        },
+        eventFactory: (updated) => buildExecutorJobEvent({
+          jobId: updated.jobId,
+          type: updated.status === 'retryable'
+            ? 'executor_job_lease_recovered'
+            : 'executor_job_timed_out',
+          timestamp: now,
+          data: {
+            previousWorkerId: candidate.lease?.workerId ?? null,
+            status: updated.status,
+            attempt: updated.attempts,
+          },
+        }),
+      });
+      if (transition.applied) recovered.push(transition.record);
+    }
+    return {
+      version: WORKER_PROTOCOL_VERSION,
+      inspected: expired.length,
+      recovered,
+    };
+  }
+
+  async function stats() {
+    const now = nowMs();
+    const workers = typeof store.listWorkers === 'function'
+      ? await store.listWorkers({ now, staleAfterMs: workerStaleAfterMs })
+      : [];
+    return {
+      version: WORKER_PROTOCOL_VERSION,
+      ...(await store.getQueueStats({ now })),
+      workers,
+      healthyWorkers: workers.filter((worker) => (
+        !worker.stale
+        && !worker.draining
+        && Object.values(worker.adapterHealth ?? {}).some((health) => health?.ok === true)
+      )).length,
+    };
+  }
+
+  return {
+    claim,
+    start,
+    heartbeat,
+    progress,
+    complete,
+    fail,
+    recoverExpired,
+    stats,
+  };
+}
+
+export const executorWorkerProtocolInternals = {
+  ACTIVE_STATUSES,
+  DEFAULT_LEASE_DURATION_MS,
+  DEFAULT_MAX_ATTEMPTS,
+  MAX_PROGRESS_DATA_BYTES,
+  WORKER_PROTOCOL_VERSION,
+  clampInteger,
+  protocolError,
+  requiredIdentifier,
+  sanitizeData,
+  sanitizeError,
+  sanitizeResult,
+  terminalStatuses: executorGatewayInternals.TERMINAL_JOB_STATUSES,
+};
diff --git a/services/orchestrator/executor-worker-protocol.test.mjs b/services/orchestrator/executor-worker-protocol.test.mjs
new file mode 100644
index 0000000..d4ba3a2
--- /dev/null
+++ b/services/orchestrator/executor-worker-protocol.test.mjs
@@ -0,0 +1,181 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createInMemoryExecutorJobStore } from './executor-gateway.mjs';
+import { createExecutorWorkerCoordinator } from './executor-worker-protocol.mjs';
+
+function queuedJob(overrides = {}) {
+  return {
+    version: 'executor-job-state-v1',
+    jobId: 'job-1',
+    idempotencyKey: 'idem-1',
+    requestFingerprint: 'a'.repeat(64),
+    executor: 'goosed',
+    status: 'queued',
+    attempts: 0,
+    maxAttempts: 2,
+    createdAt: 1000,
+    updatedAt: 1000,
+    completedAt: null,
+    ...overrides,
+  };
+}
+
+async function seed(store, job = queuedJob()) {
+  await store.createIfAbsent(job);
+}
+
+test('worker claims, starts, heartbeats and completes a queued job with lease fencing', async () => {
+  let now = 1000;
+  let token = 0;
+  const store = createInMemoryExecutorJobStore();
+  await seed(store);
+  const coordinator = createExecutorWorkerCoordinator({
+    store,
+    nowMs: () => now,
+    randomUUID: () => `lease-${++token}`,
+  });
+
+  const claimed = await coordinator.claim({
+    workerId: 'worker-1',
+    executors: ['goosed'],
+    leaseDurationMs: 5000,
+  });
+  assert.equal(claimed.version, 'executor-worker-v1');
+  assert.equal(claimed.leaseToken, 'lease-1');
+  assert.equal(claimed.job.status, 'leased');
+  assert.equal(claimed.job.attempts, 1);
+  assert.equal(await coordinator.claim({
+    workerId: 'worker-2',
+    executors: ['goosed'],
+  }), null);
+
+  await assert.rejects(
+    coordinator.start('job-1', { leaseToken: 'wrong-token' }),
+    (error) => error.code === 'EXECUTOR_LEASE_LOST',
+  );
+  const started = await coordinator.start('job-1', { leaseToken: 'lease-1' });
+  assert.equal(started.status, 'running');
+  assert.equal(started.startedAt, 1000);
+
+  now = 3000;
+  const heartbeat = await coordinator.heartbeat('job-1', {
+    leaseToken: 'lease-1',
+    leaseDurationMs: 5000,
+  });
+  assert.equal(heartbeat.lease.heartbeatAt, 3000);
+  assert.equal(heartbeat.lease.expiresAt, 8000);
+
+  await coordinator.progress('job-1', {
+    leaseToken: 'lease-1',
+    type: 'executor_job_output_chunk',
+    data: { characters: 12 },
+  });
+  now = 4000;
+  const completed = await coordinator.complete('job-1', {
+    leaseToken: 'lease-1',
+    result: {
+      summary: 'done',
+      artifactRefs: [{ kind: 'patch', id: 'artifact-1' }],
+    },
+  });
+  assert.equal(completed.status, 'succeeded');
+  assert.equal(completed.lease, null);
+  assert.deepEqual(completed.result.artifactRefs, [{ kind: 'patch', id: 'artifact-1' }]);
+  assert.deepEqual(
+    (await store.listEvents('job-1')).map((event) => event.type),
+    [
+      'executor_job_leased',
+      'executor_job_started',
+      'executor_job_heartbeat',
+      'executor_job_output_chunk',
+      'executor_job_succeeded',
+    ],
+  );
+});
+
+test('retryable failure is delayed and a later terminal failure consumes max attempts', async () => {
+  let now = 1000;
+  let token = 0;
+  const store = createInMemoryExecutorJobStore();
+  await seed(store);
+  const coordinator = createExecutorWorkerCoordinator({
+    store,
+    nowMs: () => now,
+    randomUUID: () => `lease-${++token}`,
+  });
+
+  const first = await coordinator.claim({ workerId: 'worker-1', executors: ['goosed'] });
+  await coordinator.start('job-1', { leaseToken: first.leaseToken });
+  const retryable = await coordinator.fail('job-1', {
+    leaseToken: first.leaseToken,
+    error: { code: 'UPSTREAM_BUSY', message: 'busy', retryable: true },
+    retryDelayMs: 5000,
+  });
+  assert.equal(retryable.status, 'retryable');
+  assert.equal(retryable.nextAttemptAt, 6000);
+  assert.equal(await coordinator.claim({
+    workerId: 'worker-2',
+    executors: ['goosed'],
+  }), null);
+
+  now = 6000;
+  const second = await coordinator.claim({ workerId: 'worker-2', executors: ['goosed'] });
+  assert.equal(second.job.attempts, 2);
+  await coordinator.start('job-1', { leaseToken: second.leaseToken });
+  const failed = await coordinator.fail('job-1', {
+    leaseToken: second.leaseToken,
+    error: { code: 'UPSTREAM_BUSY', message: 'still busy', retryable: true },
+  });
+  assert.equal(failed.status, 'failed');
+  assert.equal(failed.completedAt, 6000);
+});
+
+test('expired leases are recovered with fencing and eventually time out', async () => {
+  let now = 1000;
+  let token = 0;
+  const store = createInMemoryExecutorJobStore();
+  await seed(store, queuedJob({ maxAttempts: 1 }));
+  const coordinator = createExecutorWorkerCoordinator({
+    store,
+    nowMs: () => now,
+    randomUUID: () => `lease-${++token}`,
+  });
+  const claimed = await coordinator.claim({
+    workerId: 'worker-crashed',
+    executors: ['goosed'],
+    leaseDurationMs: 5000,
+  });
+  await coordinator.start('job-1', { leaseToken: claimed.leaseToken });
+  now = 6001;
+  const recovery = await coordinator.recoverExpired();
+  assert.equal(recovery.inspected, 1);
+  assert.equal(recovery.recovered[0].status, 'timed_out');
+  await assert.rejects(
+    coordinator.heartbeat('job-1', { leaseToken: claimed.leaseToken }),
+    (error) => error.code === 'EXECUTOR_JOB_STATE_CONFLICT',
+  );
+  const stats = await coordinator.stats();
+  assert.equal(stats.counts.timed_out, 1);
+  assert.equal(stats.expiredLeases, 0);
+});
+
+test('worker protocol bounds identifiers and progress payloads', async () => {
+  const store = createInMemoryExecutorJobStore();
+  await seed(store);
+  const coordinator = createExecutorWorkerCoordinator({
+    store,
+    randomUUID: () => 'lease-1',
+  });
+  await assert.rejects(
+    coordinator.claim({ workerId: '../worker', executors: ['goosed'] }),
+    (error) => error.code === 'EXECUTOR_WORKER_ID_INVALID',
+  );
+  const claimed = await coordinator.claim({ workerId: 'worker-1', executors: ['goosed'] });
+  await assert.rejects(
+    coordinator.progress('job-1', {
+      leaseToken: claimed.leaseToken,
+      data: { output: 'x'.repeat(20_000) },
+    }),
+    (error) => error.code === 'EXECUTOR_EVENT_DATA_TOO_LARGE',
+  );
+});
diff --git a/services/orchestrator/executor-worker-runtime.mjs b/services/orchestrator/executor-worker-runtime.mjs
new file mode 100644
index 0000000..e4d38ea
--- /dev/null
+++ b/services/orchestrator/executor-worker-runtime.mjs
@@ -0,0 +1,304 @@
+function workerError(code, message, options = {}) {
+  const error = new Error(message);
+  error.code = code;
+  error.retryable = options.retryable === true;
+  return error;
+}
+
+function safeJson(response) {
+  return response.json().catch(() => null);
+}
+
+export function createExecutorWorkerClient({
+  baseUrl,
+  serviceToken = '',
+  workerToken = '',
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  const target = String(baseUrl ?? '').trim().replace(/\/$/, '');
+  if (!target) throw new Error('Executor worker client requires baseUrl');
+  if (typeof fetchImpl !== 'function') throw new Error('Executor worker client requires fetch');
+
+  async function request(path, { method = 'GET', body = null } = {}) {
+    const response = await fetchImpl(`${target}${path}`, {
+      method,
+      headers: {
+        accept: 'application/json',
+        ...(body == null ? {} : { 'content-type': 'application/json' }),
+        ...(serviceToken ? { authorization: `Bearer ${serviceToken}` } : {}),
+        ...(workerToken ? { 'x-orchestrator-worker-token': workerToken } : {}),
+      },
+      ...(body == null ? {} : { body: JSON.stringify(body) }),
+    });
+    if (response.status === 204) return null;
+    const payload = await safeJson(response);
+    if (!response.ok) {
+      const error = workerError(
+        payload?.error?.code ?? 'EXECUTOR_WORKER_HTTP_ERROR',
+        payload?.error?.message ?? `Executor worker request failed (${response.status})`,
+        { retryable: response.status >= 500 || response.status === 429 },
+      );
+      error.status = response.status;
+      throw error;
+    }
+    return payload;
+  }
+
+  return {
+    claim(input) {
+      return request('/v1/workers/claim', { method: 'POST', body: input });
+    },
+    start(jobId, input) {
+      return request(`/v1/workers/jobs/${encodeURIComponent(jobId)}/start`, {
+        method: 'POST',
+        body: input,
+      });
+    },
+    heartbeat(jobId, input) {
+      return request(`/v1/workers/jobs/${encodeURIComponent(jobId)}/heartbeat`, {
+        method: 'POST',
+        body: input,
+      });
+    },
+    progress(jobId, input) {
+      return request(`/v1/workers/jobs/${encodeURIComponent(jobId)}/progress`, {
+        method: 'POST',
+        body: input,
+      });
+    },
+    complete(jobId, input) {
+      return request(`/v1/workers/jobs/${encodeURIComponent(jobId)}/complete`, {
+        method: 'POST',
+        body: input,
+      });
+    },
+    fail(jobId, input) {
+      return request(`/v1/workers/jobs/${encodeURIComponent(jobId)}/fail`, {
+        method: 'POST',
+        body: input,
+      });
+    },
+    recoverExpired(input = {}) {
+      return request('/v1/workers/recover-expired', { method: 'POST', body: input });
+    },
+    stats() {
+      return request('/v1/workers/stats');
+    },
+  };
+}
+
+export function createWorkerAdapterRegistry(initialAdapters = []) {
+  const adapters = new Map();
+  return {
+    register(adapter) {
+      const id = String(adapter?.id ?? '').trim().toLowerCase();
+      if (!id || typeof adapter?.submit !== 'function') {
+        throw new Error('Worker adapter requires id and submit');
+      }
+      if (adapters.has(id)) throw new Error(`Worker adapter already registered: ${id}`);
+      adapters.set(id, adapter);
+      return adapter;
+    },
+    get(id) {
+      return adapters.get(String(id ?? '').trim().toLowerCase()) ?? null;
+    },
+    list() {
+      return [...adapters.values()].map((adapter) => ({
+        id: adapter.id,
+        kind: adapter.kind ?? 'worker',
+        capabilities: [...(adapter.capabilities ?? [])],
+      }));
+    },
+    ids() {
+      return [...adapters.keys()];
+    },
+    async health() {
+      const result = {};
+      for (const [id, adapter] of adapters) {
+        try {
+          result[id] = typeof adapter.health === 'function'
+            ? await adapter.health()
+            : { ok: true };
+        } catch (error) {
+          result[id] = {
+            ok: false,
+            code: String(error?.code ?? 'EXECUTOR_ADAPTER_HEALTH_FAILED').slice(0, 128),
+          };
+        }
+      }
+      return result;
+    },
+    _initialize() {
+      for (const adapter of initialAdapters) this.register(adapter);
+      return this;
+    },
+  }._initialize();
+}
+
+export function createExecutorWorkerRuntime({
+  client,
+  registry = createWorkerAdapterRegistry(),
+  workerId,
+  heartbeatMs = 10_000,
+  leaseDurationMs = 30_000,
+  logger = console,
+} = {}) {
+  const normalizedWorkerId = String(workerId ?? '').trim();
+  if (!normalizedWorkerId) throw new Error('Executor worker runtime requires workerId');
+  if (!client?.claim) throw new Error('Executor worker runtime requires client');
+  let stopping = false;
+  const active = new Map();
+  let lastAdapterHealth = {};
+
+  async function executeAdapter(adapter, job, leaseToken, controller) {
+    return adapter.submit(job.request, {
+      jobId: job.jobId,
+      signal: controller.signal,
+      emit(type, data) {
+        return client.progress(job.jobId, { leaseToken, type, data });
+      },
+    });
+  }
+
+  async function processClaim(claim) {
+    const job = claim.job;
+    const leaseToken = claim.leaseToken;
+    const controller = new AbortController();
+    active.set(job.jobId, { controller, leaseToken });
+    const timeoutMs = Math.max(500, Number(job.timeoutMs ?? job.request?.controls?.timeoutMs) || 900_000);
+    const timeout = setTimeout(() => controller.abort('executor_timeout'), timeoutMs);
+    let heartbeatFailure = null;
+    const heartbeat = setInterval(() => {
+      void client.heartbeat(job.jobId, { leaseToken, leaseDurationMs }).catch((error) => {
+        heartbeatFailure = error;
+        controller.abort('heartbeat_failed');
+      });
+    }, Math.max(1_000, Math.min(heartbeatMs, Math.floor(leaseDurationMs / 2))));
+    heartbeat.unref?.();
+    try {
+      await client.start(job.jobId, { leaseToken });
+      if (!job.request) {
+        throw workerError(
+          'EXECUTOR_JOB_REQUEST_MISSING',
+          'Claimed executor job does not contain an execution request',
+        );
+      }
+      const primary = registry.get(job.executor);
+      if (!primary) {
+        throw workerError(
+          'EXECUTOR_ADAPTER_NOT_INSTALLED',
+          `Worker does not have adapter ${job.executor}`,
+        );
+      }
+      let result;
+      try {
+        result = await executeAdapter(primary, job, leaseToken, controller);
+      } catch (primaryError) {
+        const fallbackId = String(job.fallbackExecutor ?? '').trim();
+        const fallback = job.fallbackAvailable ? registry.get(fallbackId) : null;
+        if (!fallback || controller.signal.aborted) throw primaryError;
+        await client.progress(job.jobId, {
+          leaseToken,
+          type: 'executor_job_fallback_started',
+          data: {
+            from: job.executor,
+            to: fallbackId,
+            reason: String(primaryError?.code ?? 'EXECUTOR_PRIMARY_FAILED').slice(0, 128),
+          },
+        });
+        result = await executeAdapter(fallback, {
+          ...job,
+          executor: fallbackId,
+          request: { ...job.request, executor: fallbackId },
+        }, leaseToken, controller);
+      }
+      if (heartbeatFailure) throw heartbeatFailure;
+      await client.complete(job.jobId, { leaseToken, result });
+      return { processed: true, jobId: job.jobId, status: 'succeeded' };
+    } catch (error) {
+      const failure = controller.signal.aborted && !heartbeatFailure
+        ? {
+            code: 'EXECUTOR_TIMEOUT_OR_CANCELLED',
+            message: 'Executor was cancelled or exceeded its timeout',
+            retryable: false,
+          }
+        : {
+            code: String(error?.code ?? 'EXECUTOR_WORKER_FAILED').slice(0, 128),
+            message: String(error?.message ?? error ?? 'Executor worker failed').slice(0, 2048),
+            retryable: error?.retryable === true,
+          };
+      try {
+        await client.fail(job.jobId, {
+          leaseToken,
+          error: failure,
+          retryDelayMs: failure.retryable ? 2_000 : 0,
+        });
+      } catch (reportError) {
+        logger.error?.(
+          `[executor-worker] failed to report ${job.jobId}: ${reportError.message}`,
+        );
+        throw reportError;
+      }
+      return { processed: true, jobId: job.jobId, status: 'failed', error: failure };
+    } finally {
+      clearTimeout(timeout);
+      clearInterval(heartbeat);
+      active.delete(job.jobId);
+    }
+  }
+
+  return {
+    async runOnce() {
+      if (stopping) return { processed: false, reason: 'stopping' };
+      lastAdapterHealth = await registry.health();
+      const healthyExecutors = registry.ids().filter(
+        (executor) => lastAdapterHealth[executor]?.ok === true,
+      );
+      const claim = await client.claim({
+        workerId: normalizedWorkerId,
+        executors: healthyExecutors.length ? healthyExecutors : registry.ids(),
+        leaseDurationMs,
+        draining: healthyExecutors.length === 0,
+        adapterHealth: lastAdapterHealth,
+      });
+      if (!claim) {
+        return {
+          processed: false,
+          reason: healthyExecutors.length ? 'queue_empty' : 'adapters_unhealthy',
+        };
+      }
+      return processClaim(claim);
+    },
+    async recoverExpired(options = {}) {
+      return client.recoverExpired(options);
+    },
+    status() {
+      return {
+        version: 'executor-worker-runtime-v1',
+        workerId: normalizedWorkerId,
+        stopping,
+        activeJobs: [...active.keys()],
+        adapters: registry.list(),
+        adapterHealth: lastAdapterHealth,
+        heartbeatMs,
+        leaseDurationMs,
+      };
+    },
+    async stop() {
+      stopping = true;
+      await client.claim({
+        workerId: normalizedWorkerId,
+        executors: registry.ids(),
+        leaseDurationMs,
+        draining: true,
+        adapterHealth: lastAdapterHealth,
+      }).catch(() => null);
+      for (const { controller } of active.values()) controller.abort('worker_stopping');
+    },
+  };
+}
+
+export const executorWorkerRuntimeInternals = {
+  safeJson,
+  workerError,
+};
diff --git a/services/orchestrator/executor-worker-runtime.test.mjs b/services/orchestrator/executor-worker-runtime.test.mjs
new file mode 100644
index 0000000..be399af
--- /dev/null
+++ b/services/orchestrator/executor-worker-runtime.test.mjs
@@ -0,0 +1,143 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  createExecutorWorkerRuntime,
+  createWorkerAdapterRegistry,
+} from './executor-worker-runtime.mjs';
+
+function claim(overrides = {}) {
+  return {
+    leaseToken: 'lease-1',
+    job: {
+      jobId: 'job-1',
+      executor: 'goosed',
+      fallbackExecutor: 'aider',
+      fallbackAvailable: true,
+      timeoutMs: 30_000,
+      request: {
+        executor: 'goosed',
+        task: {
+          instruction: 'do it',
+          workspaceRef: { kind: 'workspace-alias', id: 'canary' },
+        },
+      },
+      ...overrides,
+    },
+  };
+}
+
+function fakeClient(nextClaim = claim()) {
+  const calls = [];
+  let claimed = false;
+  return {
+    calls,
+    async claim(input) {
+      calls.push(['claim', input]);
+      if (claimed) return null;
+      claimed = true;
+      return nextClaim;
+    },
+    async start(jobId, input) {
+      calls.push(['start', jobId, input]);
+    },
+    async heartbeat(jobId, input) {
+      calls.push(['heartbeat', jobId, input]);
+    },
+    async progress(jobId, input) {
+      calls.push(['progress', jobId, input]);
+    },
+    async complete(jobId, input) {
+      calls.push(['complete', jobId, input]);
+    },
+    async fail(jobId, input) {
+      calls.push(['fail', jobId, input]);
+    },
+    async recoverExpired(input) {
+      calls.push(['recover', input]);
+      return { recovered: [] };
+    },
+  };
+}
+
+function adapter(id, submit) {
+  return { id, capabilities: [], submit };
+}
+
+test('worker runtime claims, executes, emits progress and completes through lease protocol', async () => {
+  const client = fakeClient();
+  const registry = createWorkerAdapterRegistry([
+    adapter('goosed', async (_request, { emit }) => {
+      await emit('executor_job_adapter_event', { eventType: 'finish' });
+      return {
+        outcome: 'completed',
+        artifactRefs: [{ kind: 'goosed-session', id: 'session-1' }],
+      };
+    }),
+  ]);
+  const worker = createExecutorWorkerRuntime({
+    client,
+    registry,
+    workerId: 'worker-1',
+  });
+  const result = await worker.runOnce();
+  assert.equal(result.status, 'succeeded');
+  assert.deepEqual(
+    client.calls.map((call) => call[0]),
+    ['claim', 'start', 'progress', 'complete'],
+  );
+  assert.equal(client.calls.at(-1)[2].leaseToken, 'lease-1');
+  assert.deepEqual(worker.status().activeJobs, []);
+});
+
+test('worker runtime falls back to an installed adapter and records the transition', async () => {
+  const client = fakeClient();
+  const registry = createWorkerAdapterRegistry([
+    adapter('goosed', async () => {
+      const error = new Error('primary failed');
+      error.code = 'PRIMARY_FAILED';
+      throw error;
+    }),
+    adapter('aider', async (request) => ({
+      outcome: 'completed',
+      summary: request.executor,
+      artifactRefs: [{ kind: 'patch', id: 'patch-1' }],
+    })),
+  ]);
+  const worker = createExecutorWorkerRuntime({
+    client,
+    registry,
+    workerId: 'worker-1',
+  });
+  const result = await worker.runOnce();
+  assert.equal(result.status, 'succeeded');
+  const fallback = client.calls.find(
+    (call) => call[0] === 'progress' && call[2].type === 'executor_job_fallback_started',
+  );
+  assert.deepEqual(fallback[2].data, {
+    from: 'goosed',
+    to: 'aider',
+    reason: 'PRIMARY_FAILED',
+  });
+  assert.equal(client.calls.at(-1)[0], 'complete');
+});
+
+test('worker runtime reports bounded adapter failures without completing the job', async () => {
+  const client = fakeClient(claim({ fallbackAvailable: false }));
+  const registry = createWorkerAdapterRegistry([
+    adapter('goosed', async () => {
+      const error = new Error('upstream unavailable');
+      error.code = 'UPSTREAM_UNAVAILABLE';
+      error.retryable = true;
+      throw error;
+    }),
+  ]);
+  const worker = createExecutorWorkerRuntime({
+    client,
+    registry,
+    workerId: 'worker-1',
+  });
+  const result = await worker.runOnce();
+  assert.equal(result.status, 'failed');
+  assert.equal(client.calls.at(-1)[0], 'fail');
+  assert.equal(client.calls.at(-1)[2].error.retryable, true);
+});
diff --git a/services/orchestrator/observability.mjs b/services/orchestrator/observability.mjs
new file mode 100644
index 0000000..5ea5477
--- /dev/null
+++ b/services/orchestrator/observability.mjs
@@ -0,0 +1,636 @@
+import { createRemoteWorkflowEngine } from './engine-registry.mjs';
+import { WORKFLOW_ENGINE } from './contracts.mjs';
+
+const SHADOW_EVENT_TYPES = Object.freeze([
+  'workflow_shadow_completed',
+  'workflow_shadow_failed',
+]);
+const EXECUTION_PLAN_EVENT_TYPE = 'workflow_execution_planned';
+const MAX_METRIC_EVENTS = 5000;
+const CANARY_READINESS_THRESHOLDS = Object.freeze({
+  hours: 24 * 7,
+  minObservations: 20,
+  minSuccessRate: 0.95,
+  maxP95LatencyMs: 2000,
+  minLatencyCoverageRate: 0.95,
+  minNativeSettledRate: 0.95,
+  minDistinctSessions: 5,
+  maxHoursSinceLastObservation: 24,
+});
+const NATIVE_TERMINAL_STATUSES = new Set(['succeeded', 'failed']);
+const SYNTHETIC_TASK_TYPES = new Set(['orchestrator_shadow_smoke']);
+
+function clampInteger(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(parsed)));
+}
+
+function parseJsonColumn(value, fallback = null) {
+  if (value == null || value === '') return fallback;
+  if (typeof value === 'object') return value;
+  try {
+    return JSON.parse(String(value));
+  } catch {
+    return fallback;
+  }
+}
+
+function percentile(values, ratio) {
+  if (!values.length) return null;
+  const sorted = [...values].sort((left, right) => left - right);
+  const index = Math.max(0, Math.ceil(sorted.length * ratio) - 1);
+  return sorted[index];
+}
+
+function normalizeRunId(value) {
+  const runId = String(value ?? '').trim();
+  return /^[a-zA-Z0-9_-]{1,128}$/.test(runId) ? runId : '';
+}
+
+function normalizeExecutorJobId(value) {
+  const jobId = String(value ?? '').trim();
+  return /^[a-zA-Z0-9:_-]{1,128}$/.test(jobId) ? jobId : '';
+}
+
+function projectShadowEventRow(row) {
+  const data = parseJsonColumn(row.data_json, {}) ?? {};
+  const succeeded = row.event_type === 'workflow_shadow_completed';
+  const latency = Number(data.latencyMs);
+  const taskType = data.taskType ?? null;
+  return {
+    eventId: row.event_id,
+    runId: row.run_id,
+    requestId: row.request_id,
+    userId: row.user_id,
+    sessionId: row.agent_session_id ?? null,
+    nativeStatus: row.native_status,
+    nativeAttempts: Number(row.native_attempts ?? 0),
+    shadowStatus: succeeded ? 'succeeded' : 'failed',
+    engine: data.engine ?? 'langgraph',
+    configVersion: data.configVersion == null ? null : Number(data.configVersion),
+    phase: data.phase ?? null,
+    taskType,
+    synthetic: data.synthetic === true || SYNTHETIC_TASK_TYPES.has(String(taskType ?? '')),
+    executorAdapter: data.executorAdapter ?? null,
+    latencyMs: Number.isFinite(latency) && latency >= 0 ? latency : null,
+    error: succeeded ? null : {
+      code: data.code ?? 'WORKFLOW_SHADOW_FAILED',
+      message: data.message ?? 'Shadow observation failed',
+    },
+    observedAt: Number(row.event_created_at ?? 0),
+    nativeCompletedAt: row.native_completed_at == null
+      ? null
+      : Number(row.native_completed_at),
+  };
+}
+
+function projectUniqueShadowRuns(rows) {
+  const seen = new Set();
+  const runs = [];
+  for (const row of rows) {
+    const run = projectShadowEventRow(row);
+    if (seen.has(run.runId)) continue;
+    seen.add(run.runId);
+    runs.push(run);
+  }
+  return runs;
+}
+
+function projectExecutionPlanEventRow(row) {
+  const data = parseJsonColumn(row.data_json, {}) ?? {};
+  const bucket = Number(data.bucket);
+  return {
+    eventId: row.event_id,
+    runId: row.run_id,
+    requestId: row.request_id,
+    userId: row.user_id,
+    sessionId: row.agent_session_id ?? null,
+    nativeStatus: row.native_status,
+    nativeAttempts: Number(row.native_attempts ?? 0),
+    mode: data.mode ?? null,
+    candidateEngine: data.candidateEngine ?? 'native',
+    effectiveEngine: data.effectiveEngine ?? 'native',
+    fallbackEngine: data.fallbackEngine ?? 'native',
+    reason: data.reason ?? null,
+    candidateReason: data.candidateReason ?? null,
+    configVersion: data.configVersion == null ? null : Number(data.configVersion),
+    bucket: Number.isFinite(bucket) ? bucket : null,
+    taskType: data.taskType ?? null,
+    dryRun: data.dryRun === true,
+    handoffAllowed: data.handoffAllowed === true,
+    plannedAt: Number(row.event_created_at ?? 0),
+    nativeCompletedAt: row.native_completed_at == null
+      ? null
+      : Number(row.native_completed_at),
+  };
+}
+
+function projectUniqueExecutionPlans(rows) {
+  const seen = new Set();
+  const plans = [];
+  for (const row of rows) {
+    const plan = projectExecutionPlanEventRow(row);
+    if (seen.has(plan.runId)) continue;
+    seen.add(plan.runId);
+    plans.push(plan);
+  }
+  return plans;
+}
+
+function ratio(numerator, denominator) {
+  return denominator > 0 ? numerator / denominator : null;
+}
+
+function buildCanaryReadiness(loaded, runtimeState, now) {
+  const thresholds = CANARY_READINESS_THRESHOLDS;
+  const eligibleRuns = loaded.runs.filter((run) => !run.synthetic);
+  const successes = eligibleRuns.filter((run) => run.shadowStatus === 'succeeded').length;
+  const latencies = eligibleRuns
+    .map((run) => run.latencyMs)
+    .filter((value) => Number.isFinite(value));
+  const nativeSettled = eligibleRuns.filter((run) =>
+    NATIVE_TERMINAL_STATUSES.has(run.nativeStatus)).length;
+  const distinctSessions = new Set(
+    eligibleRuns.map((run) => run.sessionId).filter(Boolean),
+  ).size;
+  const lastObservedAt = eligibleRuns[0]?.observedAt ?? null;
+  const hoursSinceLastObservation = lastObservedAt == null
+    ? null
+    : Math.max(0, (now - lastObservedAt) / (60 * 60 * 1000));
+  const successRate = ratio(successes, eligibleRuns.length);
+  const latencyCoverageRate = ratio(latencies.length, eligibleRuns.length);
+  const nativeSettledRate = ratio(nativeSettled, eligibleRuns.length);
+  const latencyP95Ms = percentile(latencies, 0.95);
+  const serviceHealth = runtimeState?.serviceHealth ?? null;
+  const checkpoint = serviceHealth?.details?.checkpoint ?? null;
+  const executorStore = serviceHealth?.details?.executorGateway?.store ?? null;
+
+  const checks = [
+    {
+      id: 'shadow_mode',
+      passed: runtimeState?.config?.mode === 'shadow',
+      actual: runtimeState?.config?.mode ?? null,
+      target: 'shadow',
+    },
+    {
+      id: 'service_healthy',
+      passed: serviceHealth?.ok === true,
+      actual: serviceHealth?.status ?? null,
+      target: 'healthy',
+    },
+    {
+      id: 'durable_checkpoint',
+      passed: checkpoint?.durable === true,
+      actual: checkpoint?.durable ?? null,
+      target: true,
+    },
+    {
+      id: 'durable_executor_job_store',
+      passed: executorStore?.durable === true,
+      actual: executorStore?.durable ?? null,
+      target: true,
+    },
+    {
+      id: 'observe_only',
+      passed: serviceHealth?.details?.execution === 'observe-only',
+      actual: serviceHealth?.details?.execution ?? null,
+      target: 'observe-only',
+    },
+    {
+      id: 'sample_volume',
+      passed: eligibleRuns.length >= thresholds.minObservations,
+      actual: eligibleRuns.length,
+      target: thresholds.minObservations,
+    },
+    {
+      id: 'shadow_success_rate',
+      passed: successRate != null && successRate >= thresholds.minSuccessRate,
+      actual: successRate,
+      target: thresholds.minSuccessRate,
+    },
+    {
+      id: 'latency_coverage',
+      passed: latencyCoverageRate != null
+        && latencyCoverageRate >= thresholds.minLatencyCoverageRate,
+      actual: latencyCoverageRate,
+      target: thresholds.minLatencyCoverageRate,
+    },
+    {
+      id: 'latency_p95',
+      passed: latencyP95Ms != null && latencyP95Ms <= thresholds.maxP95LatencyMs,
+      actual: latencyP95Ms,
+      target: thresholds.maxP95LatencyMs,
+    },
+    {
+      id: 'native_settled_rate',
+      passed: nativeSettledRate != null
+        && nativeSettledRate >= thresholds.minNativeSettledRate,
+      actual: nativeSettledRate,
+      target: thresholds.minNativeSettledRate,
+    },
+    {
+      id: 'session_coverage',
+      passed: distinctSessions >= thresholds.minDistinctSessions,
+      actual: distinctSessions,
+      target: thresholds.minDistinctSessions,
+    },
+    {
+      id: 'sample_freshness',
+      passed: hoursSinceLastObservation != null
+        && hoursSinceLastObservation <= thresholds.maxHoursSinceLastObservation,
+      actual: hoursSinceLastObservation,
+      target: thresholds.maxHoursSinceLastObservation,
+    },
+    {
+      id: 'complete_window',
+      passed: !loaded.capped,
+      actual: loaded.capped ? 'sampled' : 'complete',
+      target: 'complete',
+    },
+  ];
+  const failureCounts = new Map();
+  for (const run of eligibleRuns) {
+    if (!run.error?.code) continue;
+    failureCounts.set(run.error.code, (failureCounts.get(run.error.code) ?? 0) + 1);
+  }
+
+  return {
+    generatedAt: now,
+    ready: checks.every((check) => check.passed),
+    recommendation: checks.every((check) => check.passed)
+      ? 'manual_canary_review'
+      : 'keep_shadow',
+    window: {
+      hours: loaded.hours,
+      from: loaded.from,
+    },
+    thresholds,
+    samples: {
+      totalObservations: loaded.runs.length,
+      eligibleObservations: eligibleRuns.length,
+      excludedSynthetic: loaded.runs.length - eligibleRuns.length,
+      successes,
+      failures: eligibleRuns.length - successes,
+      successRate,
+      latencyCoverageRate,
+      latencyP95Ms,
+      nativeSettledRate,
+      distinctSessions,
+      lastObservedAt,
+      hoursSinceLastObservation,
+      sampled: loaded.capped,
+    },
+    service: {
+      status: serviceHealth?.status ?? null,
+      latencyMs: serviceHealth?.latencyMs ?? null,
+      checkpointKind: checkpoint?.kind ?? null,
+      checkpointDurable: checkpoint?.durable ?? null,
+      executorJobStoreKind: executorStore?.kind ?? null,
+      executorJobStoreDurable: executorStore?.durable ?? null,
+      execution: serviceHealth?.details?.execution ?? null,
+    },
+    checks,
+    blockers: checks.filter((check) => !check.passed).map((check) => check.id),
+    failureCodes: [...failureCounts.entries()]
+      .map(([code, count]) => ({ code, count }))
+      .sort((left, right) => right.count - left.count || left.code.localeCompare(right.code))
+      .slice(0, 10),
+  };
+}
+
+function summarizeRuns(runs, { capped = false } = {}) {
+  const successes = runs.filter((run) => run.shadowStatus === 'succeeded').length;
+  const failures = runs.length - successes;
+  const latencies = runs
+    .map((run) => run.latencyMs)
+    .filter((value) => Number.isFinite(value));
+  return {
+    observations: runs.length,
+    successes,
+    failures,
+    successRate: runs.length ? successes / runs.length : null,
+    failureRate: runs.length ? failures / runs.length : null,
+    latencyP50Ms: percentile(latencies, 0.5),
+    latencyP95Ms: percentile(latencies, 0.95),
+    nativeSucceeded: runs.filter((run) => run.nativeStatus === 'succeeded').length,
+    nativeFailed: runs.filter((run) => run.nativeStatus === 'failed').length,
+    lastObservedAt: runs[0]?.observedAt ?? null,
+    sampled: capped,
+  };
+}
+
+function countValues(values) {
+  const counts = new Map();
+  for (const value of values) {
+    const normalized = String(value ?? '').trim() || 'unknown';
+    counts.set(normalized, (counts.get(normalized) ?? 0) + 1);
+  }
+  return [...counts.entries()]
+    .map(([value, count]) => ({ value, count }))
+    .sort((left, right) => right.count - left.count || left.value.localeCompare(right.value));
+}
+
+function summarizeExecutionPlans(plans, { capped = false } = {}) {
+  const candidateSelections = plans.filter(
+    (plan) => plan.candidateEngine !== WORKFLOW_ENGINE.NATIVE,
+  ).length;
+  const nativeSettled = plans.filter((plan) =>
+    NATIVE_TERMINAL_STATUSES.has(plan.nativeStatus)).length;
+  return {
+    decisions: plans.length,
+    candidateSelections,
+    candidateSelectionRate: ratio(candidateSelections, plans.length),
+    nativeSelections: plans.length - candidateSelections,
+    nativeSucceeded: plans.filter((plan) => plan.nativeStatus === 'succeeded').length,
+    nativeFailed: plans.filter((plan) => plan.nativeStatus === 'failed').length,
+    nativeSettledRate: ratio(nativeSettled, plans.length),
+    handoffAllowed: plans.filter((plan) => plan.handoffAllowed).length,
+    distinctSessions: new Set(plans.map((plan) => plan.sessionId).filter(Boolean)).size,
+    lastPlannedAt: plans[0]?.plannedAt ?? null,
+    candidateReasons: countValues(plans.map((plan) => plan.candidateReason ?? plan.reason)),
+    taskTypes: countValues(plans.map((plan) => plan.taskType)),
+    sampled: capped,
+  };
+}
+
+function safeRemoteError(error) {
+  return {
+    code: String(error?.code ?? 'ORCHESTRATOR_UNAVAILABLE').slice(0, 128),
+    message: String(error instanceof Error ? error.message : error).slice(0, 1000),
+  };
+}
+
+export function createOrchestratorObservabilityService({
+  pool,
+  configService,
+  serviceToken = process.env.MEMIND_ORCHESTRATOR_SERVICE_TOKEN,
+  fetchImpl = globalThis.fetch,
+  nowMs = Date.now,
+} = {}) {
+  if (!pool?.query) throw new Error('Orchestrator observability requires a database pool');
+  if (!configService?.getRuntimeState) {
+    throw new Error('Orchestrator observability requires config service');
+  }
+
+  async function loadShadowEvents({ hours = 24 } = {}) {
+    const normalizedHours = clampInteger(hours, 24, 1, 24 * 30);
+    const from = nowMs() - normalizedHours * 60 * 60 * 1000;
+    const [rows] = await pool.query(
+      `SELECT
+         e.id AS event_id,
+         e.run_id,
+         e.event_type,
+         e.data_json,
+         e.created_at AS event_created_at,
+         r.request_id,
+         r.user_id,
+         r.agent_session_id,
+         r.status AS native_status,
+         r.attempts AS native_attempts,
+         r.completed_at AS native_completed_at
+       FROM h5_agent_run_events e
+       INNER JOIN h5_agent_runs r ON r.id = e.run_id
+       WHERE e.event_type IN (?, ?)
+         AND e.created_at >= ?
+       ORDER BY e.created_at DESC, e.id DESC
+       LIMIT ?`,
+      [...SHADOW_EVENT_TYPES, from, MAX_METRIC_EVENTS],
+    );
+    return {
+      from,
+      hours: normalizedHours,
+      capped: rows.length >= MAX_METRIC_EVENTS,
+      runs: projectUniqueShadowRuns(rows),
+    };
+  }
+
+  async function loadExecutionPlanEvents({ hours = 24 } = {}) {
+    const normalizedHours = clampInteger(hours, 24, 1, 24 * 30);
+    const from = nowMs() - normalizedHours * 60 * 60 * 1000;
+    const [rows] = await pool.query(
+      `SELECT
+         e.id AS event_id,
+         e.run_id,
+         e.data_json,
+         e.created_at AS event_created_at,
+         r.request_id,
+         r.user_id,
+         r.agent_session_id,
+         r.status AS native_status,
+         r.attempts AS native_attempts,
+         r.completed_at AS native_completed_at
+       FROM h5_agent_run_events e
+       INNER JOIN h5_agent_runs r ON r.id = e.run_id
+       WHERE e.event_type = ?
+         AND e.created_at >= ?
+       ORDER BY e.created_at DESC, e.id DESC
+       LIMIT ?`,
+      [EXECUTION_PLAN_EVENT_TYPE, from, MAX_METRIC_EVENTS],
+    );
+    return {
+      from,
+      hours: normalizedHours,
+      capped: rows.length >= MAX_METRIC_EVENTS,
+      plans: projectUniqueExecutionPlans(rows),
+    };
+  }
+
+  return {
+    async getCanaryReadiness() {
+      const [loaded, runtimeState] = await Promise.all([
+        loadShadowEvents({ hours: CANARY_READINESS_THRESHOLDS.hours }),
+        configService.getRuntimeState({ probe: true }),
+      ]);
+      return buildCanaryReadiness(loaded, runtimeState, nowMs());
+    },
+
+    async listShadowRuns({
+      hours = 24,
+      limit = 50,
+      status = 'all',
+    } = {}) {
+      const loaded = await loadShadowEvents({ hours });
+      const normalizedLimit = clampInteger(limit, 50, 1, 200);
+      const normalizedStatus = ['succeeded', 'failed'].includes(status) ? status : 'all';
+      const filtered = normalizedStatus === 'all'
+        ? loaded.runs
+        : loaded.runs.filter((run) => run.shadowStatus === normalizedStatus);
+      return {
+        generatedAt: nowMs(),
+        window: {
+          hours: loaded.hours,
+          from: loaded.from,
+        },
+        metrics: summarizeRuns(loaded.runs, { capped: loaded.capped }),
+        runs: filtered.slice(0, normalizedLimit),
+      };
+    },
+
+    async listExecutionPlans({
+      hours = 24,
+      limit = 50,
+      selection = 'all',
+    } = {}) {
+      const loaded = await loadExecutionPlanEvents({ hours });
+      const normalizedLimit = clampInteger(limit, 50, 1, 200);
+      const normalizedSelection = ['candidate', 'native'].includes(selection)
+        ? selection
+        : 'all';
+      const filtered = normalizedSelection === 'all'
+        ? loaded.plans
+        : loaded.plans.filter((plan) => (
+          normalizedSelection === 'candidate'
+            ? plan.candidateEngine !== WORKFLOW_ENGINE.NATIVE
+            : plan.candidateEngine === WORKFLOW_ENGINE.NATIVE
+        ));
+      return {
+        generatedAt: nowMs(),
+        window: {
+          hours: loaded.hours,
+          from: loaded.from,
+        },
+        metrics: summarizeExecutionPlans(loaded.plans, { capped: loaded.capped }),
+        plans: filtered.slice(0, normalizedLimit),
+      };
+    },
+
+    async getShadowRun(runId) {
+      const normalizedRunId = normalizeRunId(runId);
+      if (!normalizedRunId) return null;
+      const [runRows] = await pool.query(
+        `SELECT id, request_id, user_id, agent_session_id, status, attempts,
+                error_message, created_at, updated_at, started_at, completed_at
+           FROM h5_agent_runs
+          WHERE id = ?
+          LIMIT 1`,
+        [normalizedRunId],
+      );
+      if (!runRows[0]) return null;
+      const [eventRows] = await pool.query(
+        `SELECT id AS event_id, event_type, data_json, created_at
+           FROM h5_agent_run_events
+          WHERE run_id = ? AND event_type IN (?, ?)
+          ORDER BY created_at ASC, id ASC`,
+        [normalizedRunId, ...SHADOW_EVENT_TYPES],
+      );
+      const native = runRows[0];
+      const localEvents = eventRows.map((row) => ({
+        eventId: row.event_id,
+        type: row.event_type,
+        data: parseJsonColumn(row.data_json, null),
+        createdAt: Number(row.created_at),
+      }));
+
+      let remote = {
+        available: false,
+        state: null,
+        events: [],
+        error: null,
+        executorJob: {
+          available: false,
+          state: null,
+          events: [],
+          error: null,
+        },
+      };
+      try {
+        const runtimeState = await configService.getRuntimeState();
+        if (runtimeState.config.serviceUrl) {
+          const engine = createRemoteWorkflowEngine({
+            baseUrl: runtimeState.config.serviceUrl,
+            serviceToken,
+            timeoutMs: runtimeState.config.requestTimeoutMs,
+            fetchImpl,
+          });
+          const [state, events] = await Promise.all([
+            engine.getState(normalizedRunId),
+            (async () => {
+              const collected = [];
+              for await (const event of engine.streamEvents(normalizedRunId)) {
+                collected.push(event);
+                if (collected.length >= 500) break;
+              }
+              return collected;
+            })(),
+          ]);
+          const executorJobId = normalizeExecutorJobId(state?.plan?.executorJob?.id);
+          let executorJob = {
+            available: false,
+            state: null,
+            events: [],
+            error: null,
+          };
+          if (executorJobId) {
+            try {
+              const [jobState, jobEvents] = await Promise.all([
+                engine.getExecutorJob(executorJobId),
+                (async () => {
+                  const collected = [];
+                  for await (const event of engine.streamExecutorJobEvents(executorJobId)) {
+                    collected.push(event);
+                    if (collected.length >= 500) break;
+                  }
+                  return collected;
+                })(),
+              ]);
+              executorJob = {
+                available: true,
+                state: jobState,
+                events: jobEvents,
+                error: null,
+              };
+            } catch (error) {
+              executorJob.error = safeRemoteError(error);
+            }
+          }
+          remote = {
+            available: true,
+            state,
+            events,
+            error: null,
+            executorJob,
+          };
+        }
+      } catch (error) {
+        remote.error = safeRemoteError(error);
+      }
+
+      return {
+        native: {
+          runId: native.id,
+          requestId: native.request_id,
+          userId: native.user_id,
+          sessionId: native.agent_session_id ?? null,
+          status: native.status,
+          attempts: Number(native.attempts ?? 0),
+          error: native.error_message ?? null,
+          createdAt: Number(native.created_at ?? 0),
+          updatedAt: Number(native.updated_at ?? 0),
+          startedAt: native.started_at == null ? null : Number(native.started_at),
+          completedAt: native.completed_at == null ? null : Number(native.completed_at),
+        },
+        localEvents,
+        remote,
+      };
+    },
+  };
+}
+
+export const orchestratorObservabilityInternals = {
+  CANARY_READINESS_THRESHOLDS,
+  EXECUTION_PLAN_EVENT_TYPE,
+  MAX_METRIC_EVENTS,
+  SHADOW_EVENT_TYPES,
+  buildCanaryReadiness,
+  normalizeExecutorJobId,
+  normalizeRunId,
+  parseJsonColumn,
+  percentile,
+  projectShadowEventRow,
+  projectUniqueShadowRuns,
+  projectExecutionPlanEventRow,
+  projectUniqueExecutionPlans,
+  summarizeExecutionPlans,
+  summarizeRuns,
+};
diff --git a/services/orchestrator/observability.test.mjs b/services/orchestrator/observability.test.mjs
new file mode 100644
index 0000000..b201ffc
--- /dev/null
+++ b/services/orchestrator/observability.test.mjs
@@ -0,0 +1,432 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  createOrchestratorObservabilityService,
+  orchestratorObservabilityInternals,
+} from './observability.mjs';
+
+function response(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+test('observability aggregates shadow outcomes and latency percentiles', async () => {
+  const rows = [
+    {
+      event_id: 'event-3',
+      run_id: 'run-3',
+      event_type: 'workflow_shadow_completed',
+      data_json: { latencyMs: 300, engine: 'langgraph', taskType: 'refactor' },
+      event_created_at: 3000,
+      request_id: 'request-3',
+      user_id: 'user-3',
+      native_status: 'succeeded',
+      native_attempts: 1,
+      native_completed_at: 3100,
+    },
+    {
+      event_id: 'event-2',
+      run_id: 'run-2',
+      event_type: 'workflow_shadow_failed',
+      data_json: JSON.stringify({ latencyMs: 200, code: 'TIMEOUT', message: 'timed out' }),
+      event_created_at: 2000,
+      request_id: 'request-2',
+      user_id: 'user-2',
+      native_status: 'succeeded',
+      native_attempts: 1,
+      native_completed_at: 2200,
+    },
+    {
+      event_id: 'event-1',
+      run_id: 'run-1',
+      event_type: 'workflow_shadow_completed',
+      data_json: { latencyMs: 100, executorAdapter: 'native-agent-run' },
+      event_created_at: 1000,
+      request_id: 'request-1',
+      user_id: 'user-1',
+      native_status: 'failed',
+      native_attempts: 2,
+      native_completed_at: 1500,
+    },
+  ];
+  const service = createOrchestratorObservabilityService({
+    pool: {
+      async query(sql) {
+        assert.match(sql, /INNER JOIN h5_agent_runs/);
+        return [rows];
+      },
+    },
+    configService: { getRuntimeState() {} },
+  });
+
+  const result = await service.listShadowRuns({ hours: 12, limit: 2 });
+  assert.equal(result.window.hours, 12);
+  assert.equal(result.metrics.observations, 3);
+  assert.equal(result.metrics.successes, 2);
+  assert.equal(result.metrics.failures, 1);
+  assert.equal(result.metrics.latencyP50Ms, 200);
+  assert.equal(result.metrics.latencyP95Ms, 300);
+  assert.equal(result.metrics.nativeSucceeded, 2);
+  assert.equal(result.runs.length, 2);
+  assert.equal(result.runs[1].error.code, 'TIMEOUT');
+});
+
+test('observability aggregates complete dry-run routing decisions and Native outcomes', async () => {
+  const rows = [
+    {
+      event_id: 'plan-event-3',
+      run_id: 'plan-run-3',
+      data_json: {
+        mode: 'canary',
+        candidateEngine: 'langgraph',
+        effectiveEngine: 'native',
+        fallbackEngine: 'native',
+        reason: 'execution_gate_disabled',
+        candidateReason: 'percentage',
+        configVersion: 4,
+        bucket: 12,
+        taskType: 'repo_refactor',
+        dryRun: true,
+        handoffAllowed: false,
+      },
+      event_created_at: 3000,
+      request_id: 'plan-request-3',
+      user_id: 'plan-user-3',
+      agent_session_id: 'plan-session-2',
+      native_status: 'failed',
+      native_attempts: 2,
+      native_completed_at: 3100,
+    },
+    {
+      event_id: 'plan-event-2',
+      run_id: 'plan-run-2',
+      data_json: JSON.stringify({
+        mode: 'canary',
+        candidateEngine: 'native',
+        effectiveEngine: 'native',
+        reason: 'canary_not_selected',
+        configVersion: 4,
+        bucket: 78,
+        taskType: 'code_analysis',
+        dryRun: true,
+        handoffAllowed: false,
+      }),
+      event_created_at: 2000,
+      request_id: 'plan-request-2',
+      user_id: 'plan-user-2',
+      agent_session_id: 'plan-session-1',
+      native_status: 'succeeded',
+      native_attempts: 1,
+      native_completed_at: 2100,
+    },
+    {
+      event_id: 'plan-event-1',
+      run_id: 'plan-run-1',
+      data_json: {
+        mode: 'canary',
+        candidateEngine: 'langgraph',
+        effectiveEngine: 'native',
+        reason: 'execution_gate_disabled',
+        candidateReason: 'user_allowlist',
+        taskType: 'repo_refactor',
+        dryRun: true,
+        handoffAllowed: false,
+      },
+      event_created_at: 1000,
+      request_id: 'plan-request-1',
+      user_id: 'plan-user-1',
+      agent_session_id: 'plan-session-1',
+      native_status: 'running',
+      native_attempts: 1,
+      native_completed_at: null,
+    },
+  ];
+  const service = createOrchestratorObservabilityService({
+    pool: {
+      async query(sql, params) {
+        assert.match(sql, /e\.event_type = \?/);
+        assert.equal(params[0], 'workflow_execution_planned');
+        return [rows];
+      },
+    },
+    configService: { getRuntimeState() {} },
+    nowMs: () => 5000,
+  });
+
+  const result = await service.listExecutionPlans({
+    hours: 12,
+    limit: 10,
+    selection: 'candidate',
+  });
+  assert.equal(result.window.hours, 12);
+  assert.equal(result.metrics.decisions, 3);
+  assert.equal(result.metrics.candidateSelections, 2);
+  assert.equal(result.metrics.candidateSelectionRate, 2 / 3);
+  assert.equal(result.metrics.nativeSelections, 1);
+  assert.equal(result.metrics.nativeSucceeded, 1);
+  assert.equal(result.metrics.nativeFailed, 1);
+  assert.equal(result.metrics.nativeSettledRate, 2 / 3);
+  assert.equal(result.metrics.handoffAllowed, 0);
+  assert.equal(result.metrics.distinctSessions, 2);
+  assert.deepEqual(result.metrics.candidateReasons, [
+    { value: 'canary_not_selected', count: 1 },
+    { value: 'percentage', count: 1 },
+    { value: 'user_allowlist', count: 1 },
+  ]);
+  assert.deepEqual(result.metrics.taskTypes, [
+    { value: 'repo_refactor', count: 2 },
+    { value: 'code_analysis', count: 1 },
+  ]);
+  assert.equal(result.plans.length, 2);
+  assert.equal(result.plans[0].candidateEngine, 'langgraph');
+  assert.equal(result.plans[0].effectiveEngine, 'native');
+  assert.equal(result.plans[0].taskType, 'repo_refactor');
+});
+
+test('observability detail joins Native state with remote LangGraph checkpoint events', async () => {
+  const queries = [];
+  const service = createOrchestratorObservabilityService({
+    pool: {
+      async query(sql, params) {
+        queries.push({ sql, params });
+        if (sql.includes('FROM h5_agent_runs')) {
+          return [[{
+            id: 'run-detail',
+            request_id: 'request-detail',
+            user_id: 'user-detail',
+            agent_session_id: 'session-detail',
+            status: 'succeeded',
+            attempts: 1,
+            error_message: null,
+            created_at: 100,
+            updated_at: 300,
+            started_at: 150,
+            completed_at: 300,
+          }]];
+        }
+        return [[{
+          event_id: 'local-event',
+          event_type: 'workflow_shadow_completed',
+          data_json: { latencyMs: 25 },
+          created_at: 250,
+        }]];
+      },
+    },
+    configService: {
+      async getRuntimeState() {
+        return {
+          config: {
+            serviceUrl: 'http://orchestrator.internal:8093',
+            requestTimeoutMs: 1000,
+          },
+        };
+      },
+    },
+    serviceToken: 'detail-token',
+    fetchImpl: async (url, init) => {
+      assert.equal(init.headers.authorization, 'Bearer detail-token');
+      if (String(url).includes('/executor-jobs/') && String(url).endsWith('/events')) {
+        return response({
+          events: [{ sequence: 1, type: 'executor_job_blocked' }],
+        });
+      }
+      if (String(url).includes('/executor-jobs/')) {
+        return response({
+          jobId: 'run-detail:executor-preview',
+          status: 'blocked',
+          reason: 'executor_dispatch_not_implemented',
+        });
+      }
+      if (String(url).endsWith('/events')) {
+        return response({
+          events: [{ sequence: 1, type: 'workflow_validated' }],
+        });
+      }
+      return response({
+        runId: 'run-detail',
+        status: 'succeeded',
+        plan: {
+          executorAdapter: 'native-agent-run',
+          executorJob: { id: 'run-detail:executor-preview' },
+        },
+      });
+    },
+  });
+
+  const detail = await service.getShadowRun('run-detail');
+  assert.equal(detail.native.status, 'succeeded');
+  assert.equal(detail.localEvents[0].data.latencyMs, 25);
+  assert.equal(detail.remote.available, true);
+  assert.equal(detail.remote.state.plan.executorAdapter, 'native-agent-run');
+  assert.equal(detail.remote.events[0].type, 'workflow_validated');
+  assert.equal(detail.remote.executorJob.available, true);
+  assert.equal(detail.remote.executorJob.state.status, 'blocked');
+  assert.equal(detail.remote.executorJob.events[0].type, 'executor_job_blocked');
+  assert.equal(queries.length, 2);
+});
+
+test('observability rejects unsafe run ids before querying', async () => {
+  let queries = 0;
+  const service = createOrchestratorObservabilityService({
+    pool: {
+      async query() {
+        queries += 1;
+        return [[]];
+      },
+    },
+    configService: { getRuntimeState() {} },
+  });
+  assert.equal(await service.getShadowRun('../unsafe'), null);
+  assert.equal(queries, 0);
+});
+
+test('observability counts only the newest terminal event for each run', () => {
+  const base = {
+    run_id: 'same-run',
+    request_id: 'same-request',
+    user_id: 'same-user',
+    native_status: 'succeeded',
+    native_attempts: 1,
+  };
+  const runs = orchestratorObservabilityInternals.projectUniqueShadowRuns([
+    {
+      ...base,
+      event_id: 'newer-success',
+      event_type: 'workflow_shadow_completed',
+      data_json: { latencyMs: 80 },
+      event_created_at: 2000,
+    },
+    {
+      ...base,
+      event_id: 'older-failure',
+      event_type: 'workflow_shadow_failed',
+      data_json: { latencyMs: 100, code: 'TIMEOUT' },
+      event_created_at: 1000,
+    },
+  ]);
+  assert.equal(runs.length, 1);
+  assert.equal(runs[0].eventId, 'newer-success');
+  assert.equal(runs[0].shadowStatus, 'succeeded');
+});
+
+test('canary readiness excludes smoke runs and reports explicit blockers', async () => {
+  const now = 10_000_000;
+  const service = createOrchestratorObservabilityService({
+    pool: {
+      async query() {
+        return [[{
+          event_id: 'smoke-event',
+          run_id: 'smoke-run',
+          event_type: 'workflow_shadow_completed',
+          data_json: {
+            latencyMs: 50,
+            taskType: 'orchestrator_shadow_smoke',
+          },
+          event_created_at: now - 1000,
+          request_id: 'smoke-request',
+          user_id: 'smoke-user',
+          agent_session_id: null,
+          native_status: 'succeeded',
+          native_attempts: 0,
+          native_completed_at: now,
+        }]];
+      },
+    },
+    configService: {
+      async getRuntimeState(options) {
+        assert.deepEqual(options, { probe: true });
+        return {
+          config: { mode: 'shadow' },
+          serviceHealth: {
+            ok: true,
+            status: 'healthy',
+            latencyMs: 5,
+            details: {
+              checkpoint: { kind: 'postgres', durable: true },
+              executorGateway: {
+                store: { kind: 'postgres', durable: true },
+              },
+              execution: 'observe-only',
+            },
+          },
+        };
+      },
+    },
+    nowMs: () => now,
+  });
+
+  const readiness = await service.getCanaryReadiness();
+  assert.equal(readiness.ready, false);
+  assert.equal(readiness.recommendation, 'keep_shadow');
+  assert.equal(readiness.samples.totalObservations, 1);
+  assert.equal(readiness.samples.eligibleObservations, 0);
+  assert.equal(readiness.samples.excludedSynthetic, 1);
+  assert.ok(readiness.blockers.includes('sample_volume'));
+  assert.ok(readiness.blockers.includes('session_coverage'));
+  assert.ok(!readiness.blockers.includes('service_healthy'));
+});
+
+test('canary readiness passes only when operational and sample gates all pass', async () => {
+  const now = 20_000_000;
+  const rows = Array.from({ length: 20 }, (_, index) => ({
+    event_id: `event-${index}`,
+    run_id: `run-${index}`,
+    event_type: index === 19
+      ? 'workflow_shadow_failed'
+      : 'workflow_shadow_completed',
+    data_json: {
+      latencyMs: 100 + index,
+      taskType: 'code_task',
+      ...(index === 19 ? { code: 'TRANSIENT', message: 'retry later' } : {}),
+    },
+    event_created_at: now - index * 1000,
+    request_id: `request-${index}`,
+    user_id: `user-${index % 3}`,
+    agent_session_id: `session-${index % 5}`,
+    native_status: index % 2 ? 'succeeded' : 'failed',
+    native_attempts: 1,
+    native_completed_at: now,
+  }));
+  const service = createOrchestratorObservabilityService({
+    pool: {
+      async query() {
+        return [rows];
+      },
+    },
+    configService: {
+      async getRuntimeState() {
+        return {
+          config: { mode: 'shadow' },
+          serviceHealth: {
+            ok: true,
+            status: 'healthy',
+            latencyMs: 4,
+            details: {
+              checkpoint: { kind: 'postgres', durable: true },
+              executorGateway: {
+                store: { kind: 'postgres', durable: true },
+              },
+              execution: 'observe-only',
+            },
+          },
+        };
+      },
+    },
+    nowMs: () => now,
+  });
+
+  const readiness = await service.getCanaryReadiness();
+  assert.equal(readiness.ready, true);
+  assert.equal(readiness.recommendation, 'manual_canary_review');
+  assert.equal(readiness.window.hours, 168);
+  assert.equal(readiness.samples.eligibleObservations, 20);
+  assert.equal(readiness.samples.successRate, 0.95);
+  assert.equal(readiness.samples.latencyCoverageRate, 1);
+  assert.equal(readiness.samples.nativeSettledRate, 1);
+  assert.equal(readiness.samples.distinctSessions, 5);
+  assert.equal(readiness.service.executorJobStoreDurable, true);
+  assert.equal(readiness.blockers.length, 0);
+  assert.deepEqual(readiness.failureCodes, [{ code: 'TRANSIENT', count: 1 }]);
+});
diff --git a/services/orchestrator/package-lock.json b/services/orchestrator/package-lock.json
new file mode 100644
index 0000000..c594b98
--- /dev/null
+++ b/services/orchestrator/package-lock.json
@@ -0,0 +1,1297 @@
+{
+  "name": "@memind/workflow-orchestrator",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@memind/workflow-orchestrator",
+      "version": "0.1.0",
+      "dependencies": {
+        "@langchain/core": "^1.2.3",
+        "@langchain/langgraph": "^1.4.8",
+        "@langchain/langgraph-checkpoint-postgres": "^1.0.4",
+        "express": "^4.21.2",
+        "pg": "^8.12.0",
+        "undici": "^6.27.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@cfworker/json-schema": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/@cfworker/json-schema/-/json-schema-4.1.1.tgz",
+      "integrity": "sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og==",
+      "license": "MIT"
+    },
+    "node_modules/@langchain/core": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@langchain/core/-/core-1.2.3.tgz",
+      "integrity": "sha512-F+L5SsciykwDl7eDxacnhDTcWe1IF6jetzfkvI5PPfq6ogWHO7xcjU90SGh/3lqbbS0tgun+qF01KIqxawrCsA==",
+      "license": "MIT",
+      "dependencies": {
+        "@cfworker/json-schema": "^4.0.2",
+        "@standard-schema/spec": "^1.1.0",
+        "js-tiktoken": "^1.0.12",
+        "langsmith": ">=0.5.0 <1.0.0",
+        "mustache": "^4.2.0",
+        "p-queue": "^6.6.2",
+        "zod": "^3.25.76 || ^4"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@langchain/langgraph": {
+      "version": "1.4.8",
+      "resolved": "https://registry.npmjs.org/@langchain/langgraph/-/langgraph-1.4.8.tgz",
+      "integrity": "sha512-DN1Np1XefdBEbp1qBKlt39cwoL743AAGpR5Ipja0gY2YbWvsoQnOTIrjnj/orSAhaUYsdTKS8VSWdFzsHZo6Ig==",
+      "license": "MIT",
+      "dependencies": {
+        "@langchain/langgraph-checkpoint": "^1.1.3",
+        "@langchain/langgraph-sdk": "~1.9.26",
+        "@langchain/protocol": "^0.0.18",
+        "@standard-schema/spec": "1.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@langchain/core": "^1.1.48",
+        "zod": "^3.25.32 || ^4.2.0"
+      }
+    },
+    "node_modules/@langchain/langgraph-checkpoint": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@langchain/langgraph-checkpoint/-/langgraph-checkpoint-1.1.3.tgz",
+      "integrity": "sha512-wgzdQNeEsdw1e+4lvlj0tdq/RYR/k1vPin10g0ymGoehZDDgd9nvIllGXSXN4TFgF9sf5qQP/KTkOcLfeseIhA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@langchain/core": "^1.1.48"
+      }
+    },
+    "node_modules/@langchain/langgraph-checkpoint-postgres": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@langchain/langgraph-checkpoint-postgres/-/langgraph-checkpoint-postgres-1.0.4.tgz",
+      "integrity": "sha512-wuCPq7VVqwi0+nQC5GOmheoXGJHAybgXbkA9Nn0J8nYW61WFJ3uqb4wyMbLFhAlya99EaxNNsi3FzdzV2COSzw==",
+      "license": "MIT",
+      "dependencies": {
+        "pg": "^8.12.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@langchain/core": "^1.1.44",
+        "@langchain/langgraph-checkpoint": "^1.0.0"
+      }
+    },
+    "node_modules/@langchain/langgraph-sdk": {
+      "version": "1.9.28",
+      "resolved": "https://registry.npmjs.org/@langchain/langgraph-sdk/-/langgraph-sdk-1.9.28.tgz",
+      "integrity": "sha512-4j3XuM0PvtmAbL8mPfBS99ez3+ytRfgbOpAR/nOeaejTRF3Q9dNw2QnaGLGng8wLPtGLoSj+SYgUOVxy9Bv9vg==",
+      "license": "MIT",
+      "dependencies": {
+        "@langchain/protocol": "^0.0.18",
+        "@types/json-schema": "^7.0.15",
+        "p-queue": "^9.0.1",
+        "p-retry": "^7.1.1"
+      },
+      "peerDependencies": {
+        "@langchain/core": "^1.1.48",
+        "react": "^18 || ^19",
+        "react-dom": "^18 || ^19",
+        "svelte": "^4.0.0 || ^5.0.0",
+        "vue": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "react": {
+          "optional": true
+        },
+        "react-dom": {
+          "optional": true
+        },
+        "svelte": {
+          "optional": true
+        },
+        "vue": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@langchain/langgraph-sdk/node_modules/eventemitter3": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz",
+      "integrity": "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==",
+      "license": "MIT"
+    },
+    "node_modules/@langchain/langgraph-sdk/node_modules/p-queue": {
+      "version": "9.3.3",
+      "resolved": "https://registry.npmjs.org/p-queue/-/p-queue-9.3.3.tgz",
+      "integrity": "sha512-NXAOdnEe5FsZJfT4oK84lE1Y5cFFdWlRuOo5tww8DyNMxyRXwn39fIkUtNLKppcPC+UYU/bXujNCUGDv01y7CA==",
+      "license": "MIT",
+      "dependencies": {
+        "eventemitter3": "^5.0.4",
+        "p-timeout": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@langchain/langgraph-sdk/node_modules/p-timeout": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-7.0.1.tgz",
+      "integrity": "sha512-AxTM2wDGORHGEkPCt8yqxOTMgpfbEHqF51f/5fJCmwFC3C/zNcGT63SymH2ttOAaiIws2zVg4+izQCjrakcwHg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@langchain/protocol": {
+      "version": "0.0.18",
+      "resolved": "https://registry.npmjs.org/@langchain/protocol/-/protocol-0.0.18.tgz",
+      "integrity": "sha512-XW1egQtPfsGI41w2AMZNFZrUIwFSQHTjVMZs0OaTpCAvht/QLoaPN8FQcsysMVypOhupG28J29yOorrc70otBQ==",
+      "license": "MIT"
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "license": "MIT"
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "license": "MIT"
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "license": "MIT"
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.6",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.6.tgz",
+      "integrity": "sha512-p5tAzS57i5MV9fZFDj9LeIiTZEufbSe2eDozP+ElheSUq1m74CRq1jI4mYNDdVs9vQztXFLuk/Gd6BWTdwRJ5g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "~1.2.0",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "on-finished": "~2.4.1",
+        "qs": "~6.15.1",
+        "raw-body": "~2.5.3",
+        "type-is": "~1.6.18",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz",
+      "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==",
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/eventemitter3": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz",
+      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
+      "license": "MIT"
+    },
+    "node_modules/express": {
+      "version": "4.22.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.22.2.tgz",
+      "integrity": "sha512-IuL+Elrou2ZvCFHs18/CIzy2Nzvo25nZ1/D2eIZlz7c+QUayAcYoiM2BthCjs+EBHVpjYjcuLDAiCWgeIX3X1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "~1.20.5",
+        "content-disposition": "~0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "~0.7.1",
+        "cookie-signature": "~1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "~1.3.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "~0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "~6.15.1",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "~0.19.0",
+        "serve-static": "~1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "~2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz",
+      "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "~2.0.2",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-network-error": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/is-network-error/-/is-network-error-1.3.2.tgz",
+      "integrity": "sha512-PhBY86zaxNZUuWP6h13Vu5oFe0XY6/UlKzQnYFELzGVHygP3MxmvTfYSG7GN3aIab/iWudSMgjSnG9Dq+nHrgA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/js-tiktoken": {
+      "version": "1.0.21",
+      "resolved": "https://registry.npmjs.org/js-tiktoken/-/js-tiktoken-1.0.21.tgz",
+      "integrity": "sha512-biOj/6M5qdgx5TKjDnFT1ymSpM5tbd3ylwDtrQvFQSu0Z7bBYko2dF+W/aUkXUPuk6IVpRxk/3Q2sHOzGlS36g==",
+      "license": "MIT",
+      "dependencies": {
+        "base64-js": "^1.5.1"
+      }
+    },
+    "node_modules/langsmith": {
+      "version": "0.8.6",
+      "resolved": "https://registry.npmjs.org/langsmith/-/langsmith-0.8.6.tgz",
+      "integrity": "sha512-tl7cV79S/SkJNskCo7joRIVCYy+ljVLs4L1hgC2qT01x4CAWX+6IJzmfXGYAJcn1ecpaQr63WRjkLO9jefmOmQ==",
+      "license": "MIT",
+      "dependencies": {
+        "p-queue": "6.6.2"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "*",
+        "@opentelemetry/exporter-trace-otlp-proto": "*",
+        "@opentelemetry/sdk-trace-base": "*",
+        "openai": "*",
+        "ws": ">=7"
+      },
+      "peerDependenciesMeta": {
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@opentelemetry/exporter-trace-otlp-proto": {
+          "optional": true
+        },
+        "@opentelemetry/sdk-trace-base": {
+          "optional": true
+        },
+        "openai": {
+          "optional": true
+        },
+        "ws": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/mustache": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/mustache/-/mustache-4.2.0.tgz",
+      "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==",
+      "license": "MIT",
+      "bin": {
+        "mustache": "bin/mustache"
+      }
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/p-finally": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz",
+      "integrity": "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/p-queue": {
+      "version": "6.6.2",
+      "resolved": "https://registry.npmjs.org/p-queue/-/p-queue-6.6.2.tgz",
+      "integrity": "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==",
+      "license": "MIT",
+      "dependencies": {
+        "eventemitter3": "^4.0.4",
+        "p-timeout": "^3.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-retry": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/p-retry/-/p-retry-7.1.1.tgz",
+      "integrity": "sha512-J5ApzjyRkkf601HpEeykoiCvzHQjWxPAHhyjFcEUP2SWq0+35NKh8TLhpLw+Dkq5TZBFvUM6UigdE9hIVYTl5w==",
+      "license": "MIT",
+      "dependencies": {
+        "is-network-error": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-timeout": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-3.2.0.tgz",
+      "integrity": "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==",
+      "license": "MIT",
+      "dependencies": {
+        "p-finally": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.13.tgz",
+      "integrity": "sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==",
+      "license": "MIT"
+    },
+    "node_modules/pg": {
+      "version": "8.22.0",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.22.0.tgz",
+      "integrity": "sha512-8wih1vVIBMxoUM2oB4soJsD9tDnDpLv4OXBJ+EJzFsvycD+lfyIreC2gGHq78f8jbLLt+bvlPTFdFZfJkOuzAA==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-connection-string": "^2.14.0",
+        "pg-pool": "^3.14.0",
+        "pg-protocol": "^1.15.0",
+        "pg-types": "2.2.0",
+        "pgpass": "1.0.5"
+      },
+      "engines": {
+        "node": ">= 16.0.0"
+      },
+      "optionalDependencies": {
+        "pg-cloudflare": "^1.4.0"
+      },
+      "peerDependencies": {
+        "pg-native": ">=3.0.1"
+      },
+      "peerDependenciesMeta": {
+        "pg-native": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pg-cloudflare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.4.0.tgz",
+      "integrity": "sha512-Vo7z/6rrQYxpNRylp4Tlob2elzbh+N/MOQbxFVWCxS7oEx6jF53GTJFxK2WWpKuBRkmiin4Mt+xofFDjx09R0A==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/pg-connection-string": {
+      "version": "2.14.0",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.14.0.tgz",
+      "integrity": "sha512-XwWDGcLRGCXAR8F/AM5bG7Q+A3Wm2s6QeEjlOKZLlH3UYcguiqCWKyWXVag5TLTIjR7oOJUY8kcADaZgWPyLeg==",
+      "license": "MIT"
+    },
+    "node_modules/pg-int8": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/pg-pool": {
+      "version": "3.14.0",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.14.0.tgz",
+      "integrity": "sha512-gKtPkFdQPU3DksooVLi9LsjZxrsBUZIpa+7aVx+LV5pNh0KzP4Zleud2po+ConrxbuXGBJ6Hfer6hdgpIBpBaw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "pg": ">=8.0"
+      }
+    },
+    "node_modules/pg-protocol": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.15.0.tgz",
+      "integrity": "sha512-cq9sECI5s0+uPUXjbz8ioyPJni6RzsRib0US67i5IoTZKw8fNeYlVE7u8F4dG7vEJJtc5wdD1K189lCCUwqWTQ==",
+      "license": "MIT"
+    },
+    "node_modules/pg-types": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-int8": "1.0.1",
+        "postgres-array": "~2.0.0",
+        "postgres-bytea": "~1.0.0",
+        "postgres-date": "~1.0.4",
+        "postgres-interval": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pgpass": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.1.0"
+      }
+    },
+    "node_modules/postgres-array": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+      "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postgres-bytea": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.1.tgz",
+      "integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-date": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+      "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-interval": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+      "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.15.3",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.3.tgz",
+      "integrity": "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "es-define-property": "^1.0.1",
+        "side-channel": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.3",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz",
+      "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/send": {
+      "version": "0.19.2",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz",
+      "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.1",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "~2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "~2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/serve-static": {
+      "version": "1.16.3",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz",
+      "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "~0.19.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/undici": {
+      "version": "6.28.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-6.28.0.tgz",
+      "integrity": "sha512-LIY910g9TI13YS95lrMFrs8Rm/u/irgHeTWoKCoteeJ04CUJ92eEfj0rVn+7VKMPBpUPiUoBKfhNyLI23EE/KA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.17"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}
diff --git a/services/orchestrator/package.json b/services/orchestrator/package.json
new file mode 100644
index 0000000..0b7e433
--- /dev/null
+++ b/services/orchestrator/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@memind/workflow-orchestrator",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "start": "node server.mjs",
+    "start:worker": "node worker.mjs",
+    "test": "node --test *.test.mjs"
+  },
+  "dependencies": {
+    "@langchain/core": "^1.2.3",
+    "@langchain/langgraph": "^1.4.8",
+    "@langchain/langgraph-checkpoint-postgres": "^1.0.4",
+    "express": "^4.21.2",
+    "pg": "^8.12.0",
+    "undici": "^6.27.0"
+  }
+}
diff --git a/services/orchestrator/runtime.mjs b/services/orchestrator/runtime.mjs
new file mode 100644
index 0000000..63734ce
--- /dev/null
+++ b/services/orchestrator/runtime.mjs
@@ -0,0 +1,297 @@
+import { buildRunEvent, normalizeRunSpec } from './contracts.mjs';
+import {
+  CODE_RUN_SHADOW_WORKFLOW,
+  createCodeRunShadowGraph,
+} from './code-run-shadow-graph.mjs';
+import {
+  createExecutorGateway,
+  createInMemoryExecutorJobStore,
+  createPhase5ExecutorAdapterRegistry,
+} from './executor-gateway.mjs';
+import { createExecutorWorkerCoordinator } from './executor-worker-protocol.mjs';
+import { createExecutorAdmissionPolicy } from './executor-admission-policy.mjs';
+
+function graphConfig(runId) {
+  return {
+    configurable: {
+      thread_id: runId,
+      checkpoint_ns: '',
+    },
+  };
+}
+
+function projectSnapshot(runId, snapshot) {
+  const values = snapshot?.values ?? {};
+  if (!values.spec) return null;
+  return {
+    version: 'orchestrator-state-v1',
+    runId,
+    requestId: values.spec.requestId,
+    workflow: values.spec.workflow,
+    status: values.status ?? 'unknown',
+    phase: values.phase ?? null,
+    plan: values.plan ?? null,
+    result: values.result ?? null,
+    createdAt: values.events?.[0]?.timestamp ?? null,
+    updatedAt: values.events?.at?.(-1)?.timestamp ?? null,
+  };
+}
+
+export function createLangGraphOrchestratorRuntime({
+  checkpointer,
+  checkpointKind = 'unknown',
+  durable = false,
+  checkpointProbe = null,
+  executorJobStore = null,
+  executorJobProbe = null,
+  executionEnabled = false,
+  enabledExecutors = [],
+  workerOptions = {},
+  admissionConfig = {},
+} = {}) {
+  const jobStore = executorJobStore ?? createInMemoryExecutorJobStore();
+  const admissionPolicy = createExecutorAdmissionPolicy({
+    store: jobStore,
+    config: admissionConfig,
+    nowMs: workerOptions.nowMs,
+  });
+  const executorGateway = createExecutorGateway({
+    store: jobStore,
+    registry: createPhase5ExecutorAdapterRegistry({ enabledExecutors }),
+    executionEnabled,
+    admissionPolicy,
+  });
+  const workerCoordinator = createExecutorWorkerCoordinator({
+    store: jobStore,
+    ...workerOptions,
+  });
+  const graph = createCodeRunShadowGraph({
+    checkpointer,
+    executorGateway,
+    executionEnabled,
+  });
+  const probe = typeof checkpointProbe === 'function'
+    ? checkpointProbe
+    : async () => {
+        await checkpointer.getTuple(graphConfig('__orchestrator_readiness__'));
+        return true;
+      };
+  const probeExecutorJobs = typeof executorJobProbe === 'function'
+    ? executorJobProbe
+    : async () => true;
+
+  async function getSnapshot(runId) {
+    return graph.getState(graphConfig(runId));
+  }
+
+  async function refreshExecutorTerminal(runId, snapshot) {
+    const values = snapshot?.values ?? {};
+    if (values.status !== 'waiting') return snapshot;
+    const jobId = values.plan?.executorJob?.id;
+    if (!jobId) return snapshot;
+    const job = await executorGateway.getJob(jobId);
+    const terminal = {
+      succeeded: { status: 'succeeded', phase: 'completed' },
+      failed: { status: 'failed', phase: 'executor_failed' },
+      cancelled: { status: 'cancelled', phase: 'cancelled' },
+      timed_out: { status: 'failed', phase: 'executor_timed_out' },
+    }[job?.status];
+    if (!terminal) return snapshot;
+    const result = {
+      observed: false,
+      executed: job.status === 'succeeded',
+      executorAdapter: values.plan.executorAdapter,
+      taskType: values.plan.taskType,
+      executorJob: {
+        id: job.jobId,
+        status: job.status,
+        reason: job.reason,
+        result: job.result ?? null,
+      },
+    };
+    await graph.updateState(graphConfig(runId), {
+      ...terminal,
+      result,
+      events: [buildRunEvent({
+        runId,
+        sequence: (values.events?.length ?? 0) + 1,
+        type: job.status === 'succeeded'
+          ? 'workflow_completed'
+          : `workflow_${job.status}`,
+        data: result,
+      })],
+    });
+    return getSnapshot(runId);
+  }
+
+  async function getState(runId) {
+    const normalizedRunId = String(runId ?? '').trim();
+    if (!normalizedRunId) return null;
+    const snapshot = await getSnapshot(normalizedRunId);
+    return projectSnapshot(
+      normalizedRunId,
+      await refreshExecutorTerminal(normalizedRunId, snapshot),
+    );
+  }
+
+  function health() {
+    return {
+      status: 'ok',
+      service: 'memind-langgraph-orchestrator',
+      checkpoint: {
+        kind: checkpointKind,
+        durable: Boolean(durable),
+      },
+      execution: executionEnabled ? 'worker-queue-enabled' : 'observe-only',
+      executorGateway: executorGateway.status(),
+      workerProtocol: {
+        version: 'executor-worker-v1',
+        enabled: executionEnabled === true,
+      },
+      admissionPolicy: admissionPolicy.status(),
+    };
+  }
+
+  return {
+    async start(input) {
+      const spec = normalizeRunSpec(input);
+      if (spec.workflow.name !== CODE_RUN_SHADOW_WORKFLOW) {
+        const error = new Error(`Unsupported workflow: ${spec.workflow.name}`);
+        error.code = 'WORKFLOW_NOT_SUPPORTED';
+        error.status = 422;
+        throw error;
+      }
+      const existing = await getState(spec.runId);
+      if (existing) return existing;
+      await graph.invoke({
+        spec,
+        status: 'queued',
+        phase: 'accepted',
+        events: [],
+      }, graphConfig(spec.runId));
+      return getState(spec.runId);
+    },
+
+    getState,
+
+    async listEvents(runId, { after = 0 } = {}) {
+      const normalizedRunId = String(runId ?? '').trim();
+      const initial = normalizedRunId ? await getSnapshot(normalizedRunId) : null;
+      const snapshot = normalizedRunId
+        ? await refreshExecutorTerminal(normalizedRunId, initial)
+        : null;
+      if (!snapshot?.values?.spec) return null;
+      const cursor = Math.max(0, Number(after) || 0);
+      const events = (snapshot.values.events ?? []).filter((event) => event.sequence > cursor);
+      return {
+        runId: normalizedRunId,
+        events,
+        nextCursor: events.at(-1)?.sequence ?? cursor,
+      };
+    },
+
+    async resume(runId) {
+      const state = await getState(runId);
+      if (!state) return null;
+      if (state.status === 'waiting') return state;
+      const error = new Error('This workflow has no interrupt point to resume');
+      error.code = 'WORKFLOW_NOT_INTERRUPTED';
+      error.status = 409;
+      throw error;
+    },
+
+    async cancel(runId) {
+      const state = await getState(runId);
+      if (!state) return null;
+      if (state.status === 'waiting' && state.plan?.executorJob?.id) {
+        await executorGateway.cancel(state.plan.executorJob.id, {
+          reason: 'workflow_cancelled',
+        });
+        return getState(runId);
+      }
+      const error = new Error('Completed shadow observations cannot be cancelled');
+      error.code = 'WORKFLOW_ALREADY_TERMINAL';
+      error.status = 409;
+      throw error;
+    },
+
+    getExecutorJob(jobId) {
+      return executorGateway.getJob(jobId);
+    },
+
+    listExecutorJobEvents(jobId, options = {}) {
+      return executorGateway.listEvents(jobId, options);
+    },
+
+    submitExecutorJob(input) {
+      return executorGateway.createJob(input);
+    },
+
+    cancelExecutorJob(jobId, options = {}) {
+      return executorGateway.cancel(jobId, options);
+    },
+
+    claimExecutorJob(input) {
+      return workerCoordinator.claim(input);
+    },
+
+    startExecutorJob(jobId, input) {
+      return workerCoordinator.start(jobId, input);
+    },
+
+    heartbeatExecutorJob(jobId, input) {
+      return workerCoordinator.heartbeat(jobId, input);
+    },
+
+    progressExecutorJob(jobId, input) {
+      return workerCoordinator.progress(jobId, input);
+    },
+
+    completeExecutorJob(jobId, input) {
+      return workerCoordinator.complete(jobId, input);
+    },
+
+    failExecutorJob(jobId, input) {
+      return workerCoordinator.fail(jobId, input);
+    },
+
+    recoverExpiredExecutorJobs(input = {}) {
+      return workerCoordinator.recoverExpired(input);
+    },
+
+    getExecutorQueueStats() {
+      return workerCoordinator.stats();
+    },
+
+    async metrics() {
+      return {
+        version: 'orchestrator-metrics-v1',
+        timestamp: Date.now(),
+        queue: await workerCoordinator.stats(),
+        gateway: executorGateway.status(),
+      };
+    },
+
+    health,
+
+    async ready() {
+      await Promise.all([probe(), probeExecutorJobs()]);
+      const executorQueue = await workerCoordinator.stats();
+      if (executionEnabled && executorQueue.healthyWorkers < 1) {
+        const error = new Error('Execution is enabled but no healthy executor worker is registered');
+        error.code = 'EXECUTOR_WORKER_UNAVAILABLE';
+        throw error;
+      }
+      return {
+        ...health(),
+        ready: true,
+        executorQueue,
+      };
+    },
+  };
+}
+
+export const orchestratorRuntimeInternals = {
+  graphConfig,
+  projectSnapshot,
+};
diff --git a/services/orchestrator/runtime.test.mjs b/services/orchestrator/runtime.test.mjs
new file mode 100644
index 0000000..95d1860
--- /dev/null
+++ b/services/orchestrator/runtime.test.mjs
@@ -0,0 +1,212 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { MemorySaver } from '@langchain/langgraph';
+import { createInMemoryExecutorJobStore } from './executor-gateway.mjs';
+import { createLangGraphOrchestratorRuntime } from './runtime.mjs';
+
+function runSpec(overrides = {}) {
+  return {
+    runId: 'run-shadow-1',
+    requestId: 'request-shadow-1',
+    workflow: { name: 'code-run-v1', version: 1 },
+    subject: { userId: 'user-1' },
+    input: {
+      instruction: 'Add an idempotency test',
+      taskType: 'code-change',
+    },
+    policy: {
+      executionMode: 'observe-only',
+      sideEffectsAllowed: false,
+    },
+    ...overrides,
+  };
+}
+
+test('LangGraph runtime checkpoints a deterministic observe-only code workflow', async () => {
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: new MemorySaver(),
+    checkpointKind: 'memory',
+    durable: false,
+  });
+
+  const state = await runtime.start(runSpec());
+  assert.equal(state.runId, 'run-shadow-1');
+  assert.equal(state.status, 'succeeded');
+  assert.equal(state.phase, 'completed');
+  assert.equal(state.result.observed, true);
+  assert.equal(state.result.executed, false);
+  assert.equal(state.plan.executorAdapter, 'native-agent-run');
+  assert.deepEqual(state.plan.executorJob, {
+    kind: 'executor-job',
+    id: 'run-shadow-1:executor-preview',
+    executor: 'goosed',
+    status: 'blocked',
+    reason: 'executor_execution_disabled',
+    durable: false,
+  });
+  assert.equal(
+    (await runtime.getExecutorJob('run-shadow-1:executor-preview')).status,
+    'blocked',
+  );
+  const executorEvents = await runtime.listExecutorJobEvents(
+    'run-shadow-1:executor-preview',
+  );
+  assert.deepEqual(
+    executorEvents.events.map((event) => event.type),
+    ['executor_job_blocked'],
+  );
+  assert.equal(executorEvents.nextCursor, 1);
+
+  const restored = await runtime.getState('run-shadow-1');
+  assert.deepEqual(restored, state);
+
+  const eventPage = await runtime.listEvents('run-shadow-1');
+  assert.deepEqual(
+    eventPage.events.map((event) => event.type),
+    ['workflow_validated', 'workflow_planned', 'workflow_completed'],
+  );
+  assert.deepEqual(
+    eventPage.events.map((event) => event.sequence),
+    [1, 2, 3],
+  );
+  assert.equal(eventPage.nextCursor, 3);
+  assert.equal((await runtime.listEvents('run-shadow-1', { after: 2 })).events.length, 1);
+});
+
+test('LangGraph runtime is idempotent by run id', async () => {
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: new MemorySaver(),
+  });
+
+  const first = await runtime.start(runSpec());
+  const second = await runtime.start(runSpec({
+    input: { instruction: 'This must not replace the first checkpoint' },
+  }));
+
+  assert.deepEqual(second, first);
+  assert.equal((await runtime.listEvents('run-shadow-1')).events.length, 3);
+});
+
+test('LangGraph runtime persists a durable blocked Executor Job and probes both stores', async () => {
+  const checkpointProbeCalls = [];
+  const executorProbeCalls = [];
+  const executorJobStore = {
+    ...createInMemoryExecutorJobStore(),
+    kind: 'postgres',
+    durable: true,
+  };
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: new MemorySaver(),
+    checkpointKind: 'postgres',
+    durable: true,
+    checkpointProbe: async () => checkpointProbeCalls.push('checkpoint'),
+    executorJobStore,
+    executorJobProbe: async () => executorProbeCalls.push('executor-jobs'),
+  });
+
+  const state = await runtime.start(runSpec());
+  assert.equal(state.plan.executorJob.durable, true);
+  assert.equal(
+    (await executorJobStore.getById('run-shadow-1:executor-preview')).status,
+    'blocked',
+  );
+
+  const ready = await runtime.ready();
+  assert.equal(ready.ready, true);
+  assert.equal(ready.executorGateway.store.kind, 'postgres');
+  assert.equal(ready.executorGateway.store.durable, true);
+  assert.equal(ready.executorGateway.executionEnabled, false);
+  assert.deepEqual(checkpointProbeCalls, ['checkpoint']);
+  assert.deepEqual(executorProbeCalls, ['executor-jobs']);
+});
+
+test('LangGraph runtime rejects execution-enabled and unsupported workflows', async () => {
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: new MemorySaver(),
+  });
+
+  await assert.rejects(
+    runtime.start(runSpec({
+      runId: 'run-active',
+      policy: { executionMode: 'active', sideEffectsAllowed: true },
+    })),
+    (error) => error.code === 'WORKFLOW_OBSERVE_ONLY_REQUIRED',
+  );
+  await assert.rejects(
+    runtime.start(runSpec({
+      runId: 'run-unsupported',
+      workflow: { name: 'research-v1', version: 1 },
+    })),
+    (error) => error.code === 'WORKFLOW_NOT_SUPPORTED' && error.status === 422,
+  );
+});
+
+test('LangGraph runtime derives a bounded opaque Executor Job id for long run ids', async () => {
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: new MemorySaver(),
+  });
+  const state = await runtime.start(runSpec({
+    runId: 'r'.repeat(128),
+    requestId: 'request-long-run-id',
+  }));
+  assert.match(state.plan.executorJob.id, /^run_[a-f0-9]{64}:executor-preview$/);
+  assert.ok(state.plan.executorJob.id.length <= 128);
+  assert.equal((await runtime.getExecutorJob(state.plan.executorJob.id)).status, 'blocked');
+});
+
+test('LangGraph active workflow waits on a leased Executor Job and converges terminal state', async () => {
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: new MemorySaver(),
+    executionEnabled: true,
+    enabledExecutors: ['goosed'],
+  });
+  const state = await runtime.start({
+    runId: 'run-active-1',
+    requestId: 'request-active-1',
+    workflow: { name: 'code-run-v1', version: 1 },
+    subject: { tenantId: 'tenant-1', userId: 'user-1' },
+    input: {
+      instruction: 'Run a controlled canary',
+      executor: 'goosed',
+      workspaceRef: { kind: 'workspace-alias', id: 'canary' },
+    },
+    policy: {
+      executionMode: 'active',
+      sideEffectsAllowed: true,
+      networkAllowed: false,
+    },
+  });
+  assert.equal(state.status, 'waiting');
+  assert.equal(state.phase, 'executor_queued');
+  assert.equal(state.plan.executorJob.status, 'queued');
+
+  const claim = await runtime.claimExecutorJob({
+    workerId: 'worker-1',
+    executors: ['goosed'],
+  });
+  await runtime.startExecutorJob(claim.job.jobId, { leaseToken: claim.leaseToken });
+  await runtime.completeExecutorJob(claim.job.jobId, {
+    leaseToken: claim.leaseToken,
+    result: {
+      summary: 'canary complete',
+      artifactRefs: [{ kind: 'canary-result', id: 'result-1' }],
+    },
+  });
+
+  const completed = await runtime.getState('run-active-1');
+  assert.equal(completed.status, 'succeeded');
+  assert.equal(completed.result.executed, true);
+  assert.deepEqual(
+    completed.result.executorJob.result.artifactRefs,
+    [{ kind: 'canary-result', id: 'result-1' }],
+  );
+  assert.deepEqual(
+    (await runtime.listEvents('run-active-1')).events.map((event) => event.type),
+    [
+      'workflow_validated',
+      'workflow_planned',
+      'workflow_executor_queued',
+      'workflow_completed',
+    ],
+  );
+});
diff --git a/services/orchestrator/server.mjs b/services/orchestrator/server.mjs
new file mode 100644
index 0000000..51cb36a
--- /dev/null
+++ b/services/orchestrator/server.mjs
@@ -0,0 +1,135 @@
+import { pathToFileURL } from 'node:url';
+import { createOrchestratorApp } from './app.mjs';
+import { createOrchestratorCheckpoint } from './checkpoint.mjs';
+import { createExecutorJobPersistence } from './executor-job-store.mjs';
+import { createLangGraphOrchestratorRuntime } from './runtime.mjs';
+
+function positivePort(value, fallback = 8093) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) return fallback;
+  return parsed;
+}
+
+function envFlag(value, fallback = false) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!normalized) return fallback;
+  return ['1', 'true', 'yes', 'on'].includes(normalized);
+}
+
+function csvList(value) {
+  return [...new Set(
+    String(value ?? '')
+      .split(',')
+      .map((item) => item.trim().toLowerCase())
+      .filter(Boolean),
+  )];
+}
+
+export async function startOrchestratorServer({
+  env = process.env,
+  logger = console,
+} = {}) {
+  const checkpoint = await createOrchestratorCheckpoint({
+    mode: env.MEMIND_ORCHESTRATOR_CHECKPOINT_MODE,
+    connectionString: env.MEMIND_ORCHESTRATOR_DATABASE_URL,
+    schema: env.MEMIND_ORCHESTRATOR_DATABASE_SCHEMA,
+  });
+  let executorJobs;
+  try {
+    executorJobs = await createExecutorJobPersistence({
+      mode: env.MEMIND_ORCHESTRATOR_CHECKPOINT_MODE,
+      connectionString: env.MEMIND_ORCHESTRATOR_DATABASE_URL,
+      schema: env.MEMIND_ORCHESTRATOR_DATABASE_SCHEMA,
+    });
+  } catch (error) {
+    await Promise.allSettled([checkpoint.close()]);
+    throw error;
+  }
+  const runtime = createLangGraphOrchestratorRuntime({
+    checkpointer: checkpoint.checkpointer,
+    checkpointKind: checkpoint.kind,
+    durable: checkpoint.durable,
+    checkpointProbe: checkpoint.probe,
+    executorJobStore: executorJobs.store,
+    executorJobProbe: executorJobs.probe,
+    executionEnabled: envFlag(env.MEMIND_ORCHESTRATOR_EXECUTION_ENABLED, false),
+    enabledExecutors: csvList(env.MEMIND_ORCHESTRATOR_ENABLED_EXECUTORS),
+    admissionConfig: {
+      tenantAllowlist: csvList(env.MEMIND_ORCHESTRATOR_TENANT_ALLOWLIST),
+      userAllowlist: csvList(env.MEMIND_ORCHESTRATOR_USER_ALLOWLIST),
+      workspaceKindAllowlist: csvList(
+        env.MEMIND_ORCHESTRATOR_WORKSPACE_KIND_ALLOWLIST ?? 'workspace-alias',
+      ),
+      maxGlobalActive: env.MEMIND_ORCHESTRATOR_MAX_GLOBAL_ACTIVE,
+      maxTenantActive: env.MEMIND_ORCHESTRATOR_MAX_TENANT_ACTIVE,
+      maxUserActive: env.MEMIND_ORCHESTRATOR_MAX_USER_ACTIVE,
+      maxTenantPerMinute: env.MEMIND_ORCHESTRATOR_MAX_TENANT_PER_MINUTE,
+      maxUserPerMinute: env.MEMIND_ORCHESTRATOR_MAX_USER_PER_MINUTE,
+    },
+  });
+  const app = createOrchestratorApp({
+    runtime,
+    serviceToken: env.MEMIND_ORCHESTRATOR_SERVICE_TOKEN,
+    workerToken: env.MEMIND_ORCHESTRATOR_WORKER_TOKEN,
+  });
+  const host = String(env.MEMIND_ORCHESTRATOR_HOST ?? '127.0.0.1').trim() || '127.0.0.1';
+  const port = positivePort(env.MEMIND_ORCHESTRATOR_PORT, 8093);
+  let server;
+  try {
+    server = await new Promise((resolve, reject) => {
+      const listening = app.listen(port, host, () => resolve(listening));
+      listening.once('error', reject);
+    });
+  } catch (error) {
+    await Promise.allSettled([executorJobs.close(), checkpoint.close()]);
+    throw error;
+  }
+  logger.log(`[orchestrator] listening on http://${host}:${port} (${checkpoint.kind})`);
+
+  async function close() {
+    let serverCloseError = null;
+    try {
+      await new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+      });
+    } catch (error) {
+      serverCloseError = error;
+    }
+    const results = await Promise.allSettled([
+      executorJobs.close(),
+      checkpoint.close(),
+    ]);
+    if (serverCloseError) throw serverCloseError;
+    const failed = results.find((result) => result.status === 'rejected');
+    if (failed) throw failed.reason;
+  }
+
+  return {
+    app,
+    server,
+    runtime,
+    checkpoint,
+    executorJobs,
+    close,
+  };
+}
+
+const isEntrypoint = process.argv[1]
+  && import.meta.url === pathToFileURL(process.argv[1]).href;
+
+if (isEntrypoint) {
+  const running = await startOrchestratorServer();
+  const shutdown = async (signal) => {
+    console.log(`[orchestrator] received ${signal}, shutting down`);
+    await running.close();
+    process.exit(0);
+  };
+  process.once('SIGINT', () => void shutdown('SIGINT'));
+  process.once('SIGTERM', () => void shutdown('SIGTERM'));
+}
+
+export const orchestratorServerInternals = {
+  csvList,
+  envFlag,
+  positivePort,
+};
diff --git a/services/orchestrator/server.test.mjs b/services/orchestrator/server.test.mjs
new file mode 100644
index 0000000..93d0fde
--- /dev/null
+++ b/services/orchestrator/server.test.mjs
@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import net from 'node:net';
+import test from 'node:test';
+import { startOrchestratorServer } from './server.mjs';
+
+async function reservePort() {
+  const server = net.createServer();
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  const { port } = server.address();
+  await new Promise((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+  });
+  return port;
+}
+
+test('orchestrator server owns checkpoint and Executor Job Store lifecycle', async (t) => {
+  const port = await reservePort();
+  const running = await startOrchestratorServer({
+    env: {
+      MEMIND_ORCHESTRATOR_CHECKPOINT_MODE: 'memory',
+      MEMIND_ORCHESTRATOR_HOST: '127.0.0.1',
+      MEMIND_ORCHESTRATOR_PORT: String(port),
+    },
+    logger: { log() {} },
+  });
+  let closed = false;
+  t.after(async () => {
+    if (!closed) await running.close();
+  });
+
+  assert.equal(running.checkpoint.kind, 'memory');
+  assert.equal(running.executorJobs.kind, 'memory');
+  const response = await fetch(`http://127.0.0.1:${port}/ready`);
+  assert.equal(response.status, 200);
+  const ready = await response.json();
+  assert.equal(ready.ready, true);
+  assert.deepEqual(ready.executorGateway.store, {
+    kind: 'memory',
+    durable: false,
+  });
+
+  await running.close();
+  closed = true;
+  assert.equal(running.server.listening, false);
+});
diff --git a/services/orchestrator/shadow-observer.mjs b/services/orchestrator/shadow-observer.mjs
new file mode 100644
index 0000000..5eeb376
--- /dev/null
+++ b/services/orchestrator/shadow-observer.mjs
@@ -0,0 +1,132 @@
+import {
+  WORKFLOW_ENGINE,
+  normalizeRunSpec,
+} from './contracts.mjs';
+import { createRemoteWorkflowEngine } from './engine-registry.mjs';
+
+const MAX_INSTRUCTION_CHARACTERS = 16_000;
+
+function extractMessageText(message) {
+  if (typeof message === 'string') return message;
+  if (!message || typeof message !== 'object') return '';
+  if (typeof message.content === 'string') return message.content;
+  if (!Array.isArray(message.content)) return '';
+  return message.content
+    .filter((part) => part?.type === 'text')
+    .map((part) => String(part.text ?? ''))
+    .join('\n');
+}
+
+function safeError(error) {
+  return {
+    code: String(error?.code ?? 'WORKFLOW_SHADOW_FAILED').slice(0, 128),
+    message: String(error instanceof Error ? error.message : error).slice(0, 1000),
+  };
+}
+
+export function createWorkflowShadowObserver({
+  configService,
+  serviceToken = process.env.MEMIND_ORCHESTRATOR_SERVICE_TOKEN,
+  fetchImpl = globalThis.fetch,
+  logger = console,
+} = {}) {
+  if (!configService?.selectEngine || !configService?.getRuntimeState) {
+    throw new Error('Workflow shadow observer requires orchestrator config service');
+  }
+
+  return async function observeWorkflowRun({
+    runId,
+    requestId,
+    userId,
+    sessionId = null,
+    workflowName = 'code-run-v1',
+    userMessage,
+    taskType = null,
+  } = {}) {
+    const selection = await configService.selectEngine({
+      runId,
+      requestId,
+      userId,
+      workflowName,
+    });
+    const planningMode = ['shadow', 'canary', 'active'].includes(selection.mode);
+    const executionPlan = planningMode
+      && (selection.dryRun || ['canary', 'active'].includes(selection.mode)) ? {
+      version: 'workflow-execution-decision-v1',
+      candidateEngine: selection.candidateEngine ?? WORKFLOW_ENGINE.NATIVE,
+      effectiveEngine: selection.engine ?? WORKFLOW_ENGINE.NATIVE,
+      fallbackEngine: selection.fallbackEngine ?? WORKFLOW_ENGINE.NATIVE,
+      reason: selection.reason,
+      candidateReason: selection.candidateReason ?? null,
+      configVersion: selection.configVersion ?? null,
+      bucket: selection.bucket ?? null,
+      taskType,
+      dryRun: true,
+      handoffAllowed: false,
+    } : null;
+    if (selection.shadowEngine !== WORKFLOW_ENGINE.LANGGRAPH) {
+      return {
+        observed: false,
+        reason: selection.reason,
+        mode: selection.mode,
+        executionPlan,
+      };
+    }
+
+    const state = await configService.getRuntimeState();
+    const engine = createRemoteWorkflowEngine({
+      id: WORKFLOW_ENGINE.LANGGRAPH,
+      baseUrl: state.config.serviceUrl,
+      serviceToken,
+      timeoutMs: state.config.requestTimeoutMs,
+      fetchImpl,
+    });
+    const instruction = extractMessageText(userMessage).slice(0, MAX_INSTRUCTION_CHARACTERS);
+    const spec = normalizeRunSpec({
+      runId,
+      requestId,
+      workflow: { name: workflowName, version: 1 },
+      subject: { userId },
+      input: {
+        instruction,
+        taskType,
+        toolMode: 'code',
+        sessionRef: sessionId
+          ? { kind: 'goose-session', id: String(sessionId) }
+          : null,
+      },
+      policy: {
+        executionMode: 'observe-only',
+        sideEffectsAllowed: false,
+      },
+      metadata: {
+        source: 'memind-agent-run',
+        configVersion: selection.configVersion,
+      },
+    });
+    try {
+      const result = await engine.start(spec);
+      return {
+        observed: true,
+        engine: WORKFLOW_ENGINE.LANGGRAPH,
+        mode: selection.mode,
+        configVersion: selection.configVersion,
+        executionPlan,
+        shadowRun: result,
+      };
+    } catch (error) {
+      logger.warn('[orchestrator-shadow] observation failed:', safeError(error));
+      if (error && typeof error === 'object') {
+        error.executionPlan = executionPlan;
+        error.mode = selection.mode;
+      }
+      throw error;
+    }
+  };
+}
+
+export const workflowShadowObserverInternals = {
+  MAX_INSTRUCTION_CHARACTERS,
+  extractMessageText,
+  safeError,
+};
diff --git a/services/orchestrator/shadow-observer.test.mjs b/services/orchestrator/shadow-observer.test.mjs
new file mode 100644
index 0000000..548a641
--- /dev/null
+++ b/services/orchestrator/shadow-observer.test.mjs
@@ -0,0 +1,180 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createWorkflowShadowObserver } from './shadow-observer.mjs';
+
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+test('shadow observer skips without creating a remote client when mode does not select shadow', async () => {
+  let fetchCalls = 0;
+  const observer = createWorkflowShadowObserver({
+    configService: {
+      async selectEngine() {
+        return { shadowEngine: null, reason: 'mode_off', mode: 'off' };
+      },
+      async getRuntimeState() {
+        throw new Error('must not load runtime config');
+      },
+    },
+    fetchImpl: async () => {
+      fetchCalls += 1;
+      return jsonResponse({});
+    },
+  });
+
+  const result = await observer({
+    runId: 'run-1',
+    requestId: 'request-1',
+    userId: 'user-1',
+  });
+  assert.deepEqual(result, {
+    observed: false,
+    reason: 'mode_off',
+    mode: 'off',
+    executionPlan: null,
+  });
+  assert.equal(fetchCalls, 0);
+});
+
+test('shadow boundary returns an auditable dry-run plan without calling LangGraph', async () => {
+  let fetchCalls = 0;
+  const observer = createWorkflowShadowObserver({
+    configService: {
+      async selectEngine() {
+        return {
+          engine: 'native',
+          candidateEngine: 'langgraph',
+          shadowEngine: null,
+          fallbackEngine: 'native',
+          reason: 'execution_gate_disabled',
+          candidateReason: 'user_allowlist',
+          mode: 'canary',
+          configVersion: 8,
+          bucket: 42,
+          dryRun: true,
+        };
+      },
+      async getRuntimeState() {
+        throw new Error('must not load runtime config');
+      },
+    },
+    fetchImpl: async () => {
+      fetchCalls += 1;
+      return jsonResponse({});
+    },
+  });
+
+  const result = await observer({
+    runId: 'run-dry-1',
+    requestId: 'request-dry-1',
+    userId: 'user-1',
+    taskType: 'repo_refactor',
+  });
+  assert.equal(result.observed, false);
+  assert.deepEqual(result.executionPlan, {
+    version: 'workflow-execution-decision-v1',
+    candidateEngine: 'langgraph',
+    effectiveEngine: 'native',
+    fallbackEngine: 'native',
+    reason: 'execution_gate_disabled',
+    candidateReason: 'user_allowlist',
+    configVersion: 8,
+    bucket: 42,
+    taskType: 'repo_refactor',
+    dryRun: true,
+    handoffAllowed: false,
+  });
+  assert.equal(fetchCalls, 0);
+});
+
+test('shadow boundary records non-selected canary decisions for a complete rate denominator', async () => {
+  const observer = createWorkflowShadowObserver({
+    configService: {
+      async selectEngine() {
+        return {
+          engine: 'native',
+          candidateEngine: 'native',
+          shadowEngine: null,
+          fallbackEngine: 'native',
+          reason: 'canary_not_selected',
+          candidateReason: null,
+          mode: 'canary',
+          configVersion: 9,
+          bucket: 88,
+          dryRun: false,
+        };
+      },
+      async getRuntimeState() {
+        throw new Error('must not load runtime config');
+      },
+    },
+  });
+
+  const result = await observer({
+    runId: 'run-native-1',
+    requestId: 'request-native-1',
+    userId: 'user-1',
+    taskType: 'code_analysis',
+  });
+  assert.equal(result.observed, false);
+  assert.equal(result.executionPlan.dryRun, true);
+  assert.equal(result.executionPlan.candidateEngine, 'native');
+  assert.equal(result.executionPlan.reason, 'canary_not_selected');
+  assert.equal(result.executionPlan.taskType, 'code_analysis');
+});
+
+test('shadow observer sends a bounded observe-only RunSpec to LangGraph service', async () => {
+  let capturedUrl = null;
+  let capturedInit = null;
+  const observer = createWorkflowShadowObserver({
+    configService: {
+      async selectEngine() {
+        return {
+          shadowEngine: 'langgraph',
+          reason: 'shadow',
+          mode: 'shadow',
+          configVersion: 7,
+        };
+      },
+      async getRuntimeState() {
+        return {
+          config: {
+            serviceUrl: 'http://orchestrator.internal:8093',
+            requestTimeoutMs: 1200,
+          },
+        };
+      },
+    },
+    serviceToken: 'internal-token',
+    fetchImpl: async (url, init) => {
+      capturedUrl = url;
+      capturedInit = init;
+      return jsonResponse({ runId: 'run-2', status: 'succeeded' }, 202);
+    },
+  });
+
+  const result = await observer({
+    runId: 'run-2',
+    requestId: 'request-2',
+    userId: 'user-2',
+    sessionId: 'session-2',
+    taskType: 'code-change',
+    userMessage: {
+      content: [{ type: 'text', text: 'Implement the service boundary' }],
+    },
+  });
+
+  assert.equal(result.observed, true);
+  assert.equal(capturedUrl, 'http://orchestrator.internal:8093/v1/runs');
+  assert.equal(capturedInit.headers.authorization, 'Bearer internal-token');
+  const body = JSON.parse(capturedInit.body);
+  assert.equal(body.version, 'orchestrator-run-v1');
+  assert.equal(body.policy.executionMode, 'observe-only');
+  assert.equal(body.policy.sideEffectsAllowed, false);
+  assert.deepEqual(body.input.sessionRef, { kind: 'goose-session', id: 'session-2' });
+  assert.equal(body.metadata.configVersion, 7);
+});
diff --git a/services/orchestrator/worker.mjs b/services/orchestrator/worker.mjs
new file mode 100644
index 0000000..7dd687a
--- /dev/null
+++ b/services/orchestrator/worker.mjs
@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import os from 'node:os';
+import { pathToFileURL } from 'node:url';
+import {
+  createAiderExecutorAdapter,
+  createGoosedExecutorAdapter,
+  createOpenHandsExecutorAdapter,
+} from './executor-adapters.mjs';
+import {
+  createExecutorWorkerClient,
+  createExecutorWorkerRuntime,
+  createWorkerAdapterRegistry,
+} from './executor-worker-runtime.mjs';
+
+function envFlag(value, fallback = false) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!normalized) return fallback;
+  return ['1', 'true', 'yes', 'on'].includes(normalized);
+}
+
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
+}
+
+function jsonObject(value, fallback = {}) {
+  try {
+    const parsed = JSON.parse(String(value ?? ''));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+export function createConfiguredWorker({ env = process.env, fetchImpl = null } = {}) {
+  const registry = createWorkerAdapterRegistry();
+  const workspaceAliases = jsonObject(env.MEMIND_EXECUTOR_WORKSPACE_ALIASES_JSON);
+  const allowedRoot = String(env.MEMIND_EXECUTOR_WORKSPACE_ROOT ?? '').trim();
+  const goosedUrl = String(env.MEMIND_EXECUTOR_GOOSED_URL ?? '').trim();
+  if (goosedUrl) {
+    registry.register(createGoosedExecutorAdapter({
+      baseUrl: goosedUrl,
+      secret: env.MEMIND_EXECUTOR_GOOSED_TOKEN,
+      ...(fetchImpl ? { fetchImpl } : {}),
+      allowRemote: envFlag(env.MEMIND_EXECUTOR_ALLOW_REMOTE_GOOSED, false),
+      tlsInsecure: envFlag(env.MEMIND_EXECUTOR_GOOSED_TLS_INSECURE, false),
+      workspaceResolver: async (reference) => workspaceAliases[reference?.id] ?? null,
+    }));
+  }
+  if (env.MEMIND_EXECUTOR_AIDER_COMMAND && allowedRoot) {
+    registry.register(createAiderExecutorAdapter({
+      command: env.MEMIND_EXECUTOR_AIDER_COMMAND,
+      allowedRoot,
+      workspaceAliases,
+    }));
+  }
+  if (env.MEMIND_EXECUTOR_OPENHANDS_COMMAND && allowedRoot) {
+    registry.register(createOpenHandsExecutorAdapter({
+      command: env.MEMIND_EXECUTOR_OPENHANDS_COMMAND,
+      allowedRoot,
+      workspaceAliases,
+    }));
+  }
+  if (!registry.ids().length) {
+    throw new Error('Executor worker has no configured adapters');
+  }
+  const client = createExecutorWorkerClient({
+    baseUrl: env.MEMIND_ORCHESTRATOR_URL ?? 'http://127.0.0.1:8093',
+    serviceToken: env.MEMIND_ORCHESTRATOR_SERVICE_TOKEN,
+    workerToken: env.MEMIND_ORCHESTRATOR_WORKER_TOKEN,
+    fetchImpl: fetchImpl ?? globalThis.fetch,
+  });
+  return createExecutorWorkerRuntime({
+    client,
+    registry,
+    workerId: env.MEMIND_EXECUTOR_WORKER_ID ?? `${os.hostname()}-${process.pid}`,
+    heartbeatMs: positiveInteger(env.MEMIND_EXECUTOR_HEARTBEAT_MS, 10_000),
+    leaseDurationMs: positiveInteger(env.MEMIND_EXECUTOR_LEASE_MS, 30_000),
+  });
+}
+
+async function main() {
+  const worker = createConfiguredWorker();
+  const once = process.argv.includes('--once');
+  const recover = process.argv.includes('--recover-expired');
+  if (recover) {
+    console.log(JSON.stringify(await worker.recoverExpired(), null, 2));
+    return;
+  }
+  if (once) {
+    console.log(JSON.stringify(await worker.runOnce(), null, 2));
+    return;
+  }
+  let stopping = false;
+  const stop = async () => {
+    if (stopping) return;
+    stopping = true;
+    await worker.stop();
+  };
+  process.once('SIGINT', () => void stop());
+  process.once('SIGTERM', () => void stop());
+  const pollMs = positiveInteger(process.env.MEMIND_EXECUTOR_POLL_MS, 1000);
+  console.log(JSON.stringify({ ok: true, ...worker.status() }));
+  while (!stopping) {
+    await worker.runOnce();
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+}
+
+const isEntrypoint = process.argv[1]
+  && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isEntrypoint) {
+  await main();
+}
+
+export const executorWorkerEntrypointInternals = {
+  envFlag,
+  jsonObject,
+  positiveInteger,
+};
diff --git a/session-reconcile.mjs b/session-reconcile.mjs
index 4034f97..d75e432 100644
--- a/session-reconcile.mjs
+++ b/session-reconcile.mjs
@@ -17,9 +17,38 @@ export function extensionToolsKey(config) {
   return [...tools].sort().join('\0');
 }
 
+function extensionExecutionConfig(config) {
+  const type = String(config?.type ?? '');
+  const executionConfig = {
+    name: extensionName(config),
+    type,
+    availableTools: extensionToolsKey(config),
+  };
+
+  // Platform/builtin extensions are identified by their name and tool grant.
+  // Stdio extensions also carry the executable, arguments, and environment that
+  // define their filesystem and service boundaries. Ignoring those fields lets
+  // a resumed session keep a stale SANDBOX_ROOT after the Portal runtime moves.
+  if (type === 'stdio') {
+    executionConfig.cmd = String(config?.cmd ?? '');
+    executionConfig.args = Array.isArray(config?.args)
+      ? config.args.map((item) => String(item))
+      : [];
+    executionConfig.envs = Object.fromEntries(
+      Object.entries(config?.envs ?? {})
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => [key, String(value)]),
+    );
+  }
+
+  return executionConfig;
+}
+
 export function extensionConfigsMatch(sessionExt, desiredConfig) {
-  if (extensionName(sessionExt) !== extensionName(desiredConfig)) return false;
-  return extensionToolsKey(sessionExt) === extensionToolsKey(desiredConfig);
+  return (
+    JSON.stringify(extensionExecutionConfig(sessionExt))
+    === JSON.stringify(extensionExecutionConfig(desiredConfig))
+  );
 }
 
 export function extensionsNeedingRefresh(currentExtensions, desiredExtensions) {
@@ -54,6 +83,64 @@ export function extensionsNeedingRefresh(currentExtensions, desiredExtensions) {
   return { toRemove, toAdd };
 }
 
+export function extensionPolicyViolations(currentExtensions, desiredExtensions) {
+  const current = currentExtensions ?? [];
+  const desired = desiredExtensions ?? [];
+  const desiredByName = new Map();
+  for (const config of desired) {
+    const name = extensionName(config);
+    if (name && !desiredByName.has(name)) desiredByName.set(name, config);
+  }
+
+  const unexpected = [];
+  const duplicate = [];
+  const currentByName = new Map();
+  for (const ext of current) {
+    const name = extensionName(ext);
+    if (!name) continue;
+    if (!desiredByName.has(name)) unexpected.push(name);
+    const configs = currentByName.get(name) ?? [];
+    configs.push(ext);
+    currentByName.set(name, configs);
+    if (configs.length === 2) duplicate.push(name);
+  }
+
+  const missingOrMismatched = [];
+  for (const [name, desiredConfig] of desiredByName) {
+    const configs = currentByName.get(name) ?? [];
+    if (
+      configs.length !== 1
+      || !extensionConfigsMatch(configs[0], desiredConfig)
+    ) {
+      missingOrMismatched.push(name);
+    }
+  }
+
+  return {
+    unexpected: [...new Set(unexpected)].sort(),
+    duplicate: [...new Set(duplicate)].sort(),
+    missingOrMismatched: [...new Set(missingOrMismatched)].sort(),
+  };
+}
+
+function assertExtensionPolicyApplied(currentExtensions, desiredExtensions, sessionId) {
+  const violations = extensionPolicyViolations(currentExtensions, desiredExtensions);
+  if (
+    violations.unexpected.length === 0
+    && violations.duplicate.length === 0
+    && violations.missingOrMismatched.length === 0
+  ) {
+    return;
+  }
+
+  const err = new Error(
+    `session ${sessionId} extension policy mismatch: ${JSON.stringify(violations)}`,
+  );
+  err.code = 'SESSION_EXTENSION_POLICY_MISMATCH';
+  err.retryable = false;
+  throw err;
+}
+
 function samePath(left, right) {
   if (!left || !right) return false;
   return path.resolve(left) === path.resolve(right);
@@ -175,6 +262,18 @@ export async function reconcileAgentSession(
     );
   }
 
+  // Fail closed: the upstream may acknowledge add/remove/restart calls without
+  // persisting their effective session configuration. Never let the agent run
+  // with default or stale tools after a restricted policy was requested.
+  const effectiveExtensions = needsRestart
+    ? (
+        (
+          await readJson(await apiFetch(`/sessions/${sessionId}/extensions`))
+        )?.extensions ?? []
+      )
+    : refreshed;
+  assertExtensionPolicyApplied(effectiveExtensions, desired, sessionId);
+
   const sandboxText = sandboxConstraints?.trim()
     ? buildSandboxSessionConstraints({
         baseConstraints: sandboxConstraints,
diff --git a/session-reconcile.test.mjs b/session-reconcile.test.mjs
index 844df75..e32c913 100644
--- a/session-reconcile.test.mjs
+++ b/session-reconcile.test.mjs
@@ -2,6 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
   extensionConfigsMatch,
+  extensionPolicyViolations,
   extensionsNeedingRefresh,
   reconcileAgentSession,
 } from './session-reconcile.mjs';
@@ -29,6 +30,69 @@ test('extensionConfigsMatch compares available_tools', () => {
   );
 });
 
+test('extensionConfigsMatch compares stdio runtime roots and ignores env key order', () => {
+  const stale = {
+    type: 'stdio',
+    name: 'sandbox-fs',
+    cmd: '/usr/local/bin/node',
+    args: ['/opt/portal/mindspace-sandbox-mcp.mjs', '/private/tmp/stale/MindSpace/user-1'],
+    envs: {
+      SANDBOX_ROOT: '/private/tmp/stale/MindSpace/user-1',
+      PRIVATE_DATA_USER_ID: 'user-1',
+    },
+    available_tools: ['write_file', 'private_data_bind_workspace_page'],
+  };
+  const desired = {
+    type: 'stdio',
+    name: 'sandbox-fs',
+    cmd: '/usr/local/bin/node',
+    args: ['/opt/portal/mindspace-sandbox-mcp.mjs', '/Users/john/Project/Memind/MindSpace/user-1'],
+    envs: {
+      PRIVATE_DATA_USER_ID: 'user-1',
+      SANDBOX_ROOT: '/Users/john/Project/Memind/MindSpace/user-1',
+    },
+    available_tools: ['private_data_bind_workspace_page', 'write_file'],
+  };
+
+  assert.equal(extensionConfigsMatch(stale, desired), false);
+  assert.equal(
+    extensionConfigsMatch(
+      desired,
+      {
+        ...desired,
+        envs: {
+          SANDBOX_ROOT: desired.envs.SANDBOX_ROOT,
+          PRIVATE_DATA_USER_ID: desired.envs.PRIVATE_DATA_USER_ID,
+        },
+      },
+    ),
+    true,
+  );
+});
+
+test('extensionsNeedingRefresh replaces stdio extension when its sandbox root changed', () => {
+  const current = [{
+    type: 'stdio',
+    name: 'sandbox-fs',
+    cmd: 'node',
+    args: ['mindspace-sandbox-mcp.mjs', '/stale/user-1'],
+    envs: { SANDBOX_ROOT: '/stale/user-1' },
+    available_tools: ['write_file'],
+  }];
+  const desired = [{
+    type: 'stdio',
+    name: 'sandbox-fs',
+    cmd: 'node',
+    args: ['mindspace-sandbox-mcp.mjs', '/current/user-1'],
+    envs: { SANDBOX_ROOT: '/current/user-1' },
+    available_tools: ['write_file'],
+  }];
+
+  const { toRemove, toAdd } = extensionsNeedingRefresh(current, desired);
+  assert.deepEqual(toRemove, ['sandbox-fs']);
+  assert.deepEqual(toAdd, desired);
+});
+
 test('extensionsNeedingRefresh upgrades stale developer tools', () => {
   const current = [
     { name: 'developer', available_tools: ['write', 'edit'] },
@@ -58,6 +122,27 @@ test('extensionsNeedingRefresh adds missing extensions', () => {
   assert.equal(toAdd[0].name, 'summon');
 });
 
+test('extensionPolicyViolations reports unexpected, duplicate, and mismatched extensions', () => {
+  assert.deepEqual(
+    extensionPolicyViolations(
+      [
+        { name: 'developer', available_tools: ['write'] },
+        { name: 'skills', available_tools: [] },
+        { name: 'skills', available_tools: [] },
+      ],
+      [
+        { name: 'skills', available_tools: [] },
+        { name: 'sandbox-fs', available_tools: ['write_file'] },
+      ],
+    ),
+    {
+      unexpected: ['developer'],
+      duplicate: ['skills'],
+      missingOrMismatched: ['sandbox-fs', 'skills'],
+    },
+  );
+});
+
 test('reconcileAgentSession tolerates invalid working directory during resume sync without restart', async () => {
   const calls = [];
   const apiFetch = async (pathname) => {
@@ -152,6 +237,7 @@ test('reconcileAgentSession skips restart when extensions already match', async
 
 test('reconcileAgentSession restarts after adding missing extensions', async () => {
   const calls = [];
+  let extensionReads = 0;
   const apiFetch = async (pathname) => {
     calls.push(pathname);
     if (pathname === '/sessions/session-1') {
@@ -161,9 +247,16 @@ test('reconcileAgentSession restarts after adding missing extensions', async ()
       };
     }
     if (pathname === '/sessions/session-1/extensions') {
+      extensionReads += 1;
       return {
         ok: true,
-        text: async () => JSON.stringify({ extensions: [] }),
+        text: async () =>
+          JSON.stringify({
+            extensions:
+              extensionReads === 1
+                ? []
+                : [{ name: 'skills', available_tools: [] }],
+          }),
       };
     }
     if (pathname === '/agent/add_extension' || pathname === '/agent/restart') {
@@ -187,7 +280,49 @@ test('reconcileAgentSession restarts after adding missing extensions', async ()
     '/sessions/session-1/extensions',
     '/agent/add_extension',
     '/agent/restart',
+    '/sessions/session-1/extensions',
     '/agent/harness_remember',
     '/agent/harness_bootstrap',
   ]);
 });
+
+test('reconcileAgentSession fails closed when restart does not apply the requested policy', async () => {
+  const apiFetch = async (pathname) => {
+    if (pathname === '/sessions/session-1') {
+      return {
+        ok: true,
+        text: async () => JSON.stringify({ working_dir: '/valid/workspace' }),
+      };
+    }
+    if (pathname === '/sessions/session-1/extensions') {
+      return {
+        ok: true,
+        text: async () =>
+          JSON.stringify({
+            extensions: [{ name: 'developer', available_tools: ['shell'] }],
+          }),
+      };
+    }
+    if (
+      pathname === '/agent/remove_extension'
+      || pathname === '/agent/add_extension'
+      || pathname === '/agent/restart'
+    ) {
+      return {
+        ok: true,
+        text: async () => JSON.stringify({ ok: true }),
+      };
+    }
+    throw new Error(`unexpected path: ${pathname}`);
+  };
+
+  await assert.rejects(
+    reconcileAgentSession(apiFetch, 'session-1', {
+      workingDir: '/valid/workspace',
+      sessionPolicy: { extensionOverrides: [{ name: 'skills', available_tools: [] }] },
+    }),
+    (err) =>
+      err?.code === 'SESSION_EXTENSION_POLICY_MISMATCH'
+      && err?.retryable === false,
+  );
+});
diff --git a/session-runtime-lifecycle.mjs b/session-runtime-lifecycle.mjs
new file mode 100644
index 0000000..b0f1fce
--- /dev/null
+++ b/session-runtime-lifecycle.mjs
@@ -0,0 +1,78 @@
+function extensionName(config) {
+  return String(config?.name ?? '').trim();
+}
+
+async function readJson(response) {
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(text || `upstream ${response.status}`);
+  }
+  return text ? JSON.parse(text) : null;
+}
+
+export function sessionStdioExtensionNames(extensions) {
+  return [
+    ...new Set(
+      (extensions ?? [])
+        .filter((extension) => String(extension?.type ?? '').trim() === 'stdio')
+        .map(extensionName)
+        .filter(Boolean),
+    ),
+  ].sort();
+}
+
+export async function cancelSessionActiveRequest(apiFetch, sessionId, requestId) {
+  const normalizedSessionId = String(sessionId ?? '').trim();
+  const normalizedRequestId = String(requestId ?? '').trim();
+  if (!normalizedSessionId || !normalizedRequestId) {
+    return { cancelled: false, skipped: true };
+  }
+
+  const response = await apiFetch(
+    `/sessions/${encodeURIComponent(normalizedSessionId)}/cancel`,
+    {
+      method: 'POST',
+      body: JSON.stringify({ request_id: normalizedRequestId }),
+    },
+  );
+  const text = await response.text();
+  if (
+    !response.ok
+    && ![404, 409, 410].includes(Number(response.status))
+    && !/(?:not found|no active|already (?:finished|cancelled))/i.test(text)
+  ) {
+    throw new Error(text || `upstream ${response.status}`);
+  }
+  return {
+    cancelled: response.ok,
+    skipped: !response.ok,
+  };
+}
+
+/**
+ * Stop per-session stdio MCP children while preserving the Goose conversation.
+ * Session reconciliation restores the required extensions before the next turn.
+ */
+export async function quiesceSessionStdioExtensions(apiFetch, sessionId) {
+  const normalizedSessionId = String(sessionId ?? '').trim();
+  if (!normalizedSessionId) return { removed: [], skipped: true };
+
+  const payload = await readJson(
+    await apiFetch(`/sessions/${encodeURIComponent(normalizedSessionId)}/extensions`),
+  );
+  const names = sessionStdioExtensionNames(payload?.extensions);
+  const removed = [];
+  for (const name of names) {
+    await readJson(
+      await apiFetch('/agent/remove_extension', {
+        method: 'POST',
+        body: JSON.stringify({
+          session_id: normalizedSessionId,
+          name,
+        }),
+      }),
+    );
+    removed.push(name);
+  }
+  return { removed, skipped: names.length === 0 };
+}
diff --git a/session-runtime-lifecycle.test.mjs b/session-runtime-lifecycle.test.mjs
new file mode 100644
index 0000000..4549361
--- /dev/null
+++ b/session-runtime-lifecycle.test.mjs
@@ -0,0 +1,118 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  cancelSessionActiveRequest,
+  quiesceSessionStdioExtensions,
+  sessionStdioExtensionNames,
+} from './session-runtime-lifecycle.mjs';
+
+function jsonResponse(payload, { ok = true, status = 200 } = {}) {
+  return {
+    ok,
+    status,
+    text: async () => JSON.stringify(payload),
+  };
+}
+
+test('sessionStdioExtensionNames returns unique stdio extensions only', () => {
+  assert.deepEqual(
+    sessionStdioExtensionNames([
+      { name: 'sandbox-fs', type: 'stdio' },
+      { name: 'skills', type: 'platform' },
+      { name: 'sandbox-fs', type: 'stdio' },
+      { name: 'tkmind-search', type: 'stdio' },
+    ]),
+    ['sandbox-fs', 'tkmind-search'],
+  );
+});
+
+test('cancelSessionActiveRequest cancels an in-flight request without deleting its session', async () => {
+  const calls = [];
+  const result = await cancelSessionActiveRequest(
+    async (pathname, init) => {
+      calls.push({ pathname, init });
+      return {
+        ok: true,
+        status: 204,
+        text: async () => '',
+      };
+    },
+    'session-1',
+    'request-1',
+  );
+
+  assert.deepEqual(result, { cancelled: true, skipped: false });
+  assert.deepEqual(calls.map(({ pathname }) => pathname), ['/sessions/session-1/cancel']);
+  assert.deepEqual(JSON.parse(calls[0].init.body), { request_id: 'request-1' });
+  assert.equal(calls.some(({ pathname }) => pathname.includes('delete')), false);
+});
+
+test('cancelSessionActiveRequest tolerates a request that already finished', async () => {
+  const result = await cancelSessionActiveRequest(
+    async () => ({
+      ok: false,
+      status: 409,
+      text: async () => 'no active request',
+    }),
+    'session-1',
+    'request-1',
+  );
+  assert.deepEqual(result, { cancelled: false, skipped: true });
+});
+
+test('quiesceSessionStdioExtensions removes stdio children without deleting session', async () => {
+  const calls = [];
+  const apiFetch = async (pathname, init = {}) => {
+    calls.push({ pathname, init });
+    if (pathname === '/sessions/session-1/extensions') {
+      return jsonResponse({
+        extensions: [
+          { name: 'sandbox-fs', type: 'stdio' },
+          { name: 'skills', type: 'platform' },
+          { name: 'tkmind-search', type: 'stdio' },
+        ],
+      });
+    }
+    if (pathname === '/agent/remove_extension') {
+      return jsonResponse({ ok: true });
+    }
+    throw new Error(`unexpected path: ${pathname}`);
+  };
+
+  const result = await quiesceSessionStdioExtensions(apiFetch, 'session-1');
+
+  assert.deepEqual(result, {
+    removed: ['sandbox-fs', 'tkmind-search'],
+    skipped: false,
+  });
+  assert.deepEqual(
+    calls.map(({ pathname }) => pathname),
+    [
+      '/sessions/session-1/extensions',
+      '/agent/remove_extension',
+      '/agent/remove_extension',
+    ],
+  );
+  assert.deepEqual(
+    calls.slice(1).map(({ init }) => JSON.parse(init.body)),
+    [
+      { session_id: 'session-1', name: 'sandbox-fs' },
+      { session_id: 'session-1', name: 'tkmind-search' },
+    ],
+  );
+  assert.equal(calls.some(({ pathname }) => pathname.includes('delete')), false);
+});
+
+test('quiesceSessionStdioExtensions fails when upstream removal is not acknowledged', async () => {
+  const apiFetch = async (pathname) => {
+    if (pathname.endsWith('/extensions')) {
+      return jsonResponse({ extensions: [{ name: 'sandbox-fs', type: 'stdio' }] });
+    }
+    return jsonResponse({ message: 'remove failed' }, { ok: false, status: 500 });
+  };
+
+  await assert.rejects(
+    quiesceSessionStdioExtensions(apiFetch, 'session-1'),
+    /remove failed/,
+  );
+});
diff --git a/wechat-mp.test.mjs b/wechat-mp.test.mjs
index c380850..e5a6c62 100644
--- a/wechat-mp.test.mjs
+++ b/wechat-mp.test.mjs
@@ -2057,7 +2057,7 @@ test('wechat mp service reconciles existing dedicated session before reply', asy
         extensionsReadCount += 1;
         const extensions =
           extensionsReadCount > 1
-            ? [{ name: 'sandbox-fs', available_tools: ['list_dir'] }]
+            ? [extensionConfig]
             : [];
         return new Response(JSON.stringify({ extensions }), {
           status: 200,
@@ -2212,7 +2212,7 @@ test('wechat mp service recreates poisoned dedicated session after bare completi
     },
     sessionApiFetch: async (sessionId, pathname, init = {}) => {
       if (pathname === `/sessions/${sessionId}/extensions`) {
-        return new Response(JSON.stringify({ extensions: [{ name: 'developer', available_tools: ['write'] }] }), {
+        return new Response(JSON.stringify({ extensions: [{ type: 'platform', name: 'developer', available_tools: ['write'] }] }), {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
@@ -2390,7 +2390,7 @@ test('wechat mp service forwards html link when write_file created a real page w
     },
     sessionApiFetch: async (sessionId, pathname) => {
       if (pathname === `/sessions/${sessionId}/extensions`) {
-        return new Response(JSON.stringify({ extensions: [{ name: 'developer', available_tools: ['write'] }] }), {
+        return new Response(JSON.stringify({ extensions: [{ type: 'platform', name: 'developer', available_tools: ['write'] }] }), {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
@@ -3162,7 +3162,7 @@ test('wechat mp service recreates dedicated session when tool_calls error arrive
     },
     sessionApiFetch: async (sessionId, pathname, init = {}) => {
       if (pathname === `/sessions/${sessionId}/extensions`) {
-        return new Response(JSON.stringify({ extensions: [{ name: 'developer', available_tools: ['write'] }] }), {
+        return new Response(JSON.stringify({ extensions: [{ type: 'platform', name: 'developer', available_tools: ['write'] }] }), {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
@@ -3331,7 +3331,7 @@ test('wechat mp service recreates dedicated session after poisoned tool_calls hi
     },
     sessionApiFetch: async (sessionId, pathname, init = {}) => {
       if (pathname === `/sessions/${sessionId}/extensions`) {
-        return new Response(JSON.stringify({ extensions: [{ name: 'developer', available_tools: ['write'] }] }), {
+        return new Response(JSON.stringify({ extensions: [{ type: 'platform', name: 'developer', available_tools: ['write'] }] }), {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
@@ -3497,7 +3497,7 @@ test('wechat mp service retries poisoned publish claims before forwarding H5 ret
     },
     sessionApiFetch: async (sessionId, pathname) => {
       if (pathname === `/sessions/${sessionId}/extensions`) {
-        return new Response(JSON.stringify({ extensions: [{ name: 'developer', available_tools: ['write'] }] }), {
+        return new Response(JSON.stringify({ extensions: [{ type: 'platform', name: 'developer', available_tools: ['write'] }] }), {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });