@sema-agent/server 7.79.1 → 7.79.3

package/dist/main.js

@@ -1,875 +1,25 @@
-import { readFileSync } from "node:fs";
-import { DEFAULT_MODEL_REF } from "./model-select.js";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { Runner, terminalProjection, createPermissionRuleStoreProvider, InMemoryToolResultStore, TtlSessionStore, uuidv7, defaultTaskRegistry, createAllowDenyPolicy, workflowsCapability, probeSearchBackend, describeStaticWiring, DEFAULT_SUBAGENT_TOOL_NAME } from "@sema-agent/core";
-import { createSessionTitler } from "./session-titler.js";
-import { posIntEnv } from "./session-watch.js";
-import { selectEnvironmentTool } from "./capabilities/select-environment-tool.js";
-import { subagentSendUserFileExtraTools } from "./capabilities/send-user-file-tool.js";
-import { brainSummary } from "./brain.js";
-import { loadConfig, logConfigDiagnostics, resolveBindHost, splitLocalRoots, parseCapEnv, parseNumOrFailNonNegative } from "./config.js";
-import { createUnpricedCeilingVerdict } from "./boot/unpriced-ceiling-verdict.js";
-import { buildWriteProtectionPosture } from "./write-protection.js";
-import { cardRuleScopeRoot } from "./task-cwd.js";
-import { isPricingConfigured } from "./budget.js";
-import { drainNumEnvWarnings } from "./plugins/remote-shell.js";
-import { ensureChildSessionDurableWithPromotion } from "./plugins/session-store.js";
-import { ForkRoutingSessionStore } from "./plugins/fork-routing-session-store.js";
-import { webSearchConfigFromEnv, createWebSearchBackend, setWebSearchBadPayloadObserver, shouldProbeWebSearchOnBoot } from "./plugins/web-search.js";
-import { createAuthorizer, encodeCheckpointScope } from "./security.js";
-import { assertGateIntentServiceable, buildForceDurableGateInertNotice, hasOperatorGateIntent } from "./approval.js";
-import { loadSkills } from "./capabilities/skills.js";
-import { createRepoClient } from "./capabilities/repo-tools.js";
-import { buildScenarios, builtinScenarioDetails } from "./capabilities/scenarios.js";
-import { createHandsRunnerSelector, withoutExecutionEnv } from "./capabilities/hands-lane.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 { installFailOpenRecorder } from "./observability/fail-open.js";
-import { installFileHistoryFailureRecorder } from "./file-history-disclosure.js";
-import { installSecretEnvScrubRecorder } from "./observability/secret-env-scrub.js";
-import { setRunTerminalObserver } from "./observability/run-terminal-log.js";
-import { setRedactionObserver, redactSecrets } from "./trace/redact.js";
-import { RateLimiter } from "./observability/rate-limit.js";
-import { createHttpServer, explicitOperatorOk, hasServiceAuth } from "./http/server.js";
-import { exportMemoryScope } from "./memory-export.js";
-import { workflowModelAllowlistFor, selfOrchestrationDenial } from "./task-workflow.js";
-import { centerEntitlementSourceWired } from "./runtime-caps-resolver.js";
-import { createMemoryBundleFaces } from "./memory-bundle-engine.js";
-import { backendOwnsControlPlane, createMemoryComplianceFaces, createMemoryOriginFaces, createSessionMemoryStatusFace } from "./memory-operator-faces.js";
-import { performMemorySync } from "./memory-sync.js";
-import { startOtlpExporter } from "./observability/otel-exporter.js";
-import { HEARTBEAT_MS, backgroundAgentOutput, taskHandleOutput, taskHandleStop } from "./runs.js";
-import { SQL_BLOB_DEFAULT_MAX_BYTES } from "./plugins/blob-backend.js";
-import { createStoreLiveProbe } from "./store-live-probe.js";
-import { counterStoreLabel } from "./plugins/store-backend.js";
-import { composeHooks } from "./hooks/hook-runner.js";
-import { createHookLlm } from "./hooks/hook-llm.js";
-import { startFleetClientFromEnv } from "./fleet-client.js";
-import { reclaimOrphansAtBoot } from "./boot-reclaim.js";
-import { createConfigCenterRuntime } from "./boot/config-center.js";
-import { createResolveSpec } from "./boot/resolve-spec.js";
-import { createParkedReviveInheritedGate } from "./boot/parked-revive-gate.js";
-import { startReapers } from "./boot/reapers.js";
-import { assertRetentionLaneWirable, startRetentionLane, RETENTION_LEASE_TTL_FACTOR } from "./boot/retention-lane.js";
-import { assertConsolidationDriverWirable, buildConsolidationValveAudit, createMemoryConsolidationFaces, resolveConsolidationDriverSeat } from "./boot/memory-consolidation.js";
-import { startFleetReconciler } from "./fleet/fleet-reconciler.js";
-import { openStores } from "./boot/stores.js";
-import { assertDeviceLaneWired, createDeviceLane } from "./boot/device-lane.js";
-import { runAdoptionBootScan } from "./boot/adoption.js";
-import { auditDormantPermissionRules } from "./boot/permission-rules-audit.js";
-import { createBudgetAndTracing } from "./boot/budget-tracing.js";
-import { createLimitSync } from "./boot/limit-sync.js";
-import { createSideQueryLane, createPerModelAuthSeat } from "./boot/side-query-lane.js";
-import { createWebFetchSummarizeLane } from "./boot/webfetch-summarize-lane.js";
-import { createRuleConsentLane } from "./rules-consent.js";
-import { createExecutionEnv } from "./boot/execution-env.js";
-import { createWorkflowOrchestration } from "./boot/workflow-orchestration.js";
-import { createLiveCoordinators } from "./boot/coordinators.js";
-import { createRuntimeCaps } from "./boot/runtime-caps.js";
-import { classifierRouteFor, coreArmsAutoOnIntent } from "./auto-mode-face.js";
-import { createSessionShellGateRegistry } from "./boot/session-shell-gate-registry.js";
-import { createRunnerDeps, createRunnerDepsOnAsk, createSharedRunnerDeps } from "./boot/runner-deps.js";
-import { createOrgMemoryAdmissionWiring } from "./boot/org-memory.js";
-import { createGovernanceSeams } from "./boot/governance-seams.js";
-import { createSharedMemoryScopeAuthorizer } from "./shared-memory-scope-authorizer.js";
-import { createSessionFaces } from "./boot/session-faces.js";
-import { createLeaderFace } from "./boot/leader.js";
-import { assertStaticWiringConsistent } from "./http/routes/diagnostics.js";
-import { installShutdownHandlers } from "./boot/shutdown.js";
-function serviceVersion() {
-    try {
-        const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-        return pkg.version ?? "unknown";
-    }
-    catch {
-        return "unknown";
-    }
-}
+import { runStage01 } from "./boot/stage-01-config.js";
+import { runStage02 } from "./boot/stage-02-registry-pull.js";
+import { runStage03 } from "./boot/stage-03-store-backend.js";
+import { runStage04 } from "./boot/stage-04-stores.js";
+import { runStage05 } from "./boot/stage-05-execution-env.js";
+import { runStage06 } from "./boot/stage-06-runners.js";
+import { runStage07 } from "./boot/stage-07-capability-layer.js";
+import { runStage08 } from "./boot/stage-08-reapers.js";
+import { runStage09 } from "./boot/stage-09-leader.js";
+import { runStage10 } from "./boot/stage-10-http-server.js";
 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();
-    installFailOpenRecorder({ logger, metrics });
-    installSecretEnvScrubRecorder({ logger, metrics });
-    installFileHistoryFailureRecorder({ logger, metrics });
-    logConfigDiagnostics(logger);
-    for (const w of drainNumEnvWarnings())
-        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, meta) => metrics.inc("redactions_applied_total", { pattern, arm: meta.arm }, n));
-    setWebSearchBadPayloadObserver((provider) => {
-        metrics.inc("web_search_bad_payload_total", { provider });
-        logger.warn("web_search_non_array_payload", { provider });
-    });
-    setRunTerminalObserver((level, fields) => {
-        if (level === "error")
-            logger.error("run_failed", fields);
-        else
-            logger.info("run_failed", fields);
-    });
-    const localRoot = config.configLocalDir ?? process.env.AGENT_DATA_DIR ?? join(homedir(), ".ai-agent");
-    const rootsSplit = splitLocalRoots({
-        localDataRoot: config.localDataRoot,
-        configLocalDir: config.configLocalDir,
-        agentDataDir: process.env.AGENT_DATA_DIR,
-        home: homedir(),
-    });
-    if (rootsSplit) {
-        logger.warn("local_roots_split", {
-            ...rootsSplit,
-            note: "LOCAL_DATA_ROOT moved the local backend's DATA root, but config.d / remote-exec.json are still read from the config root (LOCAL_DATA_ROOT is not consulted there). If you meant to move both, set CONFIG_LOCAL_DIR to the same directory.",
-        });
-    }
-    const configCenter = await createConfigCenterRuntime({ config, logger, metrics, localRoot });
-    await configCenter.applyLocalRemoteExec();
-    const ceilingVerdict = createUnpricedCeilingVerdict({ config, logger });
-    ceilingVerdict.judge();
-    const { backend, storeBackendDegraded, memoryEngine, memorySyncCursors, rosterStore, backgroundAgentStore, taskAttachmentStore, mailboxStore, memoryExportBackend, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngineFacts, } = await openStores({ config, logger, metrics, localRoot });
-    const instanceId = uuidv7();
-    const sessionCaptureRecords = backend?.sessionCaptureRecords();
-    const sessionCaptureRecordStore = sessionCaptureRecords?.();
-    const memoryBundleFaces = memoryEngine ? createMemoryBundleFaces(memoryEngine, { ...(sessionCaptureRecordStore !== undefined ? { captureRecordStore: sessionCaptureRecordStore } : {}) }) : undefined;
-    const memoryComplianceFaces = memoryEngine
-        ? createMemoryComplianceFaces(memoryEngine, {
-            onIncident: (err) => logger.warn("memory_compliance_incident", { code: err.code ?? null, detail: err.message }),
-            ...(sessionCaptureRecordStore !== undefined ? { captureRecordStore: sessionCaptureRecordStore } : {}),
-        })
-        : undefined;
-    const memoryOriginFaces = memoryEngine
-        ? createMemoryOriginFaces(memoryEngine, {
-            onIncident: (err) => logger.warn("memory_origin_incident", { code: err.code ?? null, detail: err.message }),
-            ...(sessionCaptureRecordStore !== undefined ? { captureRecordStore: sessionCaptureRecordStore } : {}),
-        })
-        : undefined;
-    const sessionMemoryStatusFace = memoryEngine
-        ? createSessionMemoryStatusFace(memoryEngine, { ...(sessionCaptureRecordStore !== undefined ? { captureRecordStore: sessionCaptureRecordStore } : {}) })
-        : undefined;
-    const adoptionBoot = await runAdoptionBootScan({ backend, logger });
-    if (adoptionBoot.scanned > 0 || adoptionBoot.error !== undefined) {
-        logger.info("adoption_boot_scan", { ...adoptionBoot });
-    }
-    const { brain, pricing, counterDegradeHook, costQuota, modelUsageTracker, promptManifestTracker, fleetUsage, fleetLease, tracer, sideQueryAccounting, toolResultStore, sessionPolicyStore, fileHistoryStore, } = createBudgetAndTracing({ config, logger, metrics, backend, breakerState });
-    const permissionRuleStores = config.permissionRulesEnabled && backend ? backend.permissionRule() : undefined;
-    const permissionRuleProvider = permissionRuleStores
-        ? createPermissionRuleStoreProvider({ durable: permissionRuleStores.durable })
-        : undefined;
-    const ruleConsent = permissionRuleStores && permissionRuleProvider
-        ? createRuleConsentLane({ ...permissionRuleStores, provider: permissionRuleProvider })
-        : undefined;
-    if (config.permissionRulesEnabled && permissionRuleStores === undefined) {
-        logger.info("permission_rules_lane_unavailable", {
-            knob: "PERMISSION_RULES_ENABLED",
-            reason: backend === undefined ? "no_backend" : "backend_has_no_rule_store",
-            backendKind: backend?.kind ?? null,
-            note: "PERMISSION_RULES_ENABLED is on but no permission-rule store is wired — /v1/rules/* answer 501, approval cards carry no rule suggestions, and respond's persistRule is refused with rule_lane_unavailable",
-        });
-    }
-    await auditDormantPermissionRules({ stores: permissionRuleStores, logger, explicit: config.permissionRulesEnabledExplicit });
-    const deviceLane = config.remoteExec?.provider === "device" ? createDeviceLane({ config, logger, metrics, backend, replicaId: instanceId, rateGate: () => rateLimiter }) : undefined;
-    const { perTaskImage, sessionEnvSelection, perSessionCwd, setSessionCwd, setSessionShellEnv, fenceSessionOwner, dropSessionScoped, executionEnvFactory, worktreeReap, sendUserFileTaskEnvs, lspManager, } = createExecutionEnv({ config, logger, metrics, taskAttachmentStore, ...(deviceLane ? { deviceLane } : {}) });
-    assertDeviceLaneWired(config.remoteExec?.provider === "device", deviceLane, executionEnvFactory !== undefined);
-    const toolTracer = config.toolTrace ? createToolTracer(logger) : undefined;
-    if (toolTracer)
-        logger.info("tool_trace_enabled", {});
-    const deploymentHooks = {
-        ...(toolTracer ? composeHooks(createPermissionDeniedMeter(metrics), toolTracer) : createPermissionDeniedMeter(metrics)),
-        ...(config.hooksTimeoutMs !== undefined ? { timeoutMs: config.hooksTimeoutMs } : {}),
-    };
-    const { sqlWorkflowRunStore, workflowNotifyJournal, workflowCompletionInbox, deliverWorkflowCompletion, workflowNotifyGate, fleetBus, workflowRunStore, workflowJournalStore, outcomeSink, workflowRecoverOpts, workflowAgentRegistry, subagentSteerRegistry, workflowAgentSessionIndex, } = createWorkflowOrchestration({ config, logger, metrics, localRoot, backend, getRunStore: () => runStore });
-    let parkedAskRedeem;
-    const { elicitation, question, toolApproval, durableEnabled, streamApprovalGate, approvalAskAudit, sendUserFileEmitter, sendFileLedger, sendUserFileToolSpec } = createLiveCoordinators({
-        config, logger, backend, sendUserFileTaskEnvs, ruleConsent,
-        getParkedRedeem: () => parkedAskRedeem,
-        ruleScopeRootFor: (sessionId) => cardRuleScopeRoot(sessionId !== undefined ? perSessionCwd.get(sessionId) : undefined, config),
-    });
-    const memoryOptOutGrantStore = backend?.memoryOptOutGrant();
-    const { principalCaps, centerRuntimeCapsResolver, runtimeCapsResolver, runtimeCapsPeekResolver } = createRuntimeCaps({ config, logger, memoryOptOutGrant: memoryOptOutGrantStore });
-    const orgMemoryAdmission = createOrgMemoryAdmissionWiring({ config, logger, metrics });
-    const sharedMemoryStore = orgMemoryAdmission.directory !== undefined
-        ? backend?.sharedMemoryStore?.(createSharedMemoryScopeAuthorizer({
-            directory: orgMemoryAdmission.directory,
-            deploymentScopes: config.requirePrincipal === true ? () => [] : orgMemoryAdmission.deploymentMemoryScopesLive,
-        }))
-        : undefined;
-    if (sharedMemoryStore)
-        logger.info("shared_memory_stores_enabled", { backend: backend?.kind });
-    const runnerOffloadStore = toolResultStore ?? new InMemoryToolResultStore({ maxTotalChars: 64_000_000 });
-    const commitHands = config.configProvider === "local" ? { commitCoAuthor: "Sema <noreply@vivi-ai.com>" } : undefined;
-    const checkpointStore = backend?.checkpoint && config.durableApproval ? backend.checkpoint(logger) : undefined;
-    const retentionExecutor = backend?.retention?.({ taskAttachmentTable: taskAttachmentStore !== undefined, taskListTables: taskListLane.backend !== "memory", logger });
-    const retentionLaneStore = backend?.retentionLane?.();
-    assertRetentionLaneWirable({
-        intervalSec: config.retentionSweep.intervalSec,
-        policy: config.retentionPolicy,
-        executor: retentionExecutor,
-        stores: [
-            { name: "sessionStore", store: sessionStore },
-            { name: "checkpointStore", store: checkpointStore },
-            { name: "toolResultStore", store: runnerOffloadStore },
-        ],
-        locked: (config.lockedConfigKeys ?? []).includes("retentionPolicy"),
-    });
-    assertConsolidationDriverWirable({
-        enabled: config.memoryConsolidationDriver.enabled,
-        memoryEngineWired: memoryEngine !== undefined,
-        controlPlaneOwned: backendOwnsControlPlane(memoryEngine?.backend),
-        memoryEngineBackend: config.memoryEngineBackend,
-        ...(config.memoryProvenance !== undefined ? { provenance: config.memoryProvenance } : {}),
-    });
-    const memoryConsolidationFaces = config.memoryConsolidationDriver.enabled && memoryEngine
-        ? createMemoryConsolidationFaces(memoryEngine, {
-            seat: resolveConsolidationDriverSeat({
-                brain,
-                models: config.models,
-                tiers: config.tiers,
-                roles: config.roles,
-                getApiKeyAndHeaders: createPerModelAuthSeat(() => configCenter.getKeyResolver()),
-            }),
-            scopes: config.memoryConsolidationDriver.scopes,
-            ...(config.memoryProvenance !== undefined ? { provenance: config.memoryProvenance } : {}),
-            onIncident: (err) => logger.warn("memory_consolidation_incident", { code: err.code ?? null, detail: err.message }),
-            onStopDetail: (audit) => logger.warn("memory_consolidation_stop_detail", audit),
-            ...(sessionCaptureRecordStore !== undefined ? { captureRecordStore: sessionCaptureRecordStore } : {}),
-        })
-        : undefined;
-    for (const w of buildConsolidationValveAudit({
-        enabled: config.memoryConsolidationDriver.enabled,
-        operatorPrincipals: config.operatorPrincipals,
-        hasServiceAuth: hasServiceAuth(config),
-        allowUnauthedWrites: config.allowUnauthedWrites ?? false,
-    }).warnings) {
-        logger.warn(w.tag, { detail: w.detail });
-    }
-    if (memoryConsolidationFaces !== undefined) {
-        logger.info("memory_consolidation_driver_armed", {
-            seat: memoryConsolidationFaces.seat,
-            model: memoryConsolidationFaces.model,
-            scopes: memoryConsolidationFaces.scopes,
-            periodic: false,
-        });
-    }
-    const governanceSeams = createGovernanceSeams({
-        config,
-        logger,
-        retentionStores: [
-            { name: "sessionStore", store: sessionStore },
-            { name: "checkpointStore", store: checkpointStore },
-            { name: "toolResultStore", store: runnerOffloadStore },
-        ],
-        retentionExecutorWired: config.retentionSweep.intervalSec > 0 && retentionExecutor !== undefined && retentionLaneStore !== undefined,
-    });
-    const mcpRevocations = configCenter.takeMcpRevocations();
-    const workflowModelAllowlistSnapshot = workflowModelAllowlistFor(config) ?? [];
-    const sessionShellGateRegistry = createSessionShellGateRegistry();
-    const runnerDeps = createRunnerDeps({
-        hands: commitHands,
-        mcpRevocations,
-        sessionShellGateExplicitlyOff: sessionShellGateRegistry.explicitlyOff,
-        config, logger, metrics, localRoot, promptSource: configCenter.promptSource, rosterStore, backgroundAgentStore, mailboxStore, usageWindowStore, brain,
-        pricing, tracer, outcomeSink, elicitation, question, toolApproval, sessionStore, memoryEngine,
-        sessionCaptureRecords,
-        memorySyncRunner, toolResultStore: runnerOffloadStore, checkpointStore, sessionPolicyStore, runtimeCapsResolver, fileHistoryStore,
-        permissionRuleStore: permissionRuleProvider,
-        executionEnvFactory, lspManager, fleetBus, deploymentHooks, workflowRunStore, workflowJournalStore,
-        workflowAgentRegistry, workflowNotifyGate, workflowCompletionInbox, deliverWorkflowCompletion, orgMemoryAdmission,
-        governanceSeams,
-        sharedMemoryStores: sharedMemoryStore ? sharedMemoryStore : undefined,
-        getRunStore: () => runStore,
-    });
-    const runner = new Runner(runnerDeps);
-    const handslessRunner = new Runner(withoutExecutionEnv(runnerDeps));
-    const runnerTierFrozen = Object.keys(config.tiers).length > 0;
-    const { hookModelFor, hookLlm } = createHookLlm({ config, getKeyResolver: () => configCenter.getKeyResolver(), metrics });
-    const hookAgentRunner = new Runner({ ...runnerDeps, sessionStore: new TtlSessionStore({ defaultTtlDays: 1 / 24 }) });
-    const hookAgent = async ({ prompt, model, timeoutMs, system }) => {
-        const pick = hookModelFor(model);
-        if (!pick.ok)
-            return pick;
-        try {
-            const result = await hookAgentRunner.runTask({
-                objective: prompt,
-                sessionId: uuidv7(),
-                model: pick.catalogRef,
-                ...(system !== undefined ? { systemPrompt: system } : {}),
-                handsReadOnly: true,
-                enableFork: false,
-                limits: { maxTurns: 10, maxCostUsd: 0.05, maxWalltimeMs: Math.max(30_000, timeoutMs) },
-                toolPolicy: createAllowDenyPolicy({}),
-            });
-            metrics.inc("hook_llm_calls_total", { type: "agent" });
-            if (result.terminal.kind !== "completed") {
-                const plane = terminalProjection(result.terminal);
-                return { ok: false, error: `hook agent ${plane.status}: ${clipHookErr(plane.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, model: o.model }),
-            logger,
-            metrics,
-        })
-        : undefined;
-    if (sessionTitler)
-        logger.info("session_auto_title_enabled", {});
-    const workflowsCapable = workflowsCapability(runnerDeps);
-    const subRunnerSessions = new ForkRoutingSessionStore(sessionStore, new TtlSessionStore({ defaultTtlDays: 1 / 24 }));
-    const subRunnerDeps = {
-        ...createSharedRunnerDeps({
-            metrics,
-            config,
-            logger,
-            hands: commitHands,
-            mcpRevocations,
-            brain,
-            pricing,
-            tracer,
-            promptSource: configCenter.promptSource,
-            executionEnvFactory,
-            lspManager,
-            backgroundAgentStore,
-            mailboxStore,
-            rosterStore,
-            deploymentHooks,
-            toolResultStore: runnerOffloadStore,
-            checkpointStore,
-            sessionPolicyStore,
-            usageWindowStore,
-            orgMemoryAdmission,
-            governanceSeams,
-            sharedMemoryStores: sharedMemoryStore ? sharedMemoryStore : undefined,
-        }),
-        sessionStore: subRunnerSessions,
-        onBackgroundChildEvent: runnerDeps.onBackgroundChildEvent ? runnerDeps.onBackgroundChildEvent : undefined,
-        loadProjectMemory: runnerDeps.loadProjectMemory ? runnerDeps.loadProjectMemory : undefined,
-        probeInstructionSources: runnerDeps.probeInstructionSources ? runnerDeps.probeInstructionSources : undefined,
-        onError: runnerDeps.onError ? runnerDeps.onError : undefined,
-    };
-    const subRunner = new Runner(subRunnerDeps);
-    const handslessSubRunner = new Runner(withoutExecutionEnv(subRunnerDeps));
-    const authorize = createAuthorizer(config, sessionStore);
-    const runStore = backend ? backend.run() : undefined;
-    const resumeAnchorStore = backend ? backend.resumeAnchor() : undefined;
-    const approvalExemptionStore = backend ? backend.approvalExemption() : undefined;
-    const approvalNonceStore = backend ? backend.approvalNonce() : undefined;
-    const taskTimeoutSec = Math.floor(parseNumOrFailNonNegative("TASK_TIMEOUT_SEC", process.env.TASK_TIMEOUT_SEC || "0"));
-    const capEnv = (name) => {
-        const r = parseCapEnv(name, process.env[name]);
-        if (r.invalid !== undefined) {
-            logger.warn("task_limit_cap_invalid", {
-                env: name,
-                raw: r.invalid,
-                note: "this per-request rate cap is NOT in effect (a non-numeric or non-positive value parses to 'no cap'). Callers can self-report any value for this limit until the env is fixed.",
-            });
-        }
-        return r.value;
-    };
-    const taskLimitCaps = {
-        timeoutSec: capEnv("TASK_TIMEOUT_MAX_SEC"),
-        maxOutputTokens: capEnv("TASK_MAX_OUTPUT_TOKENS_MAX"),
-        maxTurns: capEnv("TASK_MAX_TURNS_MAX"),
-    };
-    const operatorGateIntent = hasOperatorGateIntent(config);
-    assertGateIntentServiceable(config, checkpointStore !== undefined);
-    const singleUserAutoAcceptBaseline = config.requirePrincipal !== true && !operatorGateIntent;
-    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: explicitOperatorOk(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 });
-    if (durableEnabled)
-        logger.info("durable_approval_enabled", { toolApprovalGate: config.approvalRequire.length });
-    if (config.a2aServe) {
-        logger.info("a2a_serve_enabled", {
-            card: "/.well-known/agent-card.json",
-            rpc: "/v1/a2a",
-            advertisedUrl: config.a2aServe.url,
-            skills: config.a2aServe.skills.length,
-            blockingWaitMs: config.a2aServe.blockingWaitMs,
-            tasksUsable: runStore !== undefined,
-        });
-    }
-    if ((config.remoteExec === undefined || config.remoteExec.provider === "host") && !toolApproval && !durableEnabled) {
-        logger.warn("fs_write_gate_no_responder", {
-            hint: "host-semantics lane with no approval face: permissionMode default/auto Write/Edit asks will auto-deny (fail-closed); wire TOOL_APPROVAL_ENABLED=true or DURABLE_APPROVAL=true to answer them",
-        });
-    }
-    if (config.selfOrchestrationEnabled && config.remoteExec !== undefined && config.remoteExec.provider !== "host" && !toolApproval && !durableEnabled) {
-        logger.warn("workflow_gate_no_responder", {
-            hint: "self-orchestration with no approval face: permissionMode default/auto/acceptEdits run_workflow asks will auto-deny (fail-closed); wire TOOL_APPROVAL_ENABLED=true or DURABLE_APPROVAL=true to answer them",
-        });
-    }
-    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 (selfOrchestrationDenial(config, centerEntitlementSourceWired(config)) !== null)
-        logger.warn("self_orchestration_no_entitlement_source", { detail: "SELF_ORCHESTRATION_ENABLED is on and REQUIRE_PRINCIPAL is on, but no per-principal entitlement source is wired (no config center, or it is in dry-run). core's allowWorkflows is tighten-only — an absent resolver leaves it ungated — so this service fail-closes self-orchestration for EVERY principal: no task on this worker can ever get the workflow engine. /v1/capabilities now reports workflows:false (workflowsGate.denial=\"entitlement_resolver_absent\") and a submit carrying selfOrchestration/settings.ultracode is refused 501 instead of silently downgraded. Wire a config center (SEMA_REGISTRY_URL + token, not dry-run), or set SELF_ORCHESTRATION_ENABLED=false." });
-    {
-        const inert = buildForceDurableGateInertNotice({
-            entitlementSourceWired: centerEntitlementSourceWired(config),
-            checkpointStorePresent: checkpointStore !== undefined,
-            durableApproval: config.durableApproval,
-        });
-        if (inert)
-            logger.warn(inert.event, inert.fields);
-    }
-    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 = backend?.rateLimiter
-        ? backend.rateLimiter(config.rateLimitPerMin, counterDegradeHook).startRefresh()
-        : new RateLimiter(config.rateLimitPerMin);
-    let skills = loadSkills(config.skillsDir);
-    skills = await configCenter.applyCenterCapabilities(skills);
-    const repoClient = config.gitApiBaseUrl ? createRepoClient(config.gitApiKind, 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})`);
-    if (webSearch && shouldProbeWebSearchOnBoot()) {
-        void probeSearchBackend(webSearch.search, { timeoutMs: 10_000 })
-            .then((r) => {
-            if (r.ok)
-                logger.info("web_search_probe_ok", { provider: webSearchCfg.provider, results: r.results });
-            else
-                logger.warn("web_search_probe_failed", { provider: webSearchCfg.provider, error: r.error, note: "WebSearch stays mounted — the tool will fail per-call until this is fixed; the service is not blocked by it." });
-        })
-            .catch((e) => logger.warn("web_search_probe_failed", { provider: webSearchCfg.provider, error: e instanceof Error ? e.message : String(e) }));
-    }
-    const ensureChildSessionDurable = checkpointStore && config.sessionBackend === "tidb" ? (sessionId) => ensureChildSessionDurableWithPromotion(sessionStore, subRunnerSessions, sessionId) : undefined;
-    const webFetchSummarize = createWebFetchSummarizeLane({ brain, config, getKeyResolver: () => configCenter.getKeyResolver(), logger });
-    const scenarioDeps = {
-        runner, subRunner, handslessSubRunner, model: DEFAULT_MODEL_REF, skills, repoClient, requirePrincipal: config.requirePrincipal,
-        webSearch: webSearch ? webSearch : undefined, metrics, logger, webFetchSummarize,
-        backgroundAgentStore: backgroundAgentStore ? backgroundAgentStore : undefined,
-        checkpointStore: checkpointStore ? checkpointStore : undefined,
-        ensureChildSessionDurable: ensureChildSessionDurable ? ensureChildSessionDurable : undefined,
-        taskListStoreFor: taskListLane.storeFor,
-        brandIdentity: config.configProvider === "local",
-        subagentExtraTools: sendUserFileToolSpec
-            ? subagentSendUserFileExtraTools({
-                spec: sendUserFileToolSpec,
-                approvalGate: () => ({ deny: config.approvalDeny, require: config.approvalRequire, neverAuto: config.approvalNeverAuto }),
-            })
-            : undefined,
-    };
-    const scenarios = buildScenarios(scenarioDeps);
-    const parkedReviveTool = checkpointStore && backgroundAgentStore ? scenarios.default?.({})?.tools.find((t) => t.name === DEFAULT_SUBAGENT_TOOL_NAME) : undefined;
-    const parkedReviveInheritedGate = parkedReviveTool && config.durableApproval
-        ? createParkedReviveInheritedGate({
-            config, question, approvalExemptionStore, logger, localRoot,
-            memoryEngineRoot: memoryEngine?.root,
-            approverSeat: createRunnerDepsOnAsk(toolApproval),
-            ...(runnerDeps.runtimeCapsResolver ? { resolveRuntimeCaps: runnerDeps.runtimeCapsResolver } : {}),
-            autoModeSeatMounted: runnerDeps.autoMode !== undefined,
-        })
-        : undefined;
-    const scenarioDetails = builtinScenarioDetails(scenarios, scenarioDeps);
-    const builtinScenarioNames = Object.keys(scenarioDetails);
-    configCenter.applyCenterScenarios({ scenarioDeps, scenarios, scenarioDetails, builtinScenarioNames });
-    logger.info("capabilities", { skills: skills.length, scenarios: Object.keys(scenarios), repoTools: Boolean(repoClient) });
-    let runDenySweep;
-    const reaper = startReapers({
-        config, logger, metrics, localRoot, backend, subRunner, runStore, checkpointStore,
-        rateLimiter, costQuota, toolResultStore, fileHistoryStore, taskAttachmentStore, imageBakes, worktreeReap,
-        workflowNotifyGate, workflowRecoverOpts, workflowJournalStore, sqlWorkflowRunStore, workflowNotifyJournal, rosterStore,
-        backgroundAgentStore, mailboxStore, toolApproval, permissionRuleStores, approvalNonceStore,
-        getRunDenySweep: () => runDenySweep,
-    });
-    const ttlMs = config.retentionSweep.intervalSec * 1000 * RETENTION_LEASE_TTL_FACTOR;
-    const retentionLaneStarted = retentionExecutor !== undefined && retentionLaneStore !== undefined && config.retentionPolicy !== undefined
-        ? startRetentionLane({
-            intervalSec: config.retentionSweep.intervalSec,
-            policy: config.retentionPolicy,
-            mode: config.retentionSweep.mode,
-            executor: retentionExecutor,
-            lease: {
-                acquire: async () => {
-                    const claim = await retentionLaneStore.acquire(instanceId, ttlMs, Date.now());
-                    return claim.held ? { held: true, fencingToken: claim.fencingToken } : { held: false };
-                },
-                renew: (fencingToken) => retentionLaneStore.renew(instanceId, fencingToken, ttlMs, Date.now()),
-                release: () => retentionLaneStore.release(instanceId),
-            },
-            audit: { append: (row) => retentionLaneStore.appendAudit(row, Date.now()) },
-            holdInForce: (domain) => retentionLaneStore.holdInForce(domain),
-            logger,
-            metrics,
-            now: () => Date.now(),
-        })
-        : undefined;
-    if (retentionLaneStarted !== undefined) {
-        logger.info("retention_lane_started", {
-            intervalSec: config.retentionSweep.intervalSec,
-            mode: config.retentionSweep.mode,
-            maxAgeDays: config.retentionPolicy?.maxAgeDays,
-            holder: instanceId,
-        });
-    }
-    const otelExporter = config.otel
-        ? startOtlpExporter(metrics, {
-            ...config.otel,
-            onError: (err) => logger.warn("otel_export_failed", { err: String(err) }),
-        })
-        : undefined;
-    const limitSync = createLimitSync({ config, rateGate: rateLimiter, quota: costQuota, logger });
-    limitSync.sync();
-    const bootRunners = [
-        ["runner", runner],
-        ["handsless", handslessRunner],
-        ["hookAgent", hookAgentRunner],
-        ["sub", subRunner],
-        ["handslessSub", handslessSubRunner],
-    ];
-    const swapRunnerDeps = (next) => {
-        for (let i = 0; i < bootRunners.length; i++) {
-            const [name, rn] = bootRunners[i];
-            try {
-                rn.swapDeps(next);
-            }
-            catch (err) {
-                if (i > 0)
-                    logger.error("runner_deps_swap_split", { failedAt: name, seats: Object.keys(next), swapped: bootRunners.slice(0, i).map(([n]) => n), err: String(err) });
-                throw err;
-            }
-        }
-    };
-    configCenter.startRefreshLoop({ runnerTierFrozen, pricing, limitSync, swapRunnerDeps, ceilingVerdict });
-    configCenter.initKeyResolver();
-    const { ownerAware, sessionAudit, sessionWatchRegistry, purgeSession, instrumentDegenerate, planCacheProbe } = createSessionFaces({
-        deviceStore: deviceLane?.store,
-        dropSessionScoped,
-        config, logger, metrics, localRoot, backend, sessionStore, runStore, checkpointStore, toolResultStore,
-        resumeAnchorStore, approvalExemptionStore, sessionPolicyStore, taskAttachmentStore, fileHistoryStore,
-        workflowCompletionInbox, taskListLane,
-    });
-    const leaderEndpoint = createLeaderFace({ config, logger, brain, pricing, executionEnvFactory, toolResultStore, sessionStore, checkpointStore, governanceSeams, backend, tracer, usageWindowStore, promptSource: configCenter.promptSource, onError: runnerDeps.onError });
-    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 wiringSpecTemplate = durableEnabled
-        ? { checkpointStore, durableApproval: { scope: encodeCheckpointScope(undefined) } }
-        : {};
-    const staticWiring = describeStaticWiring(runnerDeps, wiringSpecTemplate);
-    assertStaticWiringConsistent({ manifest: staticWiring, parkFacility: durableEnabled, backendKind: backend?.kind }, logger);
-    logger.info("wiring_static", {
-        fingerprint: staticWiring.configFingerprint ?? null,
-        parkEffective: staticWiring.parkLane.effective,
-        sessionDurability: staticWiring.session.store,
-        posture: staticWiring.interaction.posture,
-        streamApproval: streamApprovalGate.active ? "active" : streamApprovalGate.reason,
-        subagentTranscripts: staticWiring.fleet.subagentTranscripts,
-        subagentTranscriptRetentionMs: config.backgroundAgentRetentionMs,
-    });
-    const stores = {
-        runStore,
-        resumeAnchorStore: resumeAnchorStore ? resumeAnchorStore : undefined,
-        approvalExemptionStore: approvalExemptionStore ? approvalExemptionStore : undefined,
-        approvalNonceStore: approvalNonceStore ? approvalNonceStore : undefined,
-        checkpointStore,
-        sessionPolicyStore: sessionPolicyStore ? sessionPolicyStore : undefined,
-        ruleConsent,
-        fileHistoryStore: fileHistoryStore ? fileHistoryStore : undefined,
-        toolResultStore,
-        taskAttachmentStore: taskAttachmentStore ? taskAttachmentStore : undefined,
-        backgroundAgentStore: backgroundAgentStore ? backgroundAgentStore : undefined,
-        sessionStorage: ownerAware,
-        workflowRunStore: workflowRunStore ? workflowRunStore : undefined,
-        workflowAgentSessionIndex: workflowAgentSessionIndex ? workflowAgentSessionIndex : undefined,
-        workflowJournalStore: workflowJournalStore ? workflowJournalStore : undefined,
-        imageIndex,
-        imageBakes,
-        outcomeSink: outcomeSink ? outcomeSink : undefined,
-        sendFileLedger: sendFileLedger ? sendFileLedger : undefined,
-        backend: backend ? backend : undefined,
-    };
-    let resolveFleetRecovery;
-    const fleetRecoveryDone = new Promise((r) => { resolveFleetRecovery = r; });
-    const coordinators = {
-        elicitation: elicitation ? elicitation : undefined,
-        question: question ? question : undefined,
-        toolApproval: toolApproval ? toolApproval : undefined,
-        approvalAskAudit: approvalAskAudit ? approvalAskAudit : undefined,
-        approvalLateSettle: approvalAskAudit ? approvalAskAudit : undefined,
-        workflowAgentRegistry: workflowAgentRegistry ? workflowAgentRegistry : undefined,
-        subagentSteerRegistry,
-        workflowCompletionInbox: workflowCompletionInbox ? workflowCompletionInbox : undefined,
-        fleetBus,
-        fleetRecoveryDone,
-        sessionWatch: sessionWatchRegistry ? sessionWatchRegistry : undefined,
-        hookWakeBus,
-        sendUserFile: sendUserFileEmitter ? sendUserFileEmitter : undefined,
-        leaderEndpoint,
-        sessionTitler: sessionTitler ? sessionTitler : undefined,
-    };
-    const seams = {
-        deviceHub: deviceLane?.hub,
-        deviceStore: deviceLane?.store,
-        sessionAudit,
-        routeJudgeBrain: brain,
-        purgeSession: purgeSession ? purgeSession : undefined,
-        subagentTaskOutput: (handle, access) => backgroundAgentOutput(defaultTaskRegistry, handle, access, backgroundAgentStore),
-        taskHandleOutput: (handle, access) => taskHandleOutput(defaultTaskRegistry, handle, access, backgroundAgentStore),
-        taskHandleStop: (handle, access) => taskHandleStop(defaultTaskRegistry, handle, access, backgroundAgentStore),
-        memoryExport: memoryExportBackend ? (scope) => exportMemoryScope(memoryExportBackend, scope) : undefined,
-        memorySync: memoryExportBackend && memorySyncCursors
-            ? (scope, syncReq) => performMemorySync(memoryExportBackend, memorySyncCursors, scope, syncReq)
-            : undefined,
-        memoryBundleExport: memoryBundleFaces ? memoryBundleFaces.exportScopes : undefined,
-        memoryBundleImport: memoryBundleFaces ? memoryBundleFaces.importBundle : undefined,
-        memoryCompliance: memoryComplianceFaces,
-        memoryOriginFace: memoryOriginFaces,
-        sessionMemoryStatus: sessionMemoryStatusFace,
-        memoryConsolidation: memoryConsolidationFaces,
-        memoryOptOutGrant: memoryOptOutGrantStore,
-        orgMemoryDirectory: orgMemoryAdmission.directory,
-        sharedMemoryStore: sharedMemoryStore ? sharedMemoryStore : undefined,
-        sessionMirrorRuling: principalCaps
-            ? async (p) => (await principalCaps.executionRuling(p))?.sessionMirror
-            : undefined,
-        instrumentDegenerate,
-        sideQueryAccounting,
-        parkedReviveTool: parkedReviveTool ? parkedReviveTool : undefined,
-        parkedReviveInheritedGate: parkedReviveInheritedGate ? parkedReviveInheritedGate : undefined,
-    };
-    const observability = {
-        logger,
-        metrics,
-        modelUsage: modelUsageTracker,
-        promptManifests: promptManifestTracker,
-        planCacheProbe,
-    };
-    const governance = {
-        authorize,
-        registryJwtVerifier: registryJwtVerifier ? registryJwtVerifier : undefined,
-        rateLimiter,
-        costQuota,
-        fleetLease: fleetLease ? fleetLease : undefined,
-        usageWindowStore: usageWindowStore ? usageWindowStore : undefined,
-        autoModeFace: {
-            seatMounted: runnerDeps.autoMode !== undefined,
-            engineArmsOnIntent: coreArmsAutoOnIntent(),
-            resolveCaps: runtimeCapsPeekResolver,
-            classifierModel: () => {
-                const route = classifierRouteFor(runnerDeps);
-                if (route.fault !== undefined)
-                    logger.debug("auto_mode_classifier_route_unresolved", { fault: route.fault });
-                return route.id;
-            },
-        },
-    };
-    const storeLiveProbe = backend && backend.kind !== "local" && backend.dbNowMs && config.storeProbeIntervalMs > 0
-        ? createStoreLiveProbe({ probe: () => backend.dbNowMs(), intervalMs: config.storeProbeIntervalMs, logger })
-        : undefined;
-    const deployment = {
-        sessionStoreLabel: config.sessionBackend === "tidb" && backend ? `durable(${backend.kind})` : config.sessionBackend,
-        modelReady: () => configCenter.modelReady(),
-        scenarioDetails,
-        workflowsCapable,
-        workflowModelAllowlist: workflowModelAllowlistSnapshot,
-        staticWiring,
-        memoryPosture,
-        sqlEngineFacts,
-        writeProtection: buildWriteProtectionPosture(config),
-        instanceId,
-        capabilities: {
-            version: serviceVersion(),
-            scenarios: Object.keys(scenarios),
-            get pricingConfigured() {
-                return isPricingConfigured(pricing);
-            },
-        },
-        restartState: () => configCenter.restartState(),
-        planeDeferredState: () => configCenter.planeDeferredState(),
-        configApplyState: () => configCenter.configApplyState(),
-        mcpRevocations,
-        mcpRevocationState: () => configCenter.mcpRevocationState(),
-        configRefreshNow: () => configCenter.refreshNow(),
-        configCenterManagedKeys: () => configCenter.centerManagedKeys(),
-        drainState,
-        storeDegraded: storeBackendDegraded,
-        storeLiveState: storeLiveProbe ? () => storeLiveProbe.state() : undefined,
-    };
-    const knobs = {
-        snapshotBlobSqlCapBytes: backend && backend.kind !== "local" && !config.snapshotBlobStore
-            ? (config.snapshotBlobSqlMaxBytes ?? (backend.kind === "mysql" ? SQL_BLOB_DEFAULT_MAX_BYTES : undefined))
-            : undefined,
-        sessionEventsMaxConnections: sessionWatchRegistry ? posIntEnv(process.env.SESSION_EVENTS_MAX_CONNS, 256, 100_000) : undefined,
-    };
-    const resolveSpec = createResolveSpec({
-        config, logger, metrics, localRoot, scenarios, principalCaps, centerRuntimeCapsResolver,
-        getCenterPrompts: () => configCenter.getCenterPrompts(),
-        getKeyResolver: () => configCenter.getKeyResolver(),
-        taskAttachmentStore, perSessionCwd, setSessionCwd, setSessionShellEnv, fenceSessionOwner,
-        hookLlm, hookAgent, fleetBus, hookWakeBus, resumeAnchorStore, ownerAware, taskLimitCaps, taskTimeoutSec,
-        noteSessionShellGate: sessionShellGateRegistry.note,
-        selectEnvTool, sendUserFileToolSpec, memoryEngine, durableEnabled, approvalExemptionStore,
-        singleUserAutoAcceptBaseline, checkpointStore, deploymentHooks, imageIndex, perTaskImage,
-        sessionEnvSelection,
-        lockedKeys: governanceSeams.lockedKeys,
-        liveQuestionFace: question,
-        approverSeat: createRunnerDepsOnAsk(toolApproval),
-    });
-    const runnerFor = createHandsRunnerSelector({ full: runner, handsless: handslessRunner });
-    const sideQuery = createSideQueryLane({ brain, config, getKeyResolver: () => configCenter.getKeyResolver() });
-    const server = createHttpServer({ runner, runnerFor, sideQuery, config, resolveSpec, stores, coordinators, seams, observability, governance, deployment, knobs });
-    runDenySweep = server.denyExpiredApprovals;
-    if (!config.directDoorActive)
-        parkedAskRedeem = server.redeemParkedAsk;
-    else
-        logger.info("parked_late_decision_disabled", { reason: "direct_door_requires_signed_decision_envelope" });
-    const fleetReconcile = startFleetReconciler({
-        bus: fleetBus,
-        isLiveOnThisReplica: server.isRunLiveOnThisReplica,
-        ...(runStore ? { runs: runStore } : {}),
-        ...(workflowRunStore ? { workflows: workflowRunStore } : {}),
-        instanceId,
-        logger,
-        metrics,
-    });
-    const bindHost = resolveBindHost(config);
-    if (config.bindHostSource === "HOST" && bindHost !== config.bindHost) {
-        logger.warn("bind_host_from_HOST_env_overridden", {
-            bindHost,
-            ignoredHostEnv: config.bindHost,
-            note: "HOST was inherited from the shell (zsh commonly sets it to the machine name) and would have bound the write face to a non-loopback address — but this deployment has ALLOW_UNAUTHED_WRITES with no service token, so the bind address was narrowed to loopback instead. Two ways out if you meant to expose it: set BIND_HOST explicitly, or configure a service token.",
-        });
-    }
-    else if (config.bindHostSource === "HOST") {
-        logger.warn("bind_host_from_HOST_env", {
-            bindHost,
-            note: "the bind address came from the HOST env var (not BIND_HOST). Shells like zsh commonly set HOST to the machine name — if you did not set it yourself, this may be an inherited shell variable silently configuring the bind face. Set BIND_HOST explicitly to silence this warning.",
-        });
-    }
-    let onListenError;
-    try {
-        await new Promise((resolve, reject) => {
-            onListenError = reject;
-            server.once("error", onListenError);
-            bindHost ? server.listen(config.port, bindHost, resolve) : server.listen(config.port, resolve);
-        });
-    }
-    catch (e) {
-        logger.error("listen_failed", {
-            port: config.port,
-            bindHost: bindHost ?? "0.0.0.0/::(all interfaces)",
-            ...(config.bindHostSource ? { bindHostSource: config.bindHostSource } : {}),
-            ...(config.bindHostSource === "HOST" ? { note: "bind failed for a host inherited from the HOST env var — set BIND_HOST explicitly (e.g. BIND_HOST=127.0.0.1)." } : {}),
-            error: e instanceof Error ? e.message : String(e),
-        });
-        throw e;
-    }
-    finally {
-        if (onListenError)
-            server.removeListener("error", onListenError);
-    }
-    server.on("error", (e) => {
-        logger.error("server_error", {
-            error: e.message,
-            ...("code" in e ? { code: String(e.code) } : {}),
-        });
-    });
-    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,
-        bindHost: bindHost ?? "0.0.0.0/::(all interfaces)",
-        ...(bindHost === "127.0.0.1" && !config.bindHost
-            ? { bindHostNote: "auto-narrowed to loopback: write face is unauthenticated (ALLOW_UNAUTHED_WRITES with no service token). Set BIND_HOST explicitly to override." }
-            : {}),
-        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 ? counterStoreLabel(backend?.rateLimiter, backend?.kind) : "off",
-        maxPrincipalCostUsd: config.maxPrincipalCostUsd || null,
-        costQuota: config.maxPrincipalCostUsd > 0 ? counterStoreLabel(backend?.costQuota, backend?.kind) : "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.values(config.modelApiKeys).filter((v) => typeof v === "string").length,
-        sealedPoisonedModels: Object.values(config.modelApiKeys).filter((v) => typeof v !== "string").length,
-        workflowRunStore: config.selfOrchestrationEnabled
-            ? config.workflowRunStoreBackend === "memory"
-                ? "in-process"
-                : sqlWorkflowRunStore
-                    ? `db(${backend.kind})`
-                    : "file"
-            : "off",
-    });
-    if (workflowNotifyGate) {
-        void workflowNotifyGate
-            .recover(workflowRecoverOpts)
-            .then((tally) => logger.info("workflow_notify_recovered", tally))
-            .catch((err) => logger.warn("workflow_notify_recover_failed", { err: String(err) }))
-            .finally(() => resolveFleetRecovery());
-    }
-    else {
-        resolveFleetRecovery();
-    }
-    void installShutdownHandlers({
-        config, logger, server, reaper, fleetReconcile, otelExporter, breakerState, costQuota, rateLimiter,
-        version: serviceVersion(),
-        runner, subRunner, lspManager, workflowNotifyJournal, fleetClient, backend, drainState,
-        storeLiveProbe, configCenter,
-        deviceHub: deviceLane?.hub,
-        retentionLane: retentionLaneStarted,
-        releaseRetentionLease: retentionLaneStore !== undefined ? () => retentionLaneStore.release(instanceId) : undefined,
-    });
+    const s01 = runStage01();
+    const s02 = await runStage02(s01);
+    const s03 = await runStage03(s02);
+    const s04 = await runStage04(s03);
+    const s05 = runStage05(s04);
+    const s06 = runStage06(s05);
+    const s07 = await runStage07(s06);
+    const s08 = runStage08(s07);
+    const s09 = runStage09(s08);
+    await runStage10(s09);
 }
 void main().catch((err) => {
     createLogger().error("fatal", { err: String(err) });