@sema-agent/server 1.185.0

package/dist/main.js

@@ -0,0 +1,1526 @@
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { loadRemoteExec } from "@sema-agent/registry-core/node";
+import { Runner, TtlSessionStore, uuidv7, defaultTaskRegistry, combinePolicies, createDurableQuestionPolicy, createAllowDenyPolicy, tightenTaskSpec, isThinkingLevel, QUESTION_AWAITS_RESUME, FileWorkflowRunStore, InMemoryWorkflowRunStore, workflowsCapability, NodeLspManager, createFileWorkflowScriptStore, expandTiers } from "@sema-agent/core";
+import { PgMemoryEngineBackend, ensurePgMemoryEngineSchema } from "./plugins/memory-engine-pg.js";
+import { TiDBMemoryEngineBackend, ensureTiDBMemoryEngineSchema } from "./plugins/memory-engine-tidb.js";
+import { PgMemoryHistoryStore, ensurePgMemoryHistorySchema, PgMemorySyncStore, ensurePgMemorySyncSchema } from "./plugins/memory-sync-store-pg.js";
+import { TiDBMemoryHistoryStore, ensureTiDBMemoryHistorySchema, TiDBMemorySyncStore, ensureTiDBMemorySyncSchema } from "./plugins/memory-sync-store-tidb.js";
+import { resolveTaskModel, modelSupportsImages } from "./model-select.js";
+import { derivePkgSourceEnv, customPkgSourceFromEnv } from "./sandbox-pkg-source.js";
+import { createSessionTitler } from "./session-titler.js";
+import { selectEnvironmentTool, SessionEnvironmentSelection } from "./capabilities/select-environment-tool.js";
+import { buildEnvFacts, egressForRemoteExec } from "./env-facts.js";
+import { normalizeSuggestNextPrompts, normalizeResilience, normalizeAttachments } from "./spec-fields.js";
+import { createBrain, brainSummary } from "./brain.js";
+import { loadConfig, drainConfigWarnings } from "./config.js";
+import { resourceSuspendOptIn } from "./resource-suspend.js";
+import { createSessionStore } from "./plugins/session-store.js";
+import { createStoreBackend } from "./plugins/store-backend.js";
+import { e2bExecutionEnvFactory } from "./plugins/remote-env-e2b.js";
+import { k8sExecutionEnvFactory } from "./plugins/remote-env-k8s.js";
+import { sshExecutionEnvFactory } from "./plugins/remote-env-ssh.js";
+import { adbExecutionEnvFactory } from "./plugins/remote-env-adb.js";
+import { hostExecutionEnvFactory, RemoteHostExecutionEnv } from "./plugins/remote-env-host.js";
+import { webSearchConfigFromEnv, createWebSearchBackend, setWebSearchBadPayloadObserver } from "./plugins/web-search.js";
+import { FileSchedulerBackend, defaultSchedulerStorePath } from "./plugins/scheduler-support.js";
+import { localDockerExecutionEnvFactory } from "./plugins/remote-env-local-docker.js";
+import { withWorktreeIsolation, reapOrphanWorktrees } from "./plugins/worktree-isolation.js";
+import { createE2bLspManager } from "./lsp/e2b-manager.js";
+import { createAuthorizer, memoryEngineBackendFor, memoryEngineRemoteLanePosture, memorySpecForRequest, HttpError } from "./security.js";
+import { createOaApprovalPolicy, createDurableAskPolicy } from "./approval.js";
+import { buildSessionAuditPg, buildSessionAuditLocal, buildSessionAudit } from "./audit.js";
+import { makeDegenerateInstrument } from "./degenerate-instrument.js";
+import { PlanCacheProbe } from "./plan-cache-probe.js";
+import { loadSkills } from "./capabilities/skills.js";
+import { GiteaClient } from "./capabilities/repo-tools.js";
+import { buildScenarios, selectScenario, centerScenarios, mergeUserSkills, builtinScenarioDetails, centerScenarioDetails, gateScenarioRequest } from "./capabilities/scenarios.js";
+import { resolveCollabWorkflow, listCollabWorkflows } from "./capabilities/collab-workflows.js";
+import { createLogger } from "./observability/logger.js";
+import { createToolTracer, createPermissionDeniedMeter } from "./observability/tool-trace.js";
+import { createRegistryJwtVerifier } from "./auth-bridge.js";
+import { createMetrics } from "./observability/metrics.js";
+import { setRedactionObserver, redactSecrets } from "./trace/redact.js";
+import { RateLimiter } from "./observability/rate-limit.js";
+import { createHttpServer, explicitOperator } from "./http/server.js";
+import { exportMemoryScope } from "./memory-export.js";
+import { performMemorySync } from "./memory-sync.js";
+import { createMemorySyncRunner, createMemorySyncTransport } from "./memory-sync-client.js";
+import { createLeaderEndpoint } from "./leader/endpoint.js";
+import { buildLeaderRunner } from "./leader/wire.js";
+import { WorkflowNotifyGate, JournalingWorkflowRunStore, FileWorkflowNotifyJournalStore, } from "./orchestration/workflow-notify-journal.js";
+import { FileWorkflowCompletionInbox, InMemoryWorkflowCompletionInbox, resolveCompletionRoute, resolveServedSession, } from "./orchestration/workflow-completion-inbox.js";
+import { buildPricing, buildTracer, cappedCeiling, ModelUsageTracker } from "./budget.js";
+import { CostQuota } from "./observability/cost-quota.js";
+import { startOtlpExporter } from "./observability/otel-exporter.js";
+import { HEARTBEAT_MS } from "./runs.js";
+import { ElicitationCoordinator } from "./elicitation.js";
+import { QuestionCoordinator } from "./question.js";
+import { fetchEffective, applyEffective, mutateInPlace, logEffectiveDiff, applyCenterSkills, resolveMcpServers, mcpForScenario, restartReasons } from "./sema-registry.js";
+import { ensureSealedKeyStore, reportExecutionPublicKey } from "./sealed-key.js";
+import { createConfigProvider } from "./config-provider.js";
+import { createPrincipalCapsClient, gateExecutionLane, scopedTokenNeedsWorker, applyObserverEnvOptIn } from "./runtime-caps-resolver.js";
+import { applyRuntimeGovernance, stripDelegationTools } from "./runtime-governance.js";
+import { parseTaskSettings, applyTaskSettings, coercePermissionMode, withPermissionMode, effectiveThinking } from "./task-settings.js";
+import { buildTaskHooks, composeHooks } from "./hooks/hook-runner.js";
+import { selfOrchestrationFromBody, enableForkFromBody, workflowModelAllowlistFor, normalizeRetainSubagentSessions, taskWallClockSec } from "./task-workflow.js";
+import { FleetUsageAccumulator, startFleetClientFromEnv } from "./fleet-client.js";
+import { buildFleetLeaseFromEnv } from "./fleet-lease.js";
+import { reclaimOrphansAtBoot } from "./boot-reclaim.js";
+import { evictLspOnDestroy } from "./lsp-evict.js";
+import { makeLoadProjectMemory } from "./project-memory.js";
+import { cwdHonored, effectiveHostWorkspace, isValidCwd, parseAdditionalDirectories } from "./task-cwd.js";
+import { resolveRequestMcp, mcpInjectionHonored } from "./task-mcp.js";
+import { PerTaskImageRegistry, resolveSandboxImageRef } from "./per-task-image.js";
+import { routeServiceTask, isIsolatedExecEnv, supPostureOverrides } from "./router/route-orchestration.js";
+import { createHardenedVmRunner } from "./orchestration/hardened-vm-runner.js";
+import { createWorkerHardenedVmRunner } from "./orchestration/hardened-vm-worker-runner.js";
+import { WorkflowAgentRegistry } from "./orchestration/workflow-agent-steer.js";
+import { SubagentSteerRegistry } from "./orchestration/subagent-steer.js";
+import { FleetEventBus, fleetBackgroundChildPublisher } from "./fleet/fleet-bus.js";
+import { buildKeyResolver } from "./key-resolver.js";
+function serviceVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+async function main() {
+    const config = loadConfig();
+    if (config.runStaleSec * 1000 <= HEARTBEAT_MS) {
+        throw new Error(`REAP_RUN_STALE_SEC (${config.runStaleSec}s) must exceed the ${HEARTBEAT_MS / 1000}s liveness heartbeat`);
+    }
+    const logger = createLogger(config.logLevel);
+    const metrics = createMetrics();
+    for (const w of drainConfigWarnings())
+        logger.warn("config_env_invalid_using_default", { env: w.env, raw: w.raw });
+    if ((config.roles?.verifier ?? "default") === "default") {
+        logger.warn("verify_decorrelation_unavailable", {
+            hint: "verifier role = default (= implementer) — adversarial verification grades its own work; set MODEL_VERIFIER=<catalog model id> to a heterogeneous model",
+            ...(process.env.MODEL_VERIFIER ? { rejected: process.env.MODEL_VERIFIER, reason: "not in catalog" } : {}),
+        });
+    }
+    setRedactionObserver((pattern, n) => metrics.inc("redactions_applied_total", { pattern }, n));
+    setWebSearchBadPayloadObserver((provider) => {
+        metrics.inc("web_search_bad_payload_total", { provider });
+        logger.warn("web_search_non_array_payload", { provider });
+    });
+    let ccEtag;
+    let effective;
+    let pendingRestart;
+    const cc = config.configCenter;
+    const localRoot = config.configLocalDir ?? process.env.AGENT_DATA_DIR ?? join(homedir(), ".ai-agent");
+    let sealedKeys;
+    try {
+        sealedKeys = await ensureSealedKeyStore(join(config.localDataRoot ?? localRoot, "sealed-key"), logger);
+        void reportExecutionPublicKey({
+            baseUrl: cc?.baseUrl,
+            adminToken: process.env.SEMA_REGISTRY_ADMIN_TOKEN || process.env.REGISTRY_ADMIN_TOKEN,
+            key: sealedKeys.latest,
+            ...(cc?.worker ? { notes: `worker ${cc.worker}` } : {}),
+            logger,
+        });
+    }
+    catch (err) {
+        logger.warn("sealed_key_store_unavailable", { err: String(err), note: "sealed api keys cannot be unsealed on this host — models carrying sealedApiKey will fail loud per-model" });
+    }
+    const configProvider = cc || config.configProvider === "local"
+        ? createConfigProvider({
+            ...(config.configProvider ? { provider: config.configProvider } : {}),
+            ...(cc ? { configCenter: { baseUrl: cc.baseUrl, token: cc.token, worker: cc.worker, dryRun: cc.dryRun } } : {}),
+            ...(config.configProvider === "local" ? { localDir: localRoot } : {}),
+        })
+        : undefined;
+    const modelReadyState = { ready: !(cc && !cc.dryRun) || Boolean(process.env.MODEL_ID) };
+    const markRosterLanded = (eff) => {
+        if (!modelReadyState.ready && (eff.models?.models ?? []).some((m) => m.enabled !== false)) {
+            modelReadyState.ready = true;
+            logger.info("model_roster_landed", { note: "ready gate open — billable submissions accepted" });
+        }
+    };
+    if (configProvider) {
+        const dryRun = cc?.dryRun ?? false;
+        try {
+            const r = await configProvider.fetchEffective(undefined);
+            if (r) {
+                ccEtag = r.etag;
+                if (dryRun) {
+                    logEffectiveDiff(config, r.effective, logger);
+                }
+                else {
+                    applyEffective(config, r.effective, logger, { sealedKeys });
+                    markRosterLanded(r.effective);
+                    effective = r.effective;
+                    logger.info("config_loaded", { source: configProvider.kind, version: r.effective.version, worker: cc?.worker ?? "(global)" });
+                }
+            }
+        }
+        catch (err) {
+            logger.warn("config_source_unreachable_using_env", { source: configProvider.kind, err: String(err) });
+        }
+    }
+    if (!modelReadyState.ready)
+        logger.warn("model_roster_pending", { note: "registry deployment without an env model and no roster yet — billable submissions 503 until the first effective pull lands models" });
+    if (configProvider?.kind === "local") {
+        try {
+            const fileRx = await loadRemoteExec(localRoot);
+            if (fileRx) {
+                if (fileRx.provider === "host") {
+                    config.remoteExec = {
+                        provider: "host",
+                        ...(fileRx.workdir ? { workspaceBase: fileRx.workdir } : {}),
+                        ...(fileRx.commandTimeoutMs != null ? { commandTimeoutMs: fileRx.commandTimeoutMs } : {}),
+                    };
+                    logger.info("remote_exec_from_file", { provider: "host", root: localRoot });
+                }
+                else if (fileRx.provider === "local-docker") {
+                    config.remoteExec = {
+                        provider: "local-docker",
+                        image: fileRx.image,
+                        ...(fileRx.mountPath ? { mountPath: fileRx.mountPath } : fileRx.workdir ? { mountPath: fileRx.workdir } : {}),
+                        ...(fileRx.memory ? { memory: fileRx.memory } : {}),
+                        ...(fileRx.cpus != null ? { cpus: fileRx.cpus } : {}),
+                        ...(fileRx.network ? { network: fileRx.network } : {}),
+                    };
+                    logger.info("remote_exec_from_file", { provider: "local-docker", root: localRoot, image: fileRx.image });
+                }
+                else {
+                    logger.warn("remote_exec_file_isolated_lane_unwired", { provider: fileRx.provider, note: "e2b/k8s/ssh/adb are sourced from REMOTE_EXEC env until file-source NAME→value resolution lands (center field map)" });
+                }
+            }
+        }
+        catch (err) {
+            logger.error("remote_exec_file_invalid", { root: localRoot, err: String(err) });
+            throw err;
+        }
+    }
+    let backend;
+    let storeBackendDegraded = false;
+    const wantDb = config.sessionBackend === "tidb" ||
+        config.dbBackend === "local" ||
+        (config.sessionBackend === "auto" && !!(config.tidb || config.pg));
+    if (wantDb) {
+        backend = createStoreBackend(config);
+        if (backend) {
+            try {
+                await backend.ensureSchema();
+            }
+            catch (err) {
+                if (config.sessionBackend === "auto") {
+                    logger.warn("store_db_unreachable_fallback_memory", { backend: backend.kind, error: err instanceof Error ? err.message : String(err) });
+                    storeBackendDegraded = true;
+                    await backend.close().catch(() => undefined);
+                    backend = undefined;
+                }
+                else
+                    throw err;
+            }
+        }
+    }
+    metrics.setGauge("store_backend_degraded", storeBackendDegraded ? 1 : 0);
+    {
+        const minioReq = ["MINIO_ENDPOINT", "MINIO_ACCESS_KEY", "MINIO_SECRET_KEY"];
+        const present = minioReq.filter((v) => (process.env[v] ?? "") !== "");
+        if (present.length > 0 && !config.snapshotBlobStore) {
+            logger.warn("snapshot_blob_store_partial_config_fallback_sql", { present, missing: minioReq.filter((v) => !present.includes(v)) });
+        }
+        metrics.setGauge("snapshot_blob_backend", 1, { backend: config.snapshotBlobStore ? "minio" : "sql" });
+    }
+    if (config.sessionBackend === "auto")
+        config.sessionBackend = backend ? "tidb" : "memory";
+    if (config.dbBackend === "local" && backend)
+        config.sessionBackend = "tidb";
+    let memoryEngine;
+    let memorySyncCursors;
+    if (config.memoryEngineBackend !== "file" && config.memoryEngineEnabled) {
+        const dialect = config.memoryEngineBackend;
+        const countedHistorySink = (store) => ({
+            appendHistory: async (rows) => {
+                try {
+                    await store.appendHistory(rows);
+                }
+                catch (err) {
+                    metrics.inc("memory_history_append_failed_total", { backend: dialect }, rows.length);
+                    throw err;
+                }
+            },
+        });
+        if (dialect === "pg") {
+            const pool = backend?.pgPool();
+            if (!pool)
+                throw new Error("MEMORY_ENGINE_BACKEND=pg requires DB_BACKEND=pg (the memory engine binds the same PG pool) — refusing to start half-configured");
+            const q = async (text, params) => { const r = await pool.query(text, params); return { rows: r.rows }; };
+            await ensurePgMemoryEngineSchema(q);
+            await ensurePgMemoryHistorySchema(q);
+            await ensurePgMemorySyncSchema(q);
+            memorySyncCursors = new PgMemorySyncStore(q);
+            const pgMem = new PgMemoryEngineBackend(q, { history: countedHistorySink(new PgMemoryHistoryStore(q)) });
+            memoryEngine = { backend: pgMem, root: join(config.localDataRoot ?? localRoot, "memory-work") };
+        }
+        else {
+            const pool = backend?.mysqlPool();
+            if (!pool)
+                throw new Error("MEMORY_ENGINE_BACKEND=tidb requires DB_BACKEND=mysql/tidb — refusing to start half-configured");
+            await ensureTiDBMemoryEngineSchema(pool);
+            await ensureTiDBMemoryHistorySchema(pool);
+            await ensureTiDBMemorySyncSchema(pool);
+            memorySyncCursors = new TiDBMemorySyncStore(pool);
+            memoryEngine = { backend: new TiDBMemoryEngineBackend(pool, { history: countedHistorySink(new TiDBMemoryHistoryStore(pool)) }), root: join(config.localDataRoot ?? localRoot, "memory-work") };
+        }
+        logger.info("memory_engine_enabled", { enabled: true, backend: dialect, multiTenant: config.requirePrincipal === true, workRoot: memoryEngine.root });
+    }
+    else {
+        memoryEngine = memoryEngineBackendFor(config);
+    }
+    const memoryExportBackend = config.memoryEngineBackend !== "file" ? memoryEngine?.backend : undefined;
+    const memoryLane = memoryEngineRemoteLanePosture(config);
+    if (config.memoryEngineBackend === "file" || !config.memoryEngineEnabled) {
+        logger.info("memory_engine_enabled", memoryEngine
+            ? { enabled: true, backend: "file", dir: memoryEngine.root }
+            : {
+                enabled: false,
+                reason: config.requirePrincipal === true ? "multi-tenant on the FILE backend (no tenant isolation; set MEMORY_ENGINE_BACKEND=pg|tidb to light up)"
+                    : !config.memoryEngineEnabled ? "MEMORY_ENGINE=off"
+                        : `remote exec lane "${memoryLane?.lane}" (worker/sandbox file planes split; MEMORY_ENGINE_REMOTE_LANE=allow overrides)`,
+            });
+    }
+    if (memoryLane && config.memoryEngineEnabled && config.requirePrincipal !== true) {
+        logger.warn("memory_engine_remote_lane", memoryLane.posture === "dark"
+            ? { lane: memoryLane.lane, effect: "memory dark (fail-closed): the file engine works the worker's local fs while this lane routes model file tools to the sandbox fs — sandbox writes are never harvested. Set MEMORY_ENGINE_REMOTE_LANE=allow ONLY if both are one fs." }
+            : { lane: memoryLane.lane, effect: "MEMORY_ENGINE_REMOTE_LANE=allow: memory engine ON over a remote lane — harvest only sees files landing on the WORKER fs; verify the lane really shares it." });
+    }
+    let memorySyncRunner;
+    if (config.memorySync) {
+        if (memoryEngine) {
+            memorySyncRunner = createMemorySyncRunner({
+                backend: memoryEngine.backend,
+                scope: config.memorySync.scope,
+                memoryRoot: memoryEngine.root,
+                transport: createMemorySyncTransport({ url: config.memorySync.url, token: config.memorySync.token }),
+                log: logger,
+            });
+            logger.info("memory_sync_enabled", { url: config.memorySync.url, scope: config.memorySync.scope, cursorPath: memorySyncRunner.cursorPath });
+            memorySyncRunner.trigger("boot");
+        }
+        else {
+            logger.warn("memory_sync_configured_but_memory_dark", { note: "MEMORY_SYNC_URL is set but the file memory engine is dark (multi-tenant / MEMORY_ENGINE=off / remote exec lane) — no sync rounds will run" });
+        }
+    }
+    const sessionStore = createSessionStore(config, backend, metrics);
+    if (config.requirePrincipal && !sessionStore.ownerOf) {
+        throw new Error("REQUIRE_PRINCIPAL=true needs an owner-aware session store (SESSION_BACKEND=tidb); " +
+            "the in-memory store cannot enforce session ownership.");
+    }
+    if (config.requirePrincipal && backend?.kind === "local") {
+        throw new Error("REQUIRE_PRINCIPAL=true is not supported on the local in-memory backend (DB_BACKEND=local): its owner map is " +
+            "process-local and lost on restart, so it cannot durably enforce multi-tenant session ownership. Use a DB " +
+            "backend (DB_BACKEND=tidb|pg) for multi-tenant, or run local single-user with REQUIRE_PRINCIPAL=false.");
+    }
+    if (!config.requirePrincipal && sessionStore.ownerOf) {
+        logger.warn("principal_optional", {
+            note: "owner-aware session store with REQUIRE_PRINCIPAL=false — owned sessions are protected, but headerless callers can create/share anonymous sessions; set REQUIRE_PRINCIPAL=true for multi-tenant",
+        });
+    }
+    metrics.dynamicGauge("sessions_warm", "Sessions held in the warm cache", () => sessionStore.size);
+    const breakerState = backend?.breaker && config.resilience.circuitBreaker
+        ? backend
+            .breaker((streak) => {
+            metrics.setGauge("counter_flush_fail_streak", streak, { table: "circuit_breaker", kind: "write_through" });
+            if (streak > 0)
+                metrics.inc("breaker_writethrough_failed_total", { backend: backend.kind });
+            if (streak === 3)
+                logger.warn("breaker_writethrough_degraded", { streak });
+            else if (streak === 0)
+                logger.info("breaker_writethrough_recovered", {});
+        })
+            .startRefresh()
+        : undefined;
+    const brain = createBrain(config, { breakerState });
+    const pricing = buildPricing(config.models);
+    const counterDegradeHook = (info) => {
+        metrics.setGauge("counter_flush_fail_streak", info.streak, { table: info.table, kind: info.kind });
+        if (info.streak > 0)
+            metrics.inc("counter_flush_failed_total", { table: info.table, kind: info.kind });
+        if (info.streak === 3)
+            logger.warn("counter_flush_degraded", { table: info.table, kind: info.kind, streak: info.streak, ...(info.error ? { error: info.error } : {}) });
+        else if (info.streak === 0 && info.prevStreak >= 3)
+            logger.info("counter_flush_recovered", { table: info.table, kind: info.kind, prevStreak: info.prevStreak });
+    };
+    const costQuota = config.maxPrincipalCostUsd > 0
+        ? backend?.costQuota
+            ? backend.costQuota(Math.round(config.maxPrincipalCostUsd * 1e6), config.costQuotaWindowSec * 1000, counterDegradeHook).startRefresh()
+            : new CostQuota(Math.round(config.maxPrincipalCostUsd * 1e6), config.costQuotaWindowSec * 1000)
+        : undefined;
+    const modelUsageTracker = new ModelUsageTracker();
+    const fleetUsage = config.configCenter && process.env.FLEET_ADVERTISE_ADDRESS ? new FleetUsageAccumulator() : undefined;
+    const fleetLease = buildFleetLeaseFromEnv(config, { logger, metrics });
+    const tracer = buildTracer(metrics, costQuota, modelUsageTracker, fleetUsage, fleetLease, (m) => config.modelQuotaWeights[m] ?? 1);
+    const toolResultStore = backend?.toolResult ? backend.toolResult() : undefined;
+    const sessionPolicyStore = backend ? backend.sessionPolicy() : undefined;
+    const fileSnapshotStore = backend ? backend.fileSnapshot() : undefined;
+    const perTaskImage = new PerTaskImageRegistry();
+    const sessionEnvSelection = new SessionEnvironmentSelection();
+    const MAX_CWD_SESSIONS = 4096;
+    const perSessionCwd = new Map();
+    const setSessionCwd = (sid, cwd) => {
+        perSessionCwd.delete(sid);
+        perSessionCwd.set(sid, cwd);
+        if (perSessionCwd.size > MAX_CWD_SESSIONS)
+            perSessionCwd.delete(perSessionCwd.keys().next().value);
+    };
+    const perSessionShellEnv = new Map();
+    const setSessionShellEnv = (sid, env) => {
+        perSessionShellEnv.delete(sid);
+        perSessionShellEnv.set(sid, env);
+        if (perSessionShellEnv.size > MAX_CWD_SESSIONS)
+            perSessionShellEnv.delete(perSessionShellEnv.keys().next().value);
+    };
+    let executionEnvFactory;
+    let worktreeReap;
+    if (config.remoteExec?.provider === "e2b") {
+        executionEnvFactory = e2bExecutionEnvFactory({
+            apiKey: config.remoteExec.apiKey,
+            ...(config.remoteExec.template ? { template: config.remoteExec.template } : {}),
+            ...(config.remoteExec.timeoutMs != null ? { timeoutMs: config.remoteExec.timeoutMs } : {}),
+            ...(config.remoteExec.livenessMs != null ? { livenessMs: config.remoteExec.livenessMs } : {}),
+            ...(config.remoteExec.allowInternetAccess != null ? { allowInternetAccess: config.remoteExec.allowInternetAccess } : {}),
+            ...(() => {
+                const merged = { ...derivePkgSourceEnv(config.sandboxPkgSource, customPkgSourceFromEnv()), ...(config.remoteExec.sandboxEnv ?? {}) };
+                return Object.keys(merged).length > 0 ? { sandboxEnv: merged } : {};
+            })(),
+            logger,
+            metrics,
+        });
+    }
+    else if (config.remoteExec?.provider === "k8s") {
+        const k8sCfg = {
+            image: config.remoteExec.image,
+            ...(config.remoteExec.apiUrl ? { apiUrl: config.remoteExec.apiUrl } : {}),
+            ...(config.remoteExec.token ? { token: config.remoteExec.token } : {}),
+            ...(config.remoteExec.caCert ? { caCert: config.remoteExec.caCert } : {}),
+            ...(config.remoteExec.insecureTls ? { insecureTls: true } : {}),
+            ...(config.remoteExec.namespace ? { namespace: config.remoteExec.namespace } : {}),
+            ...(config.remoteExec.runtimeClass != null ? { runtimeClass: config.remoteExec.runtimeClass } : {}),
+            ...(config.remoteExec.mountPath ? { mountPath: config.remoteExec.mountPath } : {}),
+            ...(config.remoteExec.timeoutMs != null ? { timeoutMs: config.remoteExec.timeoutMs } : {}),
+            ...(config.remoteExec.memory ? { memory: config.remoteExec.memory } : {}),
+            ...(config.remoteExec.cpu ? { cpu: config.remoteExec.cpu } : {}),
+            ...(config.remoteExec.s3Snapshot ? { s3Snapshot: config.remoteExec.s3Snapshot } : {}),
+            ...(() => {
+                const derived = derivePkgSourceEnv(config.sandboxPkgSource, customPkgSourceFromEnv());
+                return Object.keys(derived).length > 0 ? { podEnv: derived } : {};
+            })(),
+        };
+        executionEnvFactory = (ctx) => k8sExecutionEnvFactory({ ...k8sCfg, image: perTaskImage.get(ctx.sessionId) ?? k8sCfg.image })(ctx);
+    }
+    else if (config.remoteExec?.provider === "ssh") {
+        executionEnvFactory = sshExecutionEnvFactory({
+            host: config.remoteExec.host,
+            username: config.remoteExec.username,
+            privateKey: config.remoteExec.privateKey,
+            ...(config.remoteExec.port != null ? { port: config.remoteExec.port } : {}),
+            ...(config.remoteExec.mountPath ? { mountPath: config.remoteExec.mountPath } : {}),
+        });
+    }
+    else if (config.remoteExec?.provider === "adb") {
+        executionEnvFactory = adbExecutionEnvFactory({
+            serial: config.remoteExec.serial,
+            ...(config.remoteExec.adbPath ? { adbPath: config.remoteExec.adbPath } : {}),
+            ...(config.remoteExec.mountPath ? { mountPath: config.remoteExec.mountPath } : {}),
+        });
+    }
+    else if (config.remoteExec?.provider === "host") {
+        {
+            const hostScheduler = config.schedulerEnabled && config.requirePrincipal !== true
+                ? new FileSchedulerBackend(config.schedulerStorePath ? { storePath: config.schedulerStorePath } : {})
+                : undefined;
+            if (hostScheduler)
+                logger.info(`R7: self-wake scheduler enabled (host lane), store=${config.schedulerStorePath ?? defaultSchedulerStorePath()}`);
+            const hostCfg = {
+                ...(config.remoteExec.workspaceBase ? { workspaceBase: config.remoteExec.workspaceBase } : {}),
+                ...(config.remoteExec.commandTimeoutMs != null ? { commandTimeoutMs: config.remoteExec.commandTimeoutMs } : {}),
+                ...(hostScheduler ? { scheduler: hostScheduler } : {}),
+                backgroundShell: config.requirePrincipal !== true,
+            };
+            executionEnvFactory = (ctx) => {
+                const cwd = effectiveHostWorkspace(perSessionCwd.get(ctx.sessionId), ctx);
+                const shellEnv = perSessionShellEnv.get(ctx.sessionId);
+                const env = hostExecutionEnvFactory({
+                    ...hostCfg,
+                    ...(cwd ? { workspaceDir: cwd } : {}),
+                    ...(shellEnv ? { env: shellEnv } : {}),
+                })(ctx);
+                return lspManager && !cwd ? evictLspOnDestroy(env, lspManager) : env;
+            };
+        }
+    }
+    else if (config.remoteExec?.provider === "local-docker") {
+        executionEnvFactory = localDockerExecutionEnvFactory({
+            image: config.remoteExec.image,
+            ...(config.remoteExec.mountPath ? { mountPath: config.remoteExec.mountPath } : {}),
+            ...(config.remoteExec.dockerPath ? { dockerPath: config.remoteExec.dockerPath } : {}),
+            ...(config.remoteExec.dockerHost ? { dockerHost: config.remoteExec.dockerHost } : {}),
+            ...(config.remoteExec.memory ? { memory: config.remoteExec.memory } : {}),
+            ...(config.remoteExec.cpus != null ? { cpus: config.remoteExec.cpus } : {}),
+            ...(config.remoteExec.network ? { network: config.remoteExec.network } : {}),
+            ...(config.remoteExec.commandTimeoutMs != null ? { commandTimeoutMs: config.remoteExec.commandTimeoutMs } : {}),
+            ...(config.remoteExec.env ? { env: config.remoteExec.env } : {}),
+        });
+    }
+    if (config.worktreeIsolation && executionEnvFactory) {
+        const wtRoot = config.worktreeIsolation.repoRoot;
+        const wtValid = existsSync(wtRoot) && existsSync(join(wtRoot, ".git"));
+        if (config.remoteExec?.provider === "host" && !wtValid) {
+            logger.error("worktree_isolation_disabled_bad_repo_root", {
+                repoRoot: wtRoot,
+                reason: existsSync(wtRoot) ? "not a git repository (no .git)" : "path does not exist",
+                note: "WORKTREE_ISOLATION_ENABLED is set but WORKTREE_REPO_ROOT is not a usable git repo — isolation left OFF; isolation:'worktree' agents run on the shared base env. Fix the path or unset the flag.",
+            });
+        }
+        else if (config.remoteExec?.provider === "host") {
+            const gitBaseEnv = new RemoteHostExecutionEnv({ workspaceDir: config.worktreeIsolation.repoRoot, inheritEnv: "all", backgroundShell: config.requirePrincipal !== true });
+            executionEnvFactory = withWorktreeIsolation(executionEnvFactory, {
+                repoRoot: config.worktreeIsolation.repoRoot,
+                ...(config.worktreeIsolation.allowedRoots ? { allowedRoots: config.worktreeIsolation.allowedRoots } : {}),
+                ...(config.worktreeIsolation.commit ? { commit: config.worktreeIsolation.commit } : {}),
+                baseEnvForGit: gitBaseEnv,
+                rootEnvAt: (dir) => {
+                    const env = new RemoteHostExecutionEnv({ workspaceDir: dir, backgroundShell: config.requirePrincipal !== true });
+                    return lspManager ? evictLspOnDestroy(env, lspManager) : env;
+                },
+                logger,
+            });
+            worktreeReap = () => reapOrphanWorktrees(gitBaseEnv, config.worktreeIsolation.repoRoot, logger);
+            logger.info("worktree_isolation_enabled", { provider: "host", repoRoot: config.worktreeIsolation.repoRoot });
+            void worktreeReap();
+        }
+        else {
+            logger.warn("worktree_isolation_unsupported_lane", {
+                provider: config.remoteExec?.provider,
+                note: "git-worktree isolation v1 covers only the 'host' lane — isolation:'worktree' is a no-op here (the base env is used). Worktree-rooted remote envs are a follow-on.",
+            });
+        }
+    }
+    if (executionEnvFactory) {
+        const isolated = config.remoteExec.provider === "e2b" ||
+            config.remoteExec.provider === "k8s" ||
+            config.remoteExec.provider === "local-docker";
+        const suspendable = config.remoteExec.provider === "e2b" ||
+            (config.remoteExec.provider === "k8s" && !!config.remoteExec.s3Snapshot);
+        const sandboxEnvKeys = config.remoteExec.provider === "e2b" ? Object.keys(config.remoteExec.sandboxEnv ?? {}) : [];
+        logger.info("remote_exec_enabled", { provider: config.remoteExec.provider, isolated, suspendable, ...(sandboxEnvKeys.length > 0 ? { sandboxEnvKeys } : {}) });
+        if (!isolated)
+            logger.warn("remote_exec_real_system", { provider: config.remoteExec.provider, note: "non-isolated target — actions are permanent; rely on the policy gate + HITL (design/61 §5)" });
+    }
+    const lspProvider = config.remoteExec?.provider;
+    const lspManager = (lspProvider === "e2b" || lspProvider === "k8s") && config.lspEnabled
+        ? createE2bLspManager({ log: (event, fields) => logger.info(event, fields), scheme: lspProvider === "k8s" ? "ws" : "wss" })
+        :
+            lspProvider === "host" && config.lspHostEnabled && config.requirePrincipal !== true
+                ? new NodeLspManager({ log: (event, fields) => logger.info(event, fields) })
+                : undefined;
+    if (lspManager)
+        logger.info("lsp_enabled", { provider: lspProvider });
+    const toolTracer = config.toolTrace ? createToolTracer(logger) : undefined;
+    if (toolTracer)
+        logger.info("tool_trace_enabled", {});
+    const deploymentHooks = toolTracer ? composeHooks(createPermissionDeniedMeter(metrics), toolTracer) : createPermissionDeniedMeter(metrics);
+    const sqlWorkflowRunStore = config.workflowRunStoreBackend === "auto" ? backend?.workflowRun?.() : undefined;
+    const baseWorkflowRunStore = config.selfOrchestrationEnabled
+        ? config.workflowRunStoreBackend === "memory"
+            ? new InMemoryWorkflowRunStore()
+            : (sqlWorkflowRunStore ?? new FileWorkflowRunStore(join(config.localDataRoot ?? localRoot, "workflows")))
+        : undefined;
+    const workflowNotifyJournal = config.selfOrchestrationEnabled && config.workflowRunStoreBackend !== "memory"
+        ? (sqlWorkflowRunStore ? backend.notifyJournal() : new FileWorkflowNotifyJournalStore(join(config.localDataRoot ?? localRoot, "workflows")))
+        : undefined;
+    const workflowCompletionInbox = config.selfOrchestrationEnabled
+        ? config.workflowRunStoreBackend === "memory"
+            ? new InMemoryWorkflowCompletionInbox((msg, meta) => logger.warn(msg, meta))
+            : (sqlWorkflowRunStore ? backend.completionInbox((msg, meta) => logger.warn(msg, meta)) : new FileWorkflowCompletionInbox(join(config.localDataRoot ?? localRoot, "workflows"), (msg, meta) => logger.warn(msg, meta)))
+        : undefined;
+    const deliverWorkflowCompletion = async (p) => {
+        logger.info("workflow_completed", {
+            runId: p.runId,
+            status: p.status,
+            ...(p.sourceTaskId ? { sourceTaskId: p.sourceTaskId } : {}),
+        });
+        metrics.inc("workflow_runs_total", { status: p.status });
+        if (!workflowCompletionInbox)
+            return;
+        try {
+            const route = await resolveCompletionRoute(p, runStore ? (id) => runStore.getRun(id) : undefined, config.requirePrincipal === true);
+            if (!route)
+                return;
+            await workflowCompletionInbox.enqueue({
+                sessionId: route.sessionId,
+                owner: route.owner,
+                runId: p.runId,
+                status: p.status,
+                summary: p.summary,
+                enqueuedAt: Date.now(),
+            });
+        }
+        catch (err) {
+            logger.warn("workflow_completion_enqueue_failed", { runId: p.runId, err: String(err) });
+        }
+    };
+    const workflowNotifyGate = baseWorkflowRunStore && workflowNotifyJournal
+        ? new WorkflowNotifyGate(workflowNotifyJournal, baseWorkflowRunStore, deliverWorkflowCompletion, {
+            onError: (stage, runId, err) => logger.warn("workflow_notify_failed", { stage, runId, err: String(err) }),
+        })
+        : undefined;
+    const fleetBus = new FleetEventBus();
+    const workflowRunStore = baseWorkflowRunStore && workflowNotifyGate
+        ? new JournalingWorkflowRunStore(baseWorkflowRunStore, workflowNotifyGate, fleetBus)
+        : baseWorkflowRunStore;
+    const workflowJournalStore = config.selfOrchestrationEnabled && backend ? backend.workflowJournal() : undefined;
+    const outcomeSink = backend?.outcomeSink();
+    const workflowAgentRegistry = config.selfOrchestrationEnabled ? new WorkflowAgentRegistry() : undefined;
+    const subagentSteerRegistry = new SubagentSteerRegistry();
+    const elicitation = config.mcpElicitation.enabled ? new ElicitationCoordinator(config.mcpElicitation.throttle) : undefined;
+    const question = config.askQuestionEnabled ? new QuestionCoordinator() : undefined;
+    if (config.configCenter && !config.configCenter.dryRun && scopedTokenNeedsWorker(config.configCenter.token, config.configCenter.worker)) {
+        logger.warn("runtime_caps_scoped_token_no_worker", {
+            reason: "SEMA_REGISTRY_TOKEN is a worker-scoped wpt_ token but SEMA_REGISTRY_WORKER is unset → center 403s per-principal caps → ALL workflow self-orchestration will be fail-closed denied. Set SEMA_REGISTRY_WORKER (the orchestrator normally injects it) or use the full SERVICE_PULL_TOKEN.",
+        });
+    }
+    const principalCaps = config.configCenter && !config.configCenter.dryRun
+        ? createPrincipalCapsClient({
+            baseUrl: config.configCenter.baseUrl,
+            token: config.configCenter.token,
+            ...(config.configCenter.worker ? { worker: config.configCenter.worker } : {}),
+            onError: (err, principal) => logger.warn("runtime_caps_resolve_failed", { principal, err: String(err) }),
+        })
+        : undefined;
+    const centerRuntimeCapsResolver = principalCaps?.resolveRuntimeCaps;
+    const runtimeCapsResolver = applyObserverEnvOptIn(centerRuntimeCapsResolver, {
+        experimentalObserverAgents: config.experimentalObserverAgents,
+        requirePrincipal: config.requirePrincipal,
+        warn: (msg, fields) => logger.warn(msg, fields),
+    });
+    const runnerDeps = {
+        brain,
+        models: config.models,
+        roles: config.roles,
+        tiers: config.tiers,
+        pricing,
+        tracer,
+        ...(outcomeSink
+            ? {
+                onTaskOutcome: (o) => {
+                    metrics.inc("task_outcomes_total", { status: o.status, green: String(o.oracle?.green ?? "unknown") });
+                    void outcomeSink.recordCore(o).catch((err) => logger.warn("task_outcome_record_failed", { runId: o.runId, err: String(err) }));
+                },
+            }
+            : {}),
+        ...(elicitation ? { onElicit: elicitation.elicit } : {}),
+        ...(question ? { onQuestion: question.question } : {}),
+        sessionStore,
+        ...(memoryEngine ? { memoryBackend: memoryEngine.backend, memoryEngineDir: memoryEngine.root } : {}),
+        ...(memoryEngine
+            ? {
+                onMemoryHarvestReport: (report, info) => {
+                    metrics.inc("memory_harvest_total", { ok: String(report.ok), phase: info.phase, incident: report.incident?.kind ?? "none" });
+                    if (report.patches)
+                        metrics.inc("memory_harvest_patches_total", { phase: info.phase }, (report.patches.add ?? 0) + (report.patches.update ?? 0));
+                    if (report.incident)
+                        logger.warn("memory_harvest_incident", { kind: report.incident.kind, phase: info.phase });
+                    if (memorySyncRunner && report.ok && (report.patches?.add ?? 0) + (report.patches?.update ?? 0) > 0)
+                        memorySyncRunner.trigger("harvest");
+                },
+            }
+            : {}),
+        toolResultStore,
+        ...(sessionPolicyStore ? { sessionPolicyStore } : {}),
+        ...(runtimeCapsResolver ? { runtimeCapsResolver } : {}),
+        ...(fileSnapshotStore ? { fileSnapshotStore } : {}),
+        ...(executionEnvFactory ? { executionEnvFactory } : {}),
+        ...(lspManager ? { lspManager } : {}),
+        onBackgroundChildEvent: fleetBackgroundChildPublisher(fleetBus, (msg, fields) => logger.info(msg, fields)),
+        ...(config.requirePrincipal !== true && !config.projectMemoryDisabled ? { loadProjectMemory: makeLoadProjectMemory({ logger }) } : {}),
+        hooks: deploymentHooks,
+        ...(config.selfOrchestrationEnabled
+            ? {
+                workflowScriptRunner: config.selfOrchestrationWorkerIsolation
+                    ? createWorkerHardenedVmRunner()
+                    : createHardenedVmRunner(),
+                ...(workflowRunStore ? { workflowRunStore } : {}),
+                ...(workflowJournalStore ? { workflowJournalStore } : {}),
+                workflowScriptStore: (() => {
+                    const fileStore = createFileWorkflowScriptStore(join(config.localDataRoot ?? localRoot, "workflow-scripts"));
+                    return {
+                        persist: fileStore.persist.bind(fileStore),
+                        load: fileStore.load.bind(fileStore),
+                        resolveName: (name) => resolveCollabWorkflow(name) ?? fileStore.resolveName?.(name),
+                        list: () => listCollabWorkflows(),
+                    };
+                })(),
+                ...(workflowAgentRegistry
+                    ? {
+                        onWorkflowAgentSpawn: (handle) => {
+                            const unregister = workflowAgentRegistry.register(handle);
+                            void Promise.resolve(handle.result()).then(unregister, unregister);
+                        },
+                    }
+                    : {}),
+                ...(config.workflowSizeGuideline ? { workflowLimits: { sizeGuideline: config.workflowSizeGuideline } } : {}),
+                workflowGovernanceBaseline: {
+                    base: { handsReadOnly: true },
+                    ...((wl) => (wl ? { workflowModelAllowlist: wl } : {}))(workflowModelAllowlistFor(config)),
+                },
+                workflowCompletionNotifier: {
+                    ...(workflowNotifyGate
+                        ? workflowNotifyGate.buildNotifier()
+                        : { notify: (input) => deliverWorkflowCompletion(input) }),
+                    ackServed: async (input) => {
+                        if (!workflowCompletionInbox)
+                            return;
+                        try {
+                            const sid = await resolveServedSession(input, runStore ? (id) => runStore.getRun(id) : undefined);
+                            if (sid) {
+                                await workflowCompletionInbox.markTerminalServed(sid, input.runId);
+                                logger.info("workflow_complete_ack_served", { route: "poll-served", sessionId: sid, runId: input.runId });
+                            }
+                        }
+                        catch (err) {
+                            logger.warn("workflow_ack_served_failed", { runId: input.runId, err: String(err) });
+                        }
+                    },
+                },
+            }
+            : {}),
+        onError: (err, ctx) => {
+            if (ctx.phase === "degraded") {
+                logger.warn("task_degraded", { sessionId: ctx.sessionId, info: String(err) });
+                return;
+            }
+            if (ctx.phase === "prompt-constitution") {
+                logger.warn("prompt_provider_needs_upgrade", { sessionId: ctx.sessionId, info: String(err) });
+                return;
+            }
+            if (ctx.phase === "rewind") {
+                const code = /\((\w+)\)/.exec(String(err))?.[1] ?? "unknown";
+                logger.warn("rewind_snapshot_failed", { sessionId: ctx.sessionId, code, info: String(err) });
+                metrics.inc("rewind_snapshot_failed_total", { code });
+                return;
+            }
+            if (ctx.phase === "memory") {
+                logger.warn("memory_consolidation_failed", { sessionId: ctx.sessionId, info: String(err) });
+                return;
+            }
+            if (ctx.phase === "mcp") {
+                logger.warn("mcp_server_unavailable", { sessionId: ctx.sessionId, info: String(err) });
+                metrics.inc("mcp_server_unavailable_total");
+                return;
+            }
+            if (ctx.phase === "prompt-cache") {
+                metrics.inc("prompt_cache_low_hit_total");
+                const fields = { sessionId: ctx.sessionId, ...(ctx.classification ? { classification: ctx.classification } : {}), err: String(err) };
+                if (ctx.classification === "server-or-ttl")
+                    logger.warn("prompt_cache_break", fields);
+                else
+                    logger.error("prompt_cache_break", fields);
+                return;
+            }
+            logger.error("runner_error", { phase: ctx.phase, sessionId: ctx.sessionId, err: String(err) });
+        },
+    };
+    const runner = new Runner(runnerDeps);
+    const hookModelFor = (requested) => {
+        const shape = (ref) => {
+            const m = config.models[ref];
+            return { ok: true, catalogRef: ref, providerModelId: m?.id ?? ref, baseUrl: m?.baseUrl || config.gatewayBaseUrl };
+        };
+        if (requested === undefined) {
+            const sum = config.roles.summarize;
+            const roleModel = typeof sum === "string" ? sum : sum && typeof sum === "object" && "model" in sum && typeof sum.model === "string" ? sum.model : undefined;
+            if (roleModel !== undefined)
+                return config.models[roleModel] ? shape(roleModel) : { ok: true, catalogRef: config.model.id, providerModelId: roleModel, baseUrl: config.gatewayBaseUrl };
+            return { ok: true, catalogRef: config.model.id, providerModelId: config.model.id, baseUrl: config.gatewayBaseUrl };
+        }
+        if (config.models[requested])
+            return shape(requested);
+        if (requested === config.model.id)
+            return { ok: true, catalogRef: requested, providerModelId: requested, baseUrl: config.gatewayBaseUrl };
+        return { ok: false, error: `hook model "${requested}" is not in this deployment's catalog` };
+    };
+    const hookLlm = async ({ prompt, model, timeoutMs }) => {
+        const pick = hookModelFor(model);
+        if (!pick.ok)
+            return pick;
+        const ac = new AbortController();
+        const t = setTimeout(() => ac.abort(), timeoutMs);
+        try {
+            const perModel = await keyResolver?.({ name: pick.catalogRef })?.catch?.(() => undefined);
+            const normUrl = (u) => {
+                try {
+                    const x = new URL(u);
+                    return `${x.protocol}//${x.host}${x.pathname.replace(/\/+$/, "")}`;
+                }
+                catch {
+                    return u.replace(/\/+$/, "");
+                }
+            };
+            const sameGateway = normUrl(pick.baseUrl) === normUrl(config.gatewayBaseUrl);
+            const hookKey = perModel?.apiKey ?? (sameGateway ? config.gatewayApiKey : undefined);
+            if (!sameGateway && !hookKey) {
+                return { ok: false, error: `hook model "${pick.catalogRef}" points at a foreign baseUrl with no per-model key — refusing to send the prompt off-gateway` };
+            }
+            const r = await fetch(`${pick.baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+                method: "POST",
+                headers: { "content-type": "application/json", ...(hookKey ? { authorization: `Bearer ${hookKey}` } : {}) },
+                body: JSON.stringify({ model: pick.providerModelId, messages: [{ role: "user", content: prompt }], stream: false }),
+                signal: ac.signal,
+            });
+            if (!r.ok)
+                return { ok: false, error: `hook llm HTTP ${r.status}` };
+            const j = (await r.json());
+            const text = j.choices?.[0]?.message?.content;
+            metrics.inc("hook_llm_calls_total", { type: "prompt" });
+            return typeof text === "string" ? { ok: true, text } : { ok: false, error: "hook llm returned no content" };
+        }
+        catch (e) {
+            return { ok: false, error: ac.signal.aborted ? "hook llm timeout" : String(e) };
+        }
+        finally {
+            clearTimeout(t);
+        }
+    };
+    const hookAgentRunner = new Runner({ ...runnerDeps, sessionStore: new TtlSessionStore({ defaultTtlDays: 1 / 24 }) });
+    const hookAgent = async ({ prompt, model, timeoutMs }) => {
+        const pick = hookModelFor(model);
+        if (!pick.ok)
+            return pick;
+        try {
+            const result = await hookAgentRunner.runTask({
+                objective: prompt,
+                sessionId: uuidv7(),
+                model: pick.catalogRef,
+                handsReadOnly: true,
+                enableFork: false,
+                maxCostUsd: 0.05,
+                limits: { maxTurns: 10, timeoutSec: Math.max(30, Math.ceil(timeoutMs / 1000)) },
+                toolPolicy: createAllowDenyPolicy({}),
+            });
+            metrics.inc("hook_llm_calls_total", { type: "agent" });
+            if (result.status !== "completed")
+                return { ok: false, error: `hook agent ${result.status}: ${clipHookErr(result.errorMessage)}` };
+            return { ok: true, text: result.result ?? "" };
+        }
+        catch (e) {
+            return { ok: false, error: String(e) };
+        }
+    };
+    const clipHookErr = (s) => (s ?? "").slice(0, 300);
+    const titleCapable = sessionStore;
+    const sessionTitler = config.sessionAutoTitle && titleCapable.setTitleIfNull && titleCapable.probeTitle
+        ? createSessionTitler({
+            setTitleIfNull: titleCapable.setTitleIfNull.bind(sessionStore),
+            probeTitle: titleCapable.probeTitle.bind(sessionStore),
+            redact: redactSecrets,
+            llm: (o) => hookLlm({ prompt: o.prompt, timeoutMs: o.timeoutMs }),
+            logger,
+            metrics,
+        })
+        : undefined;
+    if (sessionTitler)
+        logger.info("session_auto_title_enabled", {});
+    const workflowsCapable = workflowsCapability(runnerDeps);
+    const subRunner = new Runner({ brain, models: config.models, roles: config.roles, pricing, tracer, ...(executionEnvFactory ? { executionEnvFactory } : {}), ...(lspManager ? { lspManager } : {}) });
+    const authorize = createAuthorizer(config, sessionStore);
+    const runStore = backend ? backend.run() : undefined;
+    const resumeAnchorStore = backend ? backend.resumeAnchor() : undefined;
+    const approvalExemptionStore = backend ? backend.approvalExemption() : undefined;
+    const instanceId = uuidv7();
+    const taskTimeoutSec = Math.max(0, Math.floor(Number(process.env.TASK_TIMEOUT_SEC ?? "0")) || 0);
+    const approvalStore = backend?.approval ? backend.approval() : undefined;
+    const approvalEnabled = approvalStore && config.approvalRequire.length > 0;
+    const operatorGateIntent = config.approvalRequire.length > 0 || config.approvalDeny.length > 0 || config.durableApproval;
+    const singleUserAutoAcceptBaseline = config.requirePrincipal !== true && !operatorGateIntent;
+    const checkpointStore = backend?.checkpoint && config.durableApproval ? backend.checkpoint(logger) : undefined;
+    await reclaimOrphansAtBoot(runStore, checkpointStore, logger);
+    const imageIndex = backend?.imageIndex ? backend.imageIndex() : undefined;
+    const selectEnvTool = config.selectEnvironmentTool && config.remoteExec?.provider === "k8s" && imageIndex
+        ? selectEnvironmentTool({
+            catalog: imageIndex,
+            selection: sessionEnvSelection,
+            viewerFor: (principal) => ({ operator: explicitOperator(principal, config.operatorPrincipals), tenantId: principal ?? null }),
+        })
+        : undefined;
+    const imageBakes = backend?.imageBake && config.imageBakes.enabled ? backend.imageBake() : undefined;
+    if (imageBakes)
+        logger.info("image_bakes_enabled", { operators: config.operatorPrincipals.length, runner: config.imageBakes.runnerPrincipal });
+    const durableEnabled = !!checkpointStore;
+    if (durableEnabled)
+        logger.info("durable_approval_enabled", { toolApprovalGate: config.approvalRequire.length });
+    if (singleUserAutoAcceptBaseline) {
+        logger.info("tool_policy_single_user_default", {
+            posture: "adjudicated auto-accept — ALL write/hand/MCP tool surfaces auto-allowed (core per-surface UNGATED enumeration suppressed for single-user turnkey)",
+            tighten: "APPROVAL_REQUIRE / AUTONOMY / commandPolicy (re-surfaces + gates specific surfaces)",
+        });
+    }
+    if (config.directDoorActive)
+        logger.info("direct_door_active", { iss: config.principalJwtIss, aud: config.principalJwtAud, operators: config.operatorPrincipals.length });
+    if (config.requirePrincipal && config.selfOrchestrationEnabled && !config.selfOrchestrationWorkerIsolation)
+        logger.warn("self_orchestration_no_worker_isolation", { detail: "multi-tenant self-orchestration without SELF_ORCHESTRATION_WORKER_ISOLATION=true — a tenant workflow can starve the host event loop (availability risk). Set it to enable worker_thread resource isolation." });
+    if (config.requirePrincipal && !config.authToken && Object.keys(config.authTokens ?? {}).length === 0 && !config.traceToken)
+        logger.warn("multi_tenant_no_service_token", { detail: "REQUIRE_PRINCIPAL is on but no SERVICE_AUTH_TOKEN/authTokens/TRACE_TOKEN — fleet/trace/session-list are owner-gated only (never fleet-wide, tenant-isolation safe). Set a token for cross-tenant ops visibility." });
+    const rateLimiter = config.rateLimitPerMin > 0
+        ? backend?.rateLimiter
+            ? backend.rateLimiter(config.rateLimitPerMin, counterDegradeHook).startRefresh()
+            : new RateLimiter(config.rateLimitPerMin)
+        : undefined;
+    let skills = loadSkills(config.skillsDir);
+    if (effective?.skills && config.configCenter) {
+        skills = await applyCenterSkills(skills, effective.skills, config.configCenter.baseUrl, config.configCenter.token, logger);
+    }
+    if (effective?.mcp)
+        config.mcpServers = resolveMcpServers(effective.mcp, logger);
+    const repoClient = config.gitApiBaseUrl ? new GiteaClient(config.gitApiBaseUrl, config.gitApiToken) : undefined;
+    const webSearchCfg = webSearchConfigFromEnv();
+    const webSearch = webSearchCfg ? createWebSearchBackend(webSearchCfg) : undefined;
+    if (webSearch)
+        logger.info(`WebSearch enabled (provider=${webSearchCfg.provider}, maxResults=${webSearch.maxResults})`);
+    const scenarioDeps = { runner, subRunner, model: "default", skills, repoClient, requirePrincipal: config.requirePrincipal, ...(webSearch ? { webSearch } : {}), metrics, logger, oaApiBaseUrl: config.oaApiBaseUrl, oaServiceToken: config.oaServiceToken, oaIssue: config.oaIssue, brandIdentity: config.configProvider === "local" };
+    const scenarios = buildScenarios(scenarioDeps);
+    const scenarioDetails = builtinScenarioDetails(scenarios, scenarioDeps);
+    const builtinScenarioNames = Object.keys(scenarioDetails);
+    if (effective?.scenarios) {
+        const { overlay, shadows } = centerScenarios(scenarioDeps, effective.scenarios.scenarios, Object.keys(scenarios), logger);
+        Object.assign(scenarios, overlay);
+        Object.assign(scenarioDetails, centerScenarioDetails(effective.scenarios.scenarios, builtinScenarioNames));
+        if (Object.keys(overlay).length > 0)
+            logger.info("sema_registry_scenarios", { scenarios: Object.keys(overlay), ...(shadows.length > 0 ? { shadowsBuiltin: shadows } : {}) });
+    }
+    logger.info("capabilities", { skills: skills.length, scenarios: Object.keys(scenarios), repoTools: Boolean(repoClient) });
+    let runDenySweep;
+    const reapCount = (metric, labels) => (n) => {
+        if (typeof n === "number" && n > 0) {
+            metrics.inc(metric, labels, n);
+            logger.info("reaper_swept", { metric, ...labels, count: n });
+        }
+    };
+    let wfRunReapInFlight = false;
+    const probeClockSkew = async () => {
+        try {
+            const dbMs = await backend?.dbNowMs?.();
+            if (typeof dbMs === "number" && Number.isFinite(dbMs)) {
+                metrics.setGauge("fleet_counter_bucket_skew_ms", dbMs - Date.now());
+                metrics.setGauge("fleet_clock_probe_ok", 1);
+            }
+        }
+        catch {
+            metrics.setGauge("fleet_clock_probe_ok", 0);
+        }
+    };
+    const reaper = setInterval(() => {
+        void probeClockSkew().catch(() => undefined);
+        void runStore?.reapStale(config.runStaleSec * 1000).then(reapCount("runs_reaped_total", { kind: "stale" })).catch(() => undefined);
+        if (checkpointStore) {
+            void checkpointStore.reapExpired(Date.now()).then(reapCount("checkpoints_reaped_total", {})).catch(() => undefined);
+            void runStore?.failSuspendedWithExpiredCheckpoint().then(reapCount("runs_reaped_total", { kind: "expired_checkpoint" })).catch(() => undefined);
+            void runDenySweep?.(Date.now()).catch(() => undefined);
+        }
+        if (config.approvalTimeoutSec > 0) {
+            void approvalStore?.expireStale(config.approvalTimeoutSec * 1000).catch(() => undefined);
+            void runStore?.reapSuspended(config.approvalTimeoutSec * 1000).then(reapCount("runs_reaped_total", { kind: "suspended" })).catch(() => undefined);
+        }
+        void checkpointStore?.reapCtx(Date.now() - config.runStaleSec * 1000).catch(() => undefined);
+        rateLimiter?.sweep();
+        if (costQuota instanceof CostQuota)
+            costQuota.reap();
+        void toolResultStore?.reapOlderThan?.(Date.now() - config.toolResultTtlSec * 1000)?.catch(() => undefined);
+        void fileSnapshotStore?.sweepOrphanBlobs?.().catch(() => undefined);
+        void backend?.session()?.sweepStagingSessions?.().catch(() => undefined);
+        void imageBakes?.reapStaleBakes(config.imageBakes.staleMs).then(reapCount("bakes_reaped_total", {})).catch(() => undefined);
+        void worktreeReap?.();
+        void workflowNotifyGate?.recover({ orphanGraceMs: config.workflowOrphanGraceMs }).catch(() => undefined);
+        void workflowJournalStore?.reapExpired?.(Date.now(), config.workflowJournalRetentionMs).catch(() => undefined);
+        if (!wfRunReapInFlight) {
+            const sweep = sqlWorkflowRunStore?.reapAllScopes?.(Date.now(), { maxAgeMs: config.workflowRunRetentionMs });
+            if (sweep) {
+                wfRunReapInFlight = true;
+                void sweep.catch(() => undefined).finally(() => (wfRunReapInFlight = false));
+            }
+            void workflowNotifyJournal
+                ?.reapAcked?.(Date.now() - config.workflowRunRetentionMs)
+                .catch(() => undefined);
+        }
+    }, config.reapIntervalSec * 1000);
+    reaper.unref?.();
+    const otelExporter = config.otel
+        ? startOtlpExporter(metrics, {
+            ...config.otel,
+            onError: (err) => logger.warn("otel_export_failed", { err: String(err) }),
+        })
+        : undefined;
+    if (config.configCenter) {
+        const cc = config.configCenter;
+        const ccTimer = setInterval(() => {
+            void (async () => {
+                try {
+                    const r = await fetchEffective(cc.baseUrl, cc.token, ccEtag, undefined, cc.worker);
+                    if (r) {
+                        ccEtag = r.etag;
+                        if (cc.dryRun) {
+                            logEffectiveDiff(config, r.effective, logger);
+                        }
+                        else {
+                            applyEffective(config, r.effective, logger, { teamsOnly: true, sealedKeys });
+                            markRosterLanded(r.effective);
+                            mutateInPlace(pricing, buildPricing(config.models));
+                            keyResolver = buildKeyResolver(config.modelApiKeyEnv, process.env, config.modelApiKeys);
+                            const reasons = restartReasons(effective, r.effective);
+                            if (reasons.length === 0) {
+                                pendingRestart = undefined;
+                            }
+                            else if (!pendingRestart || pendingRestart.reasons.join(",") !== reasons.join(",")) {
+                                pendingRestart = { restartRequired: true, reasons, version: r.effective.version, since: Date.now() };
+                            }
+                            else {
+                                pendingRestart = { ...pendingRestart, version: r.effective.version };
+                            }
+                            logger.info("sema_registry_refreshed", {
+                                version: r.effective.version,
+                                note: "teams + runtime governance + models/roles/roster hot-applied; skills/mcp/runtime-gates/scenarios are restart-to-apply",
+                                ...(pendingRestart ? { restartRequired: true, restartReasons: pendingRestart.reasons } : {}),
+                            });
+                        }
+                    }
+                }
+                catch (err) {
+                    logger.warn("sema_registry_refresh_failed", { err: String(err) });
+                }
+            })();
+        }, 60_000);
+        ccTimer.unref?.();
+    }
+    let keyResolver = buildKeyResolver(config.modelApiKeyEnv, process.env, config.modelApiKeys);
+    const mysqlPool = backend?.mysqlPool();
+    const auditPgPool = backend?.pgPool();
+    const auditLocalRoot = backend?.kind === "local" ? (config.localDataRoot ?? localRoot) : undefined;
+    const ownerAware = sessionStore;
+    const sessionAudit = mysqlPool || auditPgPool || auditLocalRoot
+        ? async (sessionId) => {
+            const audit = mysqlPool
+                ? await buildSessionAudit(mysqlPool, sessionId)
+                : auditPgPool
+                    ? await buildSessionAuditPg(auditPgPool, sessionId)
+                    : await buildSessionAuditLocal(auditLocalRoot, sessionId);
+            if (!audit)
+                return undefined;
+            return { ...audit, owner: (await ownerAware.ownerOf?.(sessionId)) ?? null };
+        }
+        : undefined;
+    const purgeSession = ownerAware.deleteSession
+        ? async (sessionId, owner) => {
+            const runs = runStore ? await runStore.deleteBySession(sessionId, owner) : { removed: 0 };
+            if ("active" in runs)
+                return { active: runs.active };
+            if (checkpointStore)
+                await checkpointStore.deleteBySession(sessionId, owner);
+            if (toolResultStore)
+                await toolResultStore.deleteBySession?.(sessionId);
+            if (resumeAnchorStore)
+                await resumeAnchorStore.deleteBySession(sessionId);
+            if (approvalExemptionStore)
+                await approvalExemptionStore.deleteBySession(sessionId);
+            if (sessionPolicyStore?.deleteBySession)
+                await sessionPolicyStore.deleteBySession(sessionId);
+            if (fileSnapshotStore?.deleteBySession)
+                await fileSnapshotStore.deleteBySession(sessionId);
+            if (workflowCompletionInbox)
+                await workflowCompletionInbox.purge(sessionId, owner ?? null).catch((err) => logger.warn("workflow_completion_inbox_purge_failed", { sessionId, err: String(err) }));
+            try {
+                const reaped = defaultTaskRegistry.reapSessionBackground(sessionId);
+                if (reaped > 0)
+                    logger.info("session_background_reaped", { sessionId, reaped });
+            }
+            catch (err) {
+                logger.warn("session_background_reap_failed", { sessionId, err: String(err) });
+            }
+            const historyDeleted = await ownerAware.deleteSession(sessionId, owner);
+            return { deleted: historyDeleted || runs.removed > 0 };
+        }
+        : undefined;
+    const instrumentDegenerate = mysqlPool ? makeDegenerateInstrument(mysqlPool, metrics, logger) : undefined;
+    const planCacheProbe = new PlanCacheProbe(metrics, logger);
+    const leaderMinio = process.env.MINIO_ENDPOINT && process.env.MINIO_ACCESS_KEY && process.env.MINIO_SECRET_KEY
+        ? {
+            s3: {
+                endpoint: process.env.MINIO_ENDPOINT,
+                bucket: process.env.MINIO_BUCKET ?? "workspaces",
+                accessKey: process.env.MINIO_ACCESS_KEY,
+                secretKey: process.env.MINIO_SECRET_KEY,
+                ...(process.env.MINIO_REGION ? { region: process.env.MINIO_REGION } : {}),
+            },
+        }
+        : {};
+    const leaderProvider = config.remoteExec?.provider;
+    const leaderEndpoint = config.leaderEnabled &&
+        (leaderProvider === "e2b" ||
+            (leaderProvider === "k8s" && "s3" in leaderMinio && executionEnvFactory) ||
+            (leaderProvider === "host" && executionEnvFactory))
+        ? createLeaderEndpoint(buildLeaderRunner({
+            brain, models: config.models, roles: config.roles, pricing, logger,
+            fanoutEnabled: config.leaderFanoutEnabled,
+            ...((process.env.MODEL_ROUTER_ID || process.env.MODEL_CHEAP_ID)
+                ? { routerModel: (process.env.MODEL_ROUTER_ID || process.env.MODEL_CHEAP_ID) }
+                : {}),
+            ...(leaderProvider === "e2b" ? { e2bApiKey: config.remoteExec.apiKey } : {}),
+            ...(executionEnvFactory ? { envFactory: executionEnvFactory } : {}),
+            ...leaderMinio,
+            ...(toolResultStore ? { toolResultStore } : {}),
+            ...(leaderProvider === "k8s" ? { workspace: "/workspace" } : {}),
+            sessionStore,
+            ...(checkpointStore && config.approvalRequire.length > 0
+                ? {
+                    durable: {
+                        checkpointStore,
+                        requireApproval: config.approvalRequire,
+                        deny: config.approvalDeny,
+                        autoBudget: config.approvalAutoBudget,
+                        neverAuto: config.approvalNeverAuto,
+                        ...(config.approvalTimeoutSec > 0 ? { ttlMs: config.approvalTimeoutSec * 1000 } : {}),
+                    },
+                }
+                : {}),
+        }), { logger })
+        : undefined;
+    if (leaderEndpoint)
+        logger.info("leader_endpoint_enabled", { provider: leaderProvider, mode: "s3" in leaderMinio ? "factory" : "static" });
+    const drainState = { draining: false };
+    const authBridgeIssuer = process.env.AUTH_BRIDGE_ISSUER || config.configCenter?.baseUrl;
+    const registryJwtVerifier = authBridgeIssuer
+        ? createRegistryJwtVerifier({
+            issuer: authBridgeIssuer,
+            ...(process.env.AUTH_BRIDGE_JWKS_URL ? { jwksUrl: process.env.AUTH_BRIDGE_JWKS_URL } : {}),
+            ...(process.env.AUTH_BRIDGE_AUDIENCE ? { audience: process.env.AUTH_BRIDGE_AUDIENCE } : {}),
+            logger,
+            metrics,
+        })
+        : undefined;
+    if (registryJwtVerifier)
+        logger.info("auth_bridge_enabled", { issuer: authBridgeIssuer });
+    const hookWakeBus = {};
+    const server = createHttpServer({
+        runner,
+        config,
+        authorize,
+        sessionStoreLabel: config.sessionBackend === "tidb" && backend ? `durable(${backend.kind})` : config.sessionBackend,
+        modelReady: () => modelReadyState.ready,
+        scenarioDetails,
+        ...(registryJwtVerifier ? { registryJwtVerifier } : {}),
+        hookWakeBus,
+        runStore,
+        fleetBus,
+        workflowsCapable,
+        ...(resumeAnchorStore ? { resumeAnchorStore } : {}),
+        ...(approvalExemptionStore ? { approvalExemptionStore } : {}),
+        ...(sessionTitler ? { sessionTitler } : {}),
+        ...(sessionPolicyStore ? { sessionPolicyStore } : {}),
+        ...(fileSnapshotStore ? { fileSnapshotStore } : {}),
+        ...(backend ? { backend } : {}),
+        ...(principalCaps
+            ? { sessionMirrorRuling: async (p) => (await principalCaps.executionRuling(p))?.sessionMirror }
+            : {}),
+        approvalStore,
+        checkpointStore,
+        imageIndex,
+        imageBakes,
+        leaderEndpoint,
+        ...(workflowRunStore ? { workflowRunStore } : {}),
+        ...(workflowAgentRegistry ? { workflowAgentRegistry } : {}),
+        subagentSteerRegistry,
+        ...(workflowCompletionInbox ? { workflowCompletionInbox } : {}),
+        sessionAudit,
+        sessionStorage: ownerAware,
+        ...(purgeSession ? { purgeSession } : {}),
+        instrumentDegenerate,
+        planCacheProbe,
+        modelUsage: modelUsageTracker,
+        ...(elicitation ? { elicitation } : {}),
+        ...(question ? { question } : {}),
+        instanceId,
+        logger,
+        metrics,
+        rateLimiter,
+        costQuota,
+        ...(fleetLease ? { fleetLease } : {}),
+        ...(outcomeSink ? { outcomeSink } : {}),
+        ...(memoryExportBackend ? { memoryExport: (scope) => exportMemoryScope(memoryExportBackend, scope) } : {}),
+        ...(memoryExportBackend && memorySyncCursors
+            ? { memorySync: (scope, syncReq) => performMemorySync(memoryExportBackend, memorySyncCursors, scope, syncReq) }
+            : {}),
+        capabilities: {
+            version: serviceVersion(),
+            scenarios: Object.keys(scenarios),
+            pricingConfigured: Object.values(pricing).some((p) => Object.values(p).some((v) => typeof v === "number" && v > 0)),
+        },
+        restartState: () => pendingRestart,
+        drainState,
+        storeDegraded: storeBackendDegraded,
+        resolveSpec: async (body, _req, auth) => {
+            const requested = gateScenarioRequest(await principalCaps?.scenarioRuling(auth?.principal), body.scenario, config.defaultScenario);
+            gateExecutionLane(await principalCaps?.executionRuling(auth?.principal), config.remoteExec?.provider ?? "in-process");
+            const scenarioName = scenarios[requested] ? requested : "default";
+            const cap = selectScenario(scenarios, scenarioName)(body, auth?.principal);
+            const objective = typeof body.objective === "string" ? body.objective : "";
+            const parsedSettings = parseTaskSettings(body.settings);
+            if (parsedSettings.deferred.length > 0) {
+                logger.warn("task_settings_deferred", { fields: parsedSettings.deferred, sessionId: auth?.sessionId ?? null });
+            }
+            if (typeof body.cwd === "string" && body.cwd.length > 0 && auth?.sessionId) {
+                if (cwdHonored(config) && isValidCwd(body.cwd))
+                    setSessionCwd(auth.sessionId, body.cwd);
+                else
+                    logger.warn("task_cwd_ignored", { honored: cwdHonored(config), sessionId: auth.sessionId });
+            }
+            if (parsedSettings.settings?.shellEnv && auth?.sessionId) {
+                if (cwdHonored(config))
+                    setSessionShellEnv(auth.sessionId, parsedSettings.settings.shellEnv);
+                else
+                    logger.warn("task_shell_env_ignored", { honored: cwdHonored(config), sessionId: auth.sessionId });
+            }
+            const taskHooks = (() => {
+                const hc = parsedSettings.settings?.hooks;
+                if (!hc)
+                    return undefined;
+                if (config.requirePrincipal === true) {
+                    logger.warn("task_hooks_ignored", { honored: false, sessionId: auth?.sessionId ?? null });
+                    return undefined;
+                }
+                const effMode = coercePermissionMode(body.permissionMode) ?? parsedSettings.settings?.permissions?.defaultMode;
+                return buildTaskHooks(hc, {
+                    logger,
+                    sessionId: auth?.sessionId ?? "",
+                    cwd: (auth?.sessionId ? perSessionCwd.get(auth.sessionId) : undefined) ?? process.cwd(),
+                    ...(effMode ? { permissionMode: effMode } : {}),
+                    ...(parsedSettings.settings?.shellEnv ? { shellEnv: parsedSettings.settings.shellEnv } : {}),
+                    hookLlm,
+                    hookAgent,
+                    ...(auth?.sessionId
+                        ? {
+                            wake: async (text) => hookWakeBus.deliver
+                                ?
+                                    hookWakeBus.deliver(auth.sessionId, `[hook asyncRewake] ${redactSecrets(text)}`)
+                                : false,
+                        }
+                        : {}),
+                });
+            })();
+            const rawAddDirs = body.additionalDirectories;
+            const additionalDirectories = cwdHonored(config) ? parseAdditionalDirectories(rawAddDirs) : undefined;
+            if (rawAddDirs !== undefined && !cwdHonored(config)) {
+                logger.warn("task_additional_directories_ignored", { honored: false, sessionId: auth?.sessionId ?? null });
+            }
+            const wireCatalog = expandTiers(config.models, config.tiers) ?? config.models;
+            const picked = resolveTaskModel(body.model ?? parsedSettings.settings?.model, objective, wireCatalog);
+            if (Array.isArray(body.images) && body.images.length > 0 && !modelSupportsImages(wireCatalog[picked.model])) {
+                metrics.inc("images_omitted_total", { model: picked.model });
+                logger.warn("images_omitted_no_vision_model", { model: picked.model, count: body.images.length });
+            }
+            let resumeAtEntryId;
+            if (typeof body.resumeAt === "string" && body.resumeAt.length > 0) {
+                if (!auth?.sessionId)
+                    throw new HttpError(422, "resumeAt requires a session to branch (resume_at.no_session)");
+                if (!resumeAnchorStore || !ownerAware.getLeafId)
+                    throw new HttpError(501, "resume-at is not available on this worker (no session-store backend for the anchor map)");
+                resumeAtEntryId = await resumeAnchorStore.resolve(auth.sessionId, body.resumeAt, auth.principal ?? null);
+                if (resumeAtEntryId === undefined)
+                    throw new HttpError(404, "resumeAt: no such message in this session (resume_at.unknown_event)");
+            }
+            let rewindFilesToEntryId;
+            if (resumeAtEntryId === undefined && typeof body.rewindFilesTo === "string" && body.rewindFilesTo.length > 0) {
+                if (!auth?.sessionId)
+                    throw new HttpError(422, "rewindFilesTo requires a session (rewind_files_to.no_session)");
+                if (!resumeAnchorStore || !ownerAware.getLeafId)
+                    throw new HttpError(501, "rewind-files-to is not available on this worker (no session-store backend for the anchor map)");
+                rewindFilesToEntryId = await resumeAnchorStore.resolve(auth.sessionId, body.rewindFilesTo, auth.principal ?? null);
+                if (rewindFilesToEntryId === undefined)
+                    throw new HttpError(404, "rewindFilesTo: no such message in this session (rewind_files_to.unknown_event)");
+            }
+            const s4ProjectId = auth?.resolvedProjectId ?? (typeof body.projectId === "string" && body.projectId ? body.projectId : undefined);
+            const s4DefaultScopes = s4ProjectId ? config.projects[s4ProjectId]?.defaultScopes : undefined;
+            const spec = {
+                objective: picked.cleanedObjective,
+                systemPrompt: typeof body.systemPrompt === "string" ? body.systemPrompt : undefined,
+                sessionId: auth?.sessionId,
+                principal: auth?.principal,
+                images: body.images,
+                ...(body.clientContext ? { clientContext: { timeZone: body.clientContext.timeZone, userEmail: body.clientContext.userEmail } } : {}),
+                outputSchema: body.outputSchema,
+                resumeAt: resumeAtEntryId,
+                requireExistingSession: body.requireExistingSession === true ? true : undefined,
+                enableFork: enableForkFromBody(body, config, Boolean(centerRuntimeCapsResolver)),
+                suggestNextPrompts: normalizeSuggestNextPrompts(body.suggestNextPrompts),
+                rewindFiles: body.rewindFiles === true ? true : undefined,
+                rewindFilesTo: rewindFilesToEntryId,
+                additionalDirectories,
+                enablePlanMode: config.planModeEnabled ? true : undefined,
+                selfOrchestration: selfOrchestrationFromBody({ selfOrchestration: body.selfOrchestration === true || parsedSettings.settings?.ultracode === true }, config, Boolean(centerRuntimeCapsResolver)),
+                forwardSubagentEvents: body.forwardSubagentEvents === true ? true : undefined,
+                retainSubagentSessions: normalizeRetainSubagentSessions(body.retainSubagentSessions),
+                resilience: normalizeResilience(body.resilience, explicitOperator(auth?.principal, config.operatorPrincipals)),
+                finalVerification: body.finalVerification === true ? true : undefined,
+                attachments: normalizeAttachments(body.attachments),
+                ...(taskHooks ? { hooks: composeHooks(deploymentHooks, taskHooks) } : {}),
+                model: picked.model,
+                thinking: effectiveThinking(body.reasoningEffort, parsedSettings.settings?.ultracode === true),
+                getApiKeyAndHeaders: keyResolver,
+                ...(() => {
+                    const wall = taskWallClockSec(taskTimeoutSec, config.requirePrincipal, body.council === true || body.debate === true || scenarioName === "team");
+                    return wall !== undefined ? { limits: { timeoutSec: wall } } : {};
+                })(),
+                ...(config.requirePrincipal !== true ? { backgroundScope: "session" } : {}),
+                maxCostUsd: cappedCeiling(body.maxCostUsd, config.maxTaskCostUsd),
+                maxTokens: cappedCeiling(body.maxTokens, config.maxTaskTokens),
+                degrade: (() => {
+                    if (!config.degrade || cappedCeiling(body.maxCostUsd, config.maxTaskCostUsd) === undefined)
+                        return undefined;
+                    if (Array.isArray(body.images) && body.images.length > 0 && !config.degrade.toSupportsImages) {
+                        metrics.inc("degrade_dropped_total", { reason: "vision_target" });
+                        logger.warn("degrade_dropped", { reason: "vision_target", model: picked.model, images: body.images.length });
+                        return undefined;
+                    }
+                    return { to: config.degrade.to, atCostFraction: config.degrade.atCostFraction };
+                })(),
+                memory: memoryEngine ? memorySpecForRequest(auth?.memoryScope, body.memoryWrite, s4DefaultScopes) : undefined,
+                tools: selectEnvTool ? [...(cap.tools ?? []), selectEnvTool] : cap.tools,
+                skills: mergeUserSkills(cap.skills, body.skills, logger),
+                mcp: resolveRequestMcp(mcpForScenario(config.mcpServers, scenarioName), body.mcpServers, config, logger),
+                promptProvider: cap.promptProvider,
+                toolPolicy: durableEnabled
+                    ? combinePolicies(createDurableQuestionPolicy(), createDurableAskPolicy({
+                        requireApproval: config.approvalRequire, deny: config.approvalDeny, autoBudget: config.approvalAutoBudget, neverAuto: config.approvalNeverAuto,
+                        ...(approvalExemptionStore && auth?.sessionId
+                            ? {
+                                exempt: (toolName) => approvalExemptionStore.has(auth.sessionId, toolName),
+                                onExempted: (toolName, rawToolName) => logger.info("approval_exempted", { sessionId: auth.sessionId, toolName, rawToolName }),
+                            }
+                            : {}),
+                    }))
+                    : approvalEnabled && approvalStore
+                        ? createOaApprovalPolicy({
+                            store: approvalStore,
+                            requireApproval: config.approvalRequire,
+                            deny: config.approvalDeny,
+                            pollMs: config.approvalPollMs,
+                            context: () => ({ sessionId: auth?.sessionId ?? null, owner: auth?.principal ?? null }),
+                            neverAuto: config.approvalNeverAuto,
+                            ...(approvalExemptionStore
+                                ? {
+                                    exempt: (sessionId, toolName) => approvalExemptionStore.has(sessionId, toolName),
+                                    onExempted: (sessionId, toolName) => logger.info("approval_exempted", { sessionId, toolName }),
+                                }
+                                : {}),
+                        })
+                        : singleUserAutoAcceptBaseline
+                            ? createAllowDenyPolicy({})
+                            : undefined,
+                ...(durableEnabled
+                    ? {
+                        checkpointStore,
+                        durableApproval: {
+                            scope: auth?.principal ?? "_",
+                            ...(config.approvalTimeoutSec > 0 ? { ttlMs: config.approvalTimeoutSec * 1000 } : {}),
+                        },
+                        ...((rs) => (rs ? { resourceSuspend: rs } : {}))(resourceSuspendOptIn({
+                            enabled: config.resourceSuspend,
+                            ttlSec: config.resourceSuspendTtlSec,
+                            isVerify: body.verify === true,
+                            isCascade: body.cascade === true,
+                            scope: auth?.principal ?? "_",
+                        })),
+                        onQuestion: QUESTION_AWAITS_RESUME,
+                    }
+                    : {}),
+            };
+            const governedBase = applyRuntimeGovernance(spec, { autonomy: config.autonomy, commandPolicy: config.commandPolicy });
+            let governed = governedBase;
+            const bodyMode = coercePermissionMode(body.permissionMode);
+            const effectiveSettings = bodyMode ? withPermissionMode(parsedSettings.settings, bodyMode) : parsedSettings.settings;
+            if (effectiveSettings) {
+                try {
+                    governed = applyTaskSettings(governedBase, effectiveSettings);
+                }
+                catch (e) {
+                    throw new HttpError(422, `settings are tighten-only and cannot loosen the deployment policy: ${e.message}`);
+                }
+            }
+            if (governed.handsReadOnly === true && Array.isArray(governed.tools)) {
+                governed = { ...governed, tools: stripDelegationTools(governed.tools) };
+            }
+            const bodyProfile = typeof body.sandboxImageProfile === "string" && body.sandboxImageProfile.length > 0 ? body.sandboxImageProfile : undefined;
+            const taskImageProfile = bodyProfile ?? (body.cascade === true || body.verify === true ? undefined : sessionEnvSelection.get(auth?.sessionId));
+            let resolvedImageCaps;
+            if (taskImageProfile !== undefined) {
+                if (config.remoteExec?.provider !== "k8s") {
+                    throw new HttpError(400, "sandboxImageProfile is only supported on the k8s sandbox backend");
+                }
+                if (!imageIndex) {
+                    throw new HttpError(400, "sandboxImageProfile requires the image index (sema-registry backend not configured)");
+                }
+                if (!auth?.sessionId) {
+                    throw new HttpError(400, "sandboxImageProfile requires a resolved session");
+                }
+                const capsNeeded = Array.isArray(body.capabilitiesNeeded)
+                    ? body.capabilitiesNeeded.filter((c) => typeof c === "string")
+                    : undefined;
+                const resolved = await resolveSandboxImageRef({
+                    profile: taskImageProfile,
+                    ...(capsNeeded && capsNeeded.length > 0 ? { capabilitiesNeeded: capsNeeded } : {}),
+                    viewer: { operator: explicitOperator(auth.principal, config.operatorPrincipals), tenantId: auth.principal ?? null },
+                    index: imageIndex,
+                });
+                if (!resolved.ok)
+                    throw new HttpError(resolved.status, resolved.message);
+                perTaskImage.set(auth.sessionId, resolved.ref);
+                resolvedImageCaps = resolved.capabilities;
+            }
+            if (config.envFactsEnabled) {
+                const pkgSourceLane = config.remoteExec?.provider === "e2b" || config.remoteExec?.provider === "k8s";
+                const facts = buildEnvFacts({
+                    profile: taskImageProfile,
+                    capabilities: resolvedImageCaps,
+                    ...(pkgSourceLane ? { pkgSource: config.sandboxPkgSource } : {}),
+                    egress: egressForRemoteExec(config.remoteExec),
+                });
+                if (facts)
+                    governed = { ...governed, envFacts: facts };
+            }
+            if (config.routerEnabled) {
+                const isolatedExecEnv = isIsolatedExecEnv(config.remoteExec?.provider, config.remoteExec?.provider === "k8s" ? config.remoteExec.runtimeClass : undefined);
+                const decision = routeServiceTask({
+                    isolatedExecEnv,
+                    hasExecutionEnv: config.remoteExec != null,
+                    ...(config.autonomy ? { autonomy: config.autonomy } : {}),
+                    explicitTeam: body.council === true || body.debate === true || scenarioName === "team",
+                });
+                logger.info("orchestration_routed", { mode: decision.mode, reason: decision.reason, sessionId: auth?.sessionId ?? null });
+                if (decision.mode === "supervisor") {
+                    return tightenTaskSpec(governed, supPostureOverrides());
+                }
+            }
+            return governed;
+        },
+    });
+    runDenySweep = server.denyExpiredApprovals;
+    await new Promise((resolve) => server.listen(config.port, resolve));
+    const fleetClient = startFleetClientFromEnv(config, {
+        instanceId,
+        version: serviceVersion(),
+        isDraining: () => drainState.draining,
+        ...(fleetUsage ? { usage: fleetUsage } : {}),
+        logger: { info: (m, d) => logger.info(m, d ?? {}), warn: (m, d) => logger.warn(m, d ?? {}) },
+    });
+    if (fleetClient)
+        logger.info("fleet_client_started", { worker: config.configCenter?.worker, address: process.env.FLEET_ADVERTISE_ADDRESS });
+    logger.info("listening", {
+        port: config.port,
+        model: config.model.id,
+        brain: brainSummary(config),
+        breakerState: config.resilience.circuitBreaker ? (breakerState ? `shared(${backend.kind})` : "in-process") : "off",
+        session: config.sessionBackend === "tidb" && backend ? `durable(${backend.kind})` : config.sessionBackend,
+        memory: memoryEngine ? `engine(${memoryEngine.root})` : "off",
+        instanceId,
+        rateLimitPerMin: config.rateLimitPerMin,
+        rateLimit: config.rateLimitPerMin > 0 ? (backend ? `shared()` : "in-process") : "off",
+        maxPrincipalCostUsd: config.maxPrincipalCostUsd || null,
+        costQuota: config.maxPrincipalCostUsd > 0 ? (backend ? `shared()` : "in-process") : "off",
+        toolResultStore: toolResultStore ? (backend?.kind === "local" ? "file(local)" : "shared(sql)") : "in-process",
+        otel: config.otel ? config.otel.endpoint : null,
+        perModelKeys: Object.keys(config.modelApiKeyEnv).length,
+        sealedModelKeys: Object.keys(config.modelApiKeys).length,
+        workflowRunStore: config.selfOrchestrationEnabled
+            ? config.workflowRunStoreBackend === "memory"
+                ? "in-process"
+                : sqlWorkflowRunStore
+                    ? `db(${backend.kind})`
+                    : "file"
+            : "off",
+    });
+    if (workflowNotifyGate) {
+        void workflowNotifyGate
+            .recover({ orphanGraceMs: config.workflowOrphanGraceMs })
+            .then((tally) => logger.info("workflow_notify_recovered", tally))
+            .catch((err) => logger.warn("workflow_notify_recover_failed", { err: String(err) }));
+    }
+    let closing = false;
+    const hardShutdown = () => {
+        if (closing)
+            return;
+        closing = true;
+        clearInterval(reaper);
+        otelExporter?.stop();
+        breakerState?.stop();
+        if (costQuota && "stop" in costQuota)
+            costQuota.stop();
+        if (rateLimiter && "stop" in rateLimiter)
+            rateLimiter.stop();
+        runner.sessions.dispose();
+        subRunner.sessions.dispose();
+        void lspManager?.dispose?.();
+        void workflowNotifyJournal?.close?.();
+        try {
+            const reaped = defaultTaskRegistry.reapAllSessionBackground();
+            if (reaped > 0)
+                logger.info("shutdown_background_reaped", { reaped });
+        }
+        catch (err) {
+            logger.warn("shutdown_background_reap_failed", { err: String(err) });
+        }
+        void fleetClient?.stop();
+        server.close(() => {
+            void (backend ? backend.close() : Promise.resolve()).finally(() => process.exit(0));
+        });
+        const finalExit = setTimeout(() => { logger.warn("hard_shutdown_final_deadline", { afterMs: 15_000 }); process.exit(0); }, 15_000);
+        finalExit.unref?.();
+        server.closeIdleConnections?.();
+        const forceClose = setTimeout(() => server.closeAllConnections?.(), 10_000);
+        forceClose.unref?.();
+    };
+    let draining = false;
+    const drainThenShutdown = () => {
+        if (closing)
+            return;
+        if (draining) {
+            logger.info("drain_second_signal_hard_stop", {});
+            hardShutdown();
+            return;
+        }
+        draining = true;
+        drainState.draining = true;
+        drainState.since = Date.now();
+        void fleetClient?.announceNow();
+        const inflight = drainState.inflight?.() ?? 0;
+        logger.info("draining_started", { inflight, graceMs: config.drainGraceMs });
+        if (inflight === 0) {
+            hardShutdown();
+            return;
+        }
+        const t0 = Date.now();
+        const tick = setInterval(() => {
+            const n = drainState.inflight?.() ?? 0;
+            const elapsed = Date.now() - t0;
+            if (n === 0 || elapsed >= config.drainGraceMs) {
+                clearInterval(tick);
+                logger.info("drain_complete", { inflight: n, elapsedMs: elapsed, timedOut: n > 0 });
+                hardShutdown();
+            }
+        }, 1_000);
+    };
+    process.on("SIGTERM", drainThenShutdown);
+    process.on("SIGINT", hardShutdown);
+    process.on("SIGHUP", drainThenShutdown);
+}
+void main().catch((err) => {
+    createLogger().error("fatal", { err: String(err) });
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map