@sema-agent/server 7.79.1 → 7.79.3

package/dist/boot/stage-06-runners.js

@@ -0,0 +1,207 @@
+import { Runner, terminalProjection, InMemoryToolResultStore, TtlSessionStore, uuidv7, createAllowDenyPolicy, workflowsCapability } from "@sema-agent/core";
+import { createSessionTitler } from "../session-titler.js";
+import { cardRuleScopeRoot } from "../task-cwd.js";
+import { ForkRoutingSessionStore } from "../plugins/fork-routing-session-store.js";
+import { withoutExecutionEnv } from "../capabilities/hands-lane.js";
+import { redactSecrets } from "../trace/redact.js";
+import { hasServiceAuth } from "../http/server.js";
+import { workflowModelAllowlistFor } from "../task-workflow.js";
+import { backendOwnsControlPlane } from "../memory-operator-faces.js";
+import { createHookLlm } from "../hooks/hook-llm.js";
+import { assertRetentionLaneWirable } from "./retention-lane.js";
+import { assertConsolidationDriverWirable, buildConsolidationValveAudit, createMemoryConsolidationFaces, resolveConsolidationDriverSeat } from "./memory-consolidation.js";
+import { createPerModelAuthSeat } from "./side-query-lane.js";
+import { createWorkflowOrchestration } from "./workflow-orchestration.js";
+import { createLiveCoordinators } from "./coordinators.js";
+import { createRuntimeCaps } from "./runtime-caps.js";
+import { createSessionShellGateRegistry } from "./session-shell-gate-registry.js";
+import { createRunnerDeps, createSharedRunnerDeps } from "./runner-deps.js";
+import { createOrgMemoryAdmissionWiring } from "./org-memory.js";
+import { createGovernanceSeams } from "./governance-seams.js";
+import { createSharedMemoryScopeAuthorizer } from "../shared-memory-scope-authorizer.js";
+import { parkedAskRedeem, runStore } from "./late-binds.js";
+export function runStage06(ctx) {
+    const { backend, backgroundAgentStore, brain, config, configCenter, deploymentHooks, executionEnvFactory, fileHistoryStore, localRoot, logger, lspManager, mailboxStore, memoryEngine, memorySyncRunner, metrics, perSessionCwd, permissionRuleProvider, pricing, rosterStore, ruleConsent, sendUserFileTaskEnvs, sessionCaptureRecordStore, sessionCaptureRecords, sessionPolicyStore, sessionStore, taskAttachmentStore, taskListLane, toolResultStore, tracer, usageWindowStore } = ctx;
+    const { sqlWorkflowRunStore, workflowNotifyJournal, workflowCompletionInbox, deliverWorkflowCompletion, workflowNotifyGate, fleetBus, workflowRunStore, workflowJournalStore, outcomeSink, workflowRecoverOpts, workflowAgentRegistry, subagentSteerRegistry, workflowAgentSessionIndex, } = createWorkflowOrchestration({ config, logger, metrics, localRoot, backend, getRunStore: () => runStore });
+    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));
+    return { ...ctx, approvalAskAudit, centerRuntimeCapsResolver, checkpointStore, durableEnabled, elicitation, fleetBus, governanceSeams, handslessRunner, handslessSubRunner, hookAgent, hookAgentRunner, hookLlm, mcpRevocations, memoryConsolidationFaces, memoryOptOutGrantStore, orgMemoryAdmission, outcomeSink, principalCaps, question, retentionExecutor, retentionLaneStore, runner, runnerDeps, runnerTierFrozen, runtimeCapsPeekResolver, sendFileLedger, sendUserFileEmitter, sendUserFileToolSpec, sessionShellGateRegistry, sessionTitler, sharedMemoryStore, sqlWorkflowRunStore, streamApprovalGate, subRunner, subRunnerSessions, subagentSteerRegistry, toolApproval, workflowAgentRegistry, workflowAgentSessionIndex, workflowCompletionInbox, workflowJournalStore, workflowModelAllowlistSnapshot, workflowNotifyGate, workflowNotifyJournal, workflowRecoverOpts, workflowRunStore, workflowsCapable };
+}
+//# sourceMappingURL=stage-06-runners.js.map

package/dist/boot/stage-07-capability-layer.d.ts

@@ -0,0 +1,157 @@
+import { RateLimiter } from "../observability/rate-limit.js";
+import type { runStage06 } from "./stage-06-runners.js";
+export declare function runStage07(ctx: Awaited<ReturnType<typeof runStage06>>): Promise<{
+    approvalExemptionStore: import("../plugins/approval-exemption-store.js").ApprovalExemptionStore | undefined;
+    approvalNonceStore: import("../plugins/approval-nonce-store.js").ApprovalNonceStore | undefined;
+    authorize: (ctx: {
+        req: import("http").IncomingMessage;
+        body: import("../index.js").TaskRequestBody;
+    }) => Promise<import("../security.js").AuthContext>;
+    imageBakes: import("../plugins/store-backend.js").ImageBake | undefined;
+    imageIndex: import("../plugins/store-backend.js").ImageIndex | undefined;
+    parkedReviveInheritedGate: ((row: import("@sema-agent/core").BackgroundAgentRecord, identity: import("./parked-revive-gate.js").ParkedReviveIdentity) => Promise<import("./parked-revive-gate.js").RebuiltInheritedGate>) | undefined;
+    parkedReviveTool: import("@sema-agent/core").ToolSpec<import("@sema-agent/core").TSchema> | undefined;
+    rateLimiter: RateLimiter | import("../plugins/pg-rate-limiter.js").PgRateLimiter | import("../plugins/tidb-rate-limiter.js").TiDBRateLimiter;
+    resumeAnchorStore: import("../plugins/store-backend.js").ResumeAnchorStore | undefined;
+    runStore: import("../plugins/store-backend.js").RunStore | undefined;
+    scenarioDetails: Record<string, import("../capabilities/scenarios.js").ScenarioDetail>;
+    scenarios: Record<string, import("../capabilities/scenarios.js").Scenario>;
+    selectEnvTool: import("@sema-agent/core").ToolSpec<import("@sema-agent/core").TSchema> | undefined;
+    singleUserAutoAcceptBaseline: boolean;
+    taskLimitCaps: {
+        timeoutSec: number | undefined;
+        maxOutputTokens: number | undefined;
+        maxTurns: number | undefined;
+    };
+    taskTimeoutSec: number;
+    approvalAskAudit: import("../approval-ask-audit-store.js").FileApprovalAskAuditStore | undefined;
+    centerRuntimeCapsResolver: ((principal: string | undefined) => Promise<import("@sema-agent/core").RuntimeCaps | undefined>) | undefined;
+    checkpointStore: import("../plugins/store-backend.js").CheckpointStoreFull | undefined;
+    durableEnabled: boolean;
+    elicitation: import("../elicitation.js").ElicitationCoordinator | undefined;
+    fleetBus: import("../fleet/fleet-bus.js").FleetEventBus;
+    governanceSeams: import("./governance-seams.js").GovernanceSeams;
+    handslessRunner: import("@sema-agent/core").Runner;
+    handslessSubRunner: import("@sema-agent/core").Runner;
+    hookAgent: import("../hooks/hook-runner.js").HookLlmCall;
+    hookAgentRunner: import("@sema-agent/core").Runner;
+    hookLlm: import("../hooks/hook-runner.js").HookLlmCall;
+    mcpRevocations: import("../config-center/mcp-revocation.js").McpRevocationLedger;
+    memoryConsolidationFaces: import("./memory-consolidation.js").MemoryConsolidationFaces | undefined;
+    memoryOptOutGrantStore: import("../plugins/memory-optout-grant-store-sql.js").MemoryOptOutGrantStore | undefined;
+    orgMemoryAdmission: import("./org-memory.js").OrgMemoryAdmissionWiring;
+    outcomeSink: import("../plugins/file-outcome-sink.js").OutcomeSink | undefined;
+    principalCaps: import("../runtime-caps-resolver.js").PrincipalEntitlementsClient | undefined;
+    question: import("../question.js").QuestionCoordinator | undefined;
+    retentionExecutor: import("../plugins/retention-store-sql.js").SqlRetentionStore | undefined;
+    retentionLaneStore: import("../plugins/retention-lane-store-sql.js").RetentionLaneStore | undefined;
+    runner: import("@sema-agent/core").Runner;
+    runnerDeps: import("@sema-agent/core").RunnerDeps;
+    runnerTierFrozen: boolean;
+    runtimeCapsPeekResolver: import("../runtime-caps-resolver.js").EntitlementsResolverFn | undefined;
+    sendFileLedger: import("../plugins/send-file-ledger.js").SendFileLedger | undefined;
+    sendUserFileEmitter: import("../capabilities/send-user-file-tool.js").SendUserFileEmitter | undefined;
+    sendUserFileToolSpec: import("@sema-agent/core").ToolSpec<import("@sema-agent/core").TSchema> | undefined;
+    sessionShellGateRegistry: import("./session-shell-gate-registry.js").SessionShellGateRegistry;
+    sessionTitler: import("../session-titler.js").SessionTitler | undefined;
+    sharedMemoryStore: import("../plugins/shared-memory-store-sql.js").SqlSharedMemoryStore | undefined;
+    sqlWorkflowRunStore: import("@sema-agent/core").WorkflowRunStore | undefined;
+    streamApprovalGate: import("../tool-approval.js").StreamApprovalGate;
+    subRunner: import("@sema-agent/core").Runner;
+    subRunnerSessions: import("../plugins/fork-routing-session-store.js").ForkRoutingSessionStore;
+    subagentSteerRegistry: import("../orchestration/subagent-steer.js").SubagentSteerRegistry;
+    toolApproval: import("../tool-approval.js").ToolApprovalCoordinator | undefined;
+    workflowAgentRegistry: import("../orchestration/workflow-agent-steer.js").WorkflowAgentRegistry | undefined;
+    workflowAgentSessionIndex: import("../orchestration/workflow-agent-session-index.js").WorkflowAgentSessionIndex | undefined;
+    workflowCompletionInbox: import("../orchestration/workflow-completion-inbox.js").WorkflowCompletionInbox | undefined;
+    workflowJournalStore: import("../plugins/store-backend.js").ServiceWorkflowJournalStore | undefined;
+    workflowModelAllowlistSnapshot: readonly string[];
+    workflowNotifyGate: import("../orchestration/workflow-notify-journal.js").WorkflowNotifyGate | undefined;
+    workflowNotifyJournal: import("../orchestration/workflow-notify-journal.js").WorkflowNotifyJournalStore | undefined;
+    workflowRecoverOpts: {
+        orphanGraceMs?: number;
+        finalizeStartedBeforeMs?: number;
+        publishTerminalFleetRow?: (id: string, run: import("@sema-agent/core").WorkflowRun) => void;
+    };
+    workflowRunStore: import("../orchestration/workflow-notify-journal.js").JournalingWorkflowRunStore | undefined;
+    workflowsCapable: boolean;
+    deploymentHooks: import("@sema-agent/core").Hooks;
+    deviceLane: import("./device-lane.js").DeviceLane | undefined;
+    dropSessionScoped: (sid: string) => void;
+    executionEnvFactory: import("@sema-agent/core").ExecutionEnvFactory | undefined;
+    fenceSessionOwner: (sid: string, owner: string | null) => void;
+    lspManager: import("../lsp/manager.js").E2bLspManager | import("@sema-agent/core").NodeLspManager | undefined;
+    perSessionCwd: Map<string, string>;
+    perTaskImage: import("../per-task-image.js").PerTaskImageRegistry;
+    sendUserFileTaskEnvs: import("../capabilities/sandbox-file-send.js").TaskEnvRegistry | undefined;
+    sessionEnvSelection: import("../capabilities/select-environment-tool.js").SessionEnvironmentSelection;
+    setSessionCwd: (sid: string, cwd: string) => void;
+    setSessionShellEnv: (sid: string, env: Record<string, string>) => void;
+    worktreeReap: (() => Promise<void>) | undefined;
+    brain: import("@sema-agent/core").Brain;
+    costQuota: import("../observability/cost-quota.js").CostQuota | import("../plugins/pg-cost-quota.js").PgCostQuota | import("../plugins/tidb-cost-quota.js").TiDBCostQuota;
+    counterDegradeHook: (info: {
+        table: string;
+        kind: string;
+        streak: number;
+        prevStreak: number;
+        error?: string;
+    }) => void;
+    fileHistoryStore: import("../plugins/store-backend.js").ServiceFileHistoryStore | undefined;
+    fleetLease: import("../fleet-lease.js").FleetLeaseManager | undefined;
+    fleetUsage: import("../fleet-client.js").FleetUsageAccumulator | undefined;
+    memoryBundleFaces: import("../memory-bundle-engine.js").MemoryBundleFaces | undefined;
+    memoryComplianceFaces: import("../memory-operator-faces.js").MemoryComplianceFaces | undefined;
+    memoryOriginFaces: import("../memory-operator-faces.js").MemoryOriginFaces | undefined;
+    modelUsageTracker: import("../budget.js").ModelUsageTracker;
+    permissionRuleProvider: import("@sema-agent/core").PermissionRuleStoreProvider | undefined;
+    permissionRuleStores: import("../rules-consent.js").PermissionRuleStoreBundle | undefined;
+    pricing: Record<string, import("@sema-agent/core").ModelPricing>;
+    promptManifestTracker: import("../budget.js").PromptManifestTracker;
+    ruleConsent: import("../rules-consent.js").RuleConsentLane | undefined;
+    sessionMemoryStatusFace: import("../memory-operator-faces.js").SessionMemoryStatusFace | undefined;
+    sessionPolicyStore: import("@sema-agent/core").SessionPolicyStore | undefined;
+    sideQueryAccounting: (principal: string | undefined, r: {
+        model: string;
+        usage?: {
+            input?: number;
+            output?: number;
+            cacheRead?: number;
+            cacheWrite?: number;
+            cost?: {
+                total?: number;
+            };
+        };
+    }) => void;
+    toolResultStore: import("../plugins/store-backend.js").ToolResultStoreFull | undefined;
+    tracer: import("@sema-agent/core").TracerHook;
+    backend: import("../index.js").StoreBackend | undefined;
+    backgroundAgentStore: import("@sema-agent/core").BackgroundAgentStore | undefined;
+    breakerState: import("../plugins/breaker-state-sql.js").TiDBBreakerState | import("../plugins/breaker-state-sql.js").PgBreakerState | undefined;
+    instanceId: string;
+    mailboxStore: import("@sema-agent/core").MailboxStore | undefined;
+    memoryEngine: {
+        backend: import("@sema-agent/core").MemoryBackend;
+        root: string;
+    } | undefined;
+    memoryExportBackend: import("@sema-agent/core").MemoryBackend | undefined;
+    memoryPosture: import("../memory-posture.js").MemoryPosture;
+    memorySyncCursors: import("../plugins/memory-sync-store-pg.js").MemorySyncStore | undefined;
+    memorySyncRunner: import("../memory-sync-client.js").MemorySyncRunner | undefined;
+    rosterStore: import("@sema-agent/core").RosterStore | undefined;
+    sessionCaptureRecordStore: import("@sema-agent/core").SessionCaptureRecordStore | undefined;
+    sessionCaptureRecords: import("../index.js").SessionCaptureRecordSource | undefined;
+    sessionStore: import("@sema-agent/core").SessionStore;
+    sqlEngineFacts: (() => import("../plugins/sql-driver.js").SqlEngineFacts | null) | undefined;
+    storeBackendDegraded: boolean;
+    taskAttachmentStore: import("../plugins/task-attachment-store.js").TaskAttachmentStore | undefined;
+    taskListLane: import("./task-list-lane.js").TaskListLane;
+    usageWindowStore: import("@sema-agent/core").UsageWindowStore | undefined;
+    ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
+    configCenter: import("./config-center.js").ConfigCenterRuntime;
+    config: import("../config-types.js").ServiceConfig;
+    localRoot: string;
+    logger: import("../index.js").Logger;
+    metrics: import("../index.js").Metrics;
+}>;
+//# sourceMappingURL=stage-07-capability-layer.d.ts.map

package/dist/boot/stage-07-capability-layer.js

@@ -0,0 +1,162 @@
+import { DEFAULT_MODEL_REF } from "../model-select.js";
+import { probeSearchBackend, DEFAULT_SUBAGENT_TOOL_NAME } from "@sema-agent/core";
+import { selectEnvironmentTool } from "../capabilities/select-environment-tool.js";
+import { subagentSendUserFileExtraTools } from "../capabilities/send-user-file-tool.js";
+import { parseCapEnv, parseNumOrFailNonNegative } from "../config.js";
+import { ensureChildSessionDurableWithPromotion } from "../plugins/session-store.js";
+import { webSearchConfigFromEnv, createWebSearchBackend, shouldProbeWebSearchOnBoot } from "../plugins/web-search.js";
+import { createAuthorizer } 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 { RateLimiter } from "../observability/rate-limit.js";
+import { explicitOperatorOk } from "../http/server.js";
+import { selfOrchestrationDenial } from "../task-workflow.js";
+import { centerEntitlementSourceWired } from "../runtime-caps-resolver.js";
+import { reclaimOrphansAtBoot } from "../boot-reclaim.js";
+import { createParkedReviveInheritedGate } from "./parked-revive-gate.js";
+import { createWebFetchSummarizeLane } from "./webfetch-summarize-lane.js";
+import { createRunnerDepsOnAsk } from "./runner-deps.js";
+import { bindRateLimiter, bindRunStore } from "./late-binds.js";
+export async function runStage07(ctx) {
+    const { backend, backgroundAgentStore, brain, checkpointStore, config, configCenter, counterDegradeHook, durableEnabled, handslessSubRunner, localRoot, logger, memoryEngine, metrics, question, runner, runnerDeps, sendUserFileToolSpec, sessionEnvSelection, sessionStore, subRunner, subRunnerSessions, taskListLane, toolApproval } = ctx;
+    const authorize = createAuthorizer(config, sessionStore);
+    const runStore = backend ? backend.run() : undefined;
+    bindRunStore(runStore);
+    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);
+    bindRateLimiter(rateLimiter);
+    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) });
+    return { ...ctx, approvalExemptionStore, approvalNonceStore, authorize, imageBakes, imageIndex, parkedReviveInheritedGate, parkedReviveTool, rateLimiter, resumeAnchorStore, runStore, scenarioDetails, scenarios, selectEnvTool, singleUserAutoAcceptBaseline, taskLimitCaps, taskTimeoutSec };
+}
+//# sourceMappingURL=stage-07-capability-layer.js.map