@botbotgo/agent-harness 0.0.290 → 0.0.291

package/dist/runtime/harness.js

@@ -9,20 +9,20 @@ import { createBackgroundEventRuntime } from "./harness/background-runtime.js";
 import { PolicyEngine } from "./harness/system/policy-engine.js";
 import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getRoutingRules, } from "../workspace/support/workspace-ref-utils.js";
 import { createHarnessEvent, inferRoutingBindings, renderRuntimeFailure, } from "./support/harness-support.js";
-import { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";
+import { SessionMemorySync } from "./harness/system/session-memory-sync.js";
 import { RuntimeMemorySync, readRuntimeMemorySyncConfig } from "./harness/system/runtime-memory-sync.js";
 import { SqliteBackedStore } from "./harness/system/store.js";
 import { HealthMonitor, readHealthMonitorConfig, } from "./harness/system/health-monitor.js";
-import { normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, } from "./harness/run/helpers.js";
+import { normalizeInvocationEnvelope, normalizeRequestPriority, resolveRequestListeners, } from "./harness/run/helpers.js";
 import { emitHarnessEvent, } from "./harness/events/events.js";
 import { createRuntimeEventOperations } from "./harness/events/runtime-event-operations.js";
-import { appendAssistantMessage as appendLifecycleAssistantMessage, finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, } from "./harness/run/run-lifecycle.js";
+import { appendAssistantMessage as appendLifecycleAssistantMessage, finalizeCancelledRequest as finalizeLifecycleCancelledRequest, finalizeContinuedRequest as finalizeLifecycleContinuedRequest, } from "./harness/run/run-lifecycle.js";
 import { createListenerDispatchRuntime } from "./harness/events/listener-runtime.js";
 import { buildResumePayload as buildHarnessResumePayload, resolveApprovalRecord as resolveHarnessApprovalRecord, } from "./harness/run/resume.js";
-import { cancelRunOperation, executeQueuedRunOperation, resumeRun } from "./harness/run/run-operations.js";
+import { cancelRequestOperation, executeQueuedRequestOperation, resumeRequest } from "./harness/run/run-operations.js";
 import { projectOperatorOverview } from "./harness/run/operator-overview.js";
-import { acquireRunSlot as acquireHarnessRunSlot } from "./harness/run/run-slot-acquisition.js";
-import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-queue.js";
+import { acquireRequestSlot as acquireHarnessRunSlot } from "./harness/run/run-slot-acquisition.js";
+import { dropPendingRequestSlot, enqueuePendingRequestSlot } from "./harness/run/run-queue.js";
 import { getDefaultRuntimeEntryAgentId, resolveSelectedAgentId, routeAgentId } from "./harness/run/routing.js";
 import { resolveStoreFromConfig, resolveVectorStore, } from "./harness/run/resources.js";
 import { createRuntimeMcpServer, createToolMcpServerFromTools, serveRuntimeMcpOverStdio, serveToolsOverStdioFromHarness, } from "../mcp.js";
@@ -30,20 +30,20 @@ import { closeMcpClientsForWorkspace } from "../resource/mcp-tool-support.js";
 import { getBindingRuntimeExecutionMode, } from "./support/compiled-binding.js";
 import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
 import { describeWorkspaceInventory, getAgentInventoryRecord, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
-import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
+import { createDefaultHealthSnapshot, isInventoryEnabled, isSessionMemorySyncEnabled, } from "./harness/runtime-defaults.js";
 import { Mem0IngestionSync, Mem0SemanticRecall, readMem0RuntimeConfig, } from "./harness/system/mem0-ingestion-sync.js";
 import { createRuntimeMemoryManager, RuntimeMemoryFormationSync, readRuntimeMemoryFormationConfig, } from "./harness/system/runtime-memory-manager.js";
 import { readRuntimeMemoryMaintenanceConfig, readRuntimeMemoryPolicyConfig, resolveMemoryNamespace, } from "./harness/system/runtime-memory-policy.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
 import { resolveKnowledgeStorePath } from "./support/runtime-layout.js";
-import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
+import { initializeHarnessRuntime, reclaimExpiredClaimedRequests as reclaimHarnessExpiredClaimedRequests, recoverStartupRequests as recoverHarnessStartupRequests, isStaleRunningRequest as isHarnessStaleRunningRequest, } from "./harness/run/startup-runtime.js";
 import { traceStartupStage } from "./startup-tracing.js";
 import { normalizeProcessExecutablePath } from "./support/runtime-env.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
 import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-run.js";
-import { buildRequestInspectionRecord, buildSessionInspectionRecord, deleteSessionRecord, deleteThreadRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/thread-records.js";
+import { buildRequestInspectionRecord, buildSessionInspectionRecord, deleteSessionRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/session-records.js";
 import { createKnowledgeModule } from "../knowledge/index.js";
-const ACTIVE_RUN_STATES = [
+const ACTIVE_REQUEST_STATES = [
     "queued",
     "claimed",
     "running",
@@ -51,10 +51,10 @@ const ACTIVE_RUN_STATES = [
     "resuming",
     "cancelling",
 ];
-function toPublicRunResultShape(result) {
+function toPublicRequestResultShape(result) {
     return {
-        sessionId: result.sessionId ?? result.threadId ?? "",
-        requestId: result.requestId ?? result.runId ?? "",
+        sessionId: result.sessionId ?? result.legacySessionId ?? "",
+        requestId: result.requestId ?? result.legacyRequestId ?? "",
         state: result.state,
         output: result.output,
         finalMessageText: result.finalMessageText,
@@ -109,7 +109,7 @@ function toPublicHarnessStreamItem(item) {
         case "result":
             return {
                 type: "result",
-                result: toPublicRunResultShape(item.result),
+                result: toPublicRequestResultShape(item.result),
             };
         default:
             return item;
@@ -165,9 +165,9 @@ export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
     static BACKGROUND_EVENT_TYPES = new Set([
-        "run.created",
-        "run.queued",
-        "run.dequeued",
+        "request.created",
+        "request.queued",
+        "request.dequeued",
         "output.delta",
     ]);
     eventBus = new EventBus();
@@ -180,15 +180,15 @@ export class AgentHarnessRuntime {
     vectorStores = new Map();
     runtimeEntryBindings;
     defaultRuntimeEntryBinding;
-    defaultRunRootValue;
+    defaultRuntimeRootValue;
     defaultStore;
     runtimeMemoryStore;
     runtimeMemoryPolicy;
     runtimeMemoryMaintenanceConfig;
     routingRules;
     routingDefaultAgentId;
-    threadMemorySync;
-    unregisterThreadMemorySync;
+    sessionMemorySync;
+    unregisterSessionMemorySync;
     runtimeMemorySync;
     unregisterRuntimeMemorySync;
     mem0IngestionSync;
@@ -205,9 +205,9 @@ export class AgentHarnessRuntime {
     concurrencyConfig;
     backgroundTasks = new Set();
     workerId = `worker-${createPersistentId()}`;
-    activeRunSlots = 0;
+    activeRequestSlots = 0;
     pendingRunInsertionOrder = 0;
-    pendingRunSlots = [];
+    pendingRequestSlots = [];
     runtimeEventSequence = 0;
     initialized = false;
     closed = false;
@@ -226,20 +226,20 @@ export class AgentHarnessRuntime {
             return null;
         }
     }
-    defaultRunRoot() {
-        return this.defaultRunRootValue;
+    defaultRuntimeRoot() {
+        return this.defaultRuntimeRootValue;
     }
     getDefaultRuntimeEntryAgentId() {
         return getDefaultRuntimeEntryAgentId(this.workspace, this.routingDefaultAgentId);
     }
-    async resolveSelectedAgentId(input, requestedAgentId, threadId) {
+    async resolveSelectedAgentId(input, requestedAgentId, sessionId) {
         return resolveSelectedAgentId({
             workspace: this.workspace,
             input,
             requestedAgentId,
-            threadId,
+            sessionId,
             preferredRuntimeEntryAgentId: this.routingDefaultAgentId,
-            getThreadSummary: (currentThreadId) => this.getSession(currentThreadId),
+            getSessionSummary: (currentSessionId) => this.getSessionSummaryRecord(currentSessionId),
         });
     }
     createPrepareRunStartRuntime() {
@@ -247,9 +247,9 @@ export class AgentHarnessRuntime {
             workspace: this.workspace,
             policyEngine: this.policyEngine,
             persistence: this.persistence,
-            resolveSelectedAgentId: (input, requestedAgentId, threadId) => this.resolveSelectedAgentId(input, requestedAgentId, threadId),
-            emitRunCreated: (threadId, runId, payload) => this.runtimeEventOperations.emitRunCreated(threadId, runId, payload),
-            acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
+            resolveSelectedAgentId: (input, requestedAgentId, sessionId) => this.resolveSelectedAgentId(input, requestedAgentId, sessionId),
+            emitRequestCreated: (sessionId, requestId, payload) => this.runtimeEventOperations.emitRequestCreated(sessionId, requestId, payload),
+            acquireRequestSlot: (sessionId, requestId, activeState, priority) => this.acquireRequestSlot(sessionId, requestId, activeState, priority),
         };
     }
     constructor(workspace, runtimeAdapterOptions = {}) {
@@ -258,16 +258,16 @@ export class AgentHarnessRuntime {
         normalizeProcessExecutablePath();
         this.runtimeEntryBindings = inferRoutingBindings(this.workspace).runtimeEntryBindings;
         this.defaultRuntimeEntryBinding = this.runtimeEntryBindings[0];
-        this.defaultRunRootValue = this.defaultRuntimeEntryBinding?.harnessRuntime.runRoot ?? `${this.workspace.workspaceRoot}/.agent`;
-        const runRoot = this.defaultRunRoot();
-        this.persistence = new SqlitePersistence(runRoot);
+        this.defaultRuntimeRootValue = this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeRoot ?? `${this.workspace.workspaceRoot}/.agent`;
+        const runtimeRoot = this.defaultRuntimeRoot();
+        this.persistence = new SqlitePersistence(runtimeRoot);
         const defaultStoreConfig = this.defaultRuntimeEntryBinding?.harnessRuntime.store;
-        this.defaultStore = resolveStoreFromConfig(this.stores, defaultStoreConfig, runRoot) ?? new SqliteBackedStore(resolveKnowledgeStorePath(runRoot));
+        this.defaultStore = resolveStoreFromConfig(this.stores, defaultStoreConfig, runtimeRoot) ?? new SqliteBackedStore(resolveKnowledgeStorePath(runtimeRoot));
         const runtimeMemoryStoreConfig = typeof this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory?.store === "object" &&
             this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory?.store
             ? this.defaultRuntimeEntryBinding.harnessRuntime.runtimeMemory.store
             : undefined;
-        this.runtimeMemoryStore = resolveStoreFromConfig(this.stores, runtimeMemoryStoreConfig, runRoot) ?? this.defaultStore;
+        this.runtimeMemoryStore = resolveStoreFromConfig(this.stores, runtimeMemoryStoreConfig, runtimeRoot) ?? this.defaultStore;
         this.runtimeMemoryPolicy = readRuntimeMemoryPolicyConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory, this.workspace.workspaceRoot) ?? null;
         this.runtimeMemoryMaintenanceConfig =
             readRuntimeMemoryMaintenanceConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory) ?? null;
@@ -279,7 +279,7 @@ export class AgentHarnessRuntime {
             defaultStore: this.defaultStore,
             embeddingModels: this.embeddingModels,
             vectorStores: this.vectorStores,
-            getDefaultRunRoot: () => this.defaultRunRoot(),
+            getDefaultRuntimeRoot: () => this.defaultRuntimeRoot(),
         });
         this.runtimeAdapter = new AgentRuntimeAdapter(this.resolvedRuntimeAdapterOptions);
         this.backgroundEventRuntime = createBackgroundEventRuntime({
@@ -291,32 +291,33 @@ export class AgentHarnessRuntime {
         this.runtimeEventOperations = createRuntimeEventOperations(this.backgroundEventRuntime);
         this.routingRules = getRoutingRules(workspace.refs);
         this.routingDefaultAgentId = getRoutingDefaultAgentId(workspace.refs);
-        if (isThreadMemorySyncEnabled(workspace)) {
-            this.threadMemorySync = new ThreadMemorySync(this.persistence, this.runtimeMemoryStore, {
-                resolveThreadNamespace: (sessionId) => {
+        if (isSessionMemorySyncEnabled(workspace)) {
+            this.sessionMemorySync = new SessionMemorySync(this.persistence, this.runtimeMemoryStore, {
+                resolveSessionNamespace: (sessionId) => {
                     const binding = this.defaultRuntimeEntryBinding;
                     if (!binding) {
                         return ["memories", "sessions", sessionId];
                     }
-                    return this.resolveMemoryNamespace("thread", binding, { sessionId });
+                    return this.resolveMemoryNamespace("session", binding, { sessionId });
                 },
             });
-            this.unregisterThreadMemorySync = this.eventBus.registerProjection(this.threadMemorySync);
+            this.unregisterSessionMemorySync = this.eventBus.registerProjection(this.sessionMemorySync);
         }
         else {
-            this.threadMemorySync = null;
-            this.unregisterThreadMemorySync = () => { };
+            this.sessionMemorySync = null;
+            this.unregisterSessionMemorySync = () => { };
         }
         const runtimeMemorySyncConfig = readRuntimeMemorySyncConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory);
         if (runtimeMemorySyncConfig) {
             this.runtimeMemorySync = new RuntimeMemorySync(this.persistence, this.runtimeMemoryStore, runtimeMemorySyncConfig, {
-                resolveThreadNamespace: (sessionId) => {
+                resolveSessionNamespace: (sessionId) => {
                     const binding = this.defaultRuntimeEntryBinding;
                     if (!binding) {
                         return ["memories", "sessions", sessionId];
                     }
-                    return this.resolveMemoryNamespace("thread", binding, { sessionId });
+                    return this.resolveMemoryNamespace("session", binding, { sessionId });
                 },
+                resolveRequestNamespace: (sessionId) => ["memories", "requests", sessionId],
             });
             this.unregisterRuntimeMemorySync = this.eventBus.registerProjection(this.runtimeMemorySync);
         }
@@ -326,7 +327,7 @@ export class AgentHarnessRuntime {
         }
         const mem0RuntimeConfig = readMem0RuntimeConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory, this.workspace.workspaceRoot);
         if (mem0RuntimeConfig) {
-            this.mem0IngestionSync = new Mem0IngestionSync(this.persistence, mem0RuntimeConfig, runRoot);
+            this.mem0IngestionSync = new Mem0IngestionSync(this.persistence, mem0RuntimeConfig, runtimeRoot);
             this.unregisterMem0IngestionSync = this.eventBus.registerProjection(this.mem0IngestionSync);
             this.mem0SemanticRecall = new Mem0SemanticRecall(mem0RuntimeConfig);
         }
@@ -353,7 +354,7 @@ export class AgentHarnessRuntime {
             resolveNamespace: (scope, context) => {
                 const binding = this.defaultRuntimeEntryBinding;
                 if (!binding) {
-                    const identifier = scope === "thread"
+                    const identifier = scope === "session"
                         ? context.sessionId
                         : scope === "agent"
                             ? context.agentId
@@ -376,8 +377,8 @@ export class AgentHarnessRuntime {
                 ? ({ candidates, context, existingRecords }) => this.runtimeMemoryManager.transform({
                     candidates,
                     binding: this.defaultRuntimeEntryBinding,
-                    threadId: context.sessionId ?? `memory-api-${context.requestId ?? "unknown"}`,
-                    runId: context.requestId ?? createPersistentId(new Date(context.recordedAt ?? new Date().toISOString())),
+                    sessionId: context.sessionId ?? `memory-api-${context.requestId ?? "unknown"}`,
+                    requestId: context.requestId ?? createPersistentId(new Date(context.recordedAt ?? new Date().toISOString())),
                     recordedAt: context.recordedAt ?? new Date().toISOString(),
                     existingRecords,
                 })
@@ -386,14 +387,14 @@ export class AgentHarnessRuntime {
         });
         if (runtimeMemoryFormationConfig) {
             this.runtimeMemoryFormationSync = new RuntimeMemoryFormationSync(this.persistence, runtimeMemoryFormationConfig, (input) => this.knowledgeModule.memorizeCandidates(input.candidates, {
-                sessionId: input.threadId,
-                requestId: input.runId,
+                sessionId: input.sessionId,
+                requestId: input.requestId,
                 agentId: input.agentId,
                 workspaceId: this.getWorkspaceId(this.defaultRuntimeEntryBinding),
                 userId: input.userId,
                 projectId: input.projectId,
                 recordedAt: input.recordedAt,
-            }, { storeCandidateLog: false }).then(() => undefined), runRoot);
+            }, { storeCandidateLog: false }).then(() => undefined), runtimeRoot);
             this.unregisterRuntimeMemoryFormationSync = this.eventBus.registerProjection(this.runtimeMemoryFormationSync);
         }
         else {
@@ -409,8 +410,8 @@ export class AgentHarnessRuntime {
         return new HealthMonitor({
             workspace: this.workspace,
             persistence: this.persistence,
-            getActiveRunSlots: () => this.activeRunSlots,
-            getPendingRunSlots: () => this.pendingRunSlots.length,
+            getActiveRequestSlots: () => this.activeRequestSlots,
+            getPendingRequestSlots: () => this.pendingRequestSlots.length,
             getCheckpointMaintenanceStatus: () => null,
             getRuntimeRecordMaintenanceStatus: () => null,
             publishEvent: async (payload) => {
@@ -436,7 +437,7 @@ export class AgentHarnessRuntime {
             healthMonitor: this.healthMonitor,
             scheduleBackgroundTask: (task) => this.scheduleBackgroundStartupTask(task),
         });
-        this.scheduleBackgroundStartupTask(traceStartupStage("runtime.initialize.startupRecovery", () => this.recoverStartupRuns()));
+        this.scheduleBackgroundStartupTask(traceStartupStage("runtime.initialize.startupRecovery", () => this.recoverStartupRequests()));
         this.initialized = true;
     }
     subscribe(listener) {
@@ -446,17 +447,17 @@ export class AgentHarnessRuntime {
         if (this.healthMonitor) {
             return this.healthMonitor.getSnapshot();
         }
-        return createDefaultHealthSnapshot(this.activeRunSlots, this.pendingRunSlots.length);
+        return createDefaultHealthSnapshot(this.activeRequestSlots, this.pendingRequestSlots.length);
     }
     async getOperatorOverview(options) {
-        const [health, runs, approvals] = await Promise.all([
+        const [health, requests, approvals] = await Promise.all([
             this.getHealth(),
-            Promise.all(ACTIVE_RUN_STATES.map((state) => this.listRuns({ state }))).then((groups) => groups.flat()),
+            Promise.all(ACTIVE_REQUEST_STATES.map((state) => this.listRequests({ state }))).then((groups) => groups.flat()),
             this.listApprovals({ status: "pending" }),
         ]);
         return projectOperatorOverview({
             health,
-            runs,
+            requests,
             approvals,
             limit: options?.limit,
         });
@@ -477,20 +478,17 @@ export class AgentHarnessRuntime {
         const sessions = await this.persistence.listSessionSummaries(filter);
         return sessions.map((session) => toSessionListSummary(session));
     }
-    async listThreads(filter) {
-        return this.listSessions(filter);
-    }
     async listRequests(filter) {
-        const requests = await this.persistence.listRuns({
+        const requests = await this.persistence.listRequests({
             agentId: filter?.agentId,
-            threadId: filter?.sessionId,
+            sessionId: filter?.sessionId,
             state: filter?.state,
         });
         return requests.map((request) => ({
             requestId: request.requestId,
             sessionId: request.sessionId,
             agentId: request.agentId,
-            parentRunId: request.parentRunId,
+            parentRequestId: request.parentRequestId,
             executionMode: request.executionMode,
             adapterKind: request.adapterKind,
             createdAt: request.createdAt,
@@ -506,13 +504,6 @@ export class AgentHarnessRuntime {
             runtimeSnapshot: request.runtimeSnapshot,
         }));
     }
-    async listRuns(filter) {
-        return this.listRequests({
-            agentId: filter?.agentId,
-            sessionId: filter?.threadId,
-            state: filter?.state,
-        });
-    }
     async memorize(input) {
         const binding = this.defaultRuntimeEntryBinding;
         if (!binding) {
@@ -578,12 +569,9 @@ export class AgentHarnessRuntime {
         });
     }
     async getRequest(requestId) {
-        const request = await this.persistence.getRun(requestId);
+        const request = await this.persistence.getRequest(requestId);
         return request ? buildRequestInspectionRecord(this.persistence, request) : null;
     }
-    async getRun(runId) {
-        return this.getRequest(runId);
-    }
     async getSessionSummary(sessionId) {
         const session = await this.persistence.getSession(sessionId);
         return session
@@ -598,8 +586,11 @@ export class AgentHarnessRuntime {
             }
             : null;
     }
-    async getSession(threadId) {
-        return this.getSessionSummary(threadId);
+    async getSessionSummaryRecord(sessionId) {
+        return this.getSessionSummary(sessionId);
+    }
+    async getSession(sessionId) {
+        return this.getSessionRecord(sessionId);
     }
     async getSessionRecord(sessionId) {
         return buildSessionInspectionRecord({
@@ -607,16 +598,13 @@ export class AgentHarnessRuntime {
             getSession: (currentSessionId) => this.getSessionSummary(currentSessionId),
         }, sessionId);
     }
-    async getThread(threadId) {
-        return this.getSessionRecord(threadId);
-    }
     async listApprovals(filter) {
         const approvals = await listPublicApprovals({
             persistence: this.persistence,
         }, {
             status: filter?.status,
-            threadId: filter?.sessionId,
-            runId: filter?.requestId,
+            sessionId: filter?.sessionId,
+            requestId: filter?.requestId,
         });
         return approvals;
     }
@@ -625,17 +613,14 @@ export class AgentHarnessRuntime {
             persistence: this.persistence,
         }, approvalId);
     }
-    async listArtifacts(threadId, runId) {
-        const listing = await this.persistence.listArtifacts(threadId, runId);
+    async listRequestArtifacts(sessionId, requestId) {
+        const listing = await this.persistence.listRequestArtifacts(sessionId, requestId);
         return {
             sessionId: listing.sessionId,
             requestId: listing.requestId,
             items: listing.items,
         };
     }
-    async readArtifact(threadId, runId, artifactPath) {
-        return this.persistence.readArtifact(threadId, runId, normalizeRecordedArtifactPath(artifactPath));
-    }
     async recordArtifact(input) {
         const session = await this.getSessionRecord(input.sessionId);
         if (!session) {
@@ -655,27 +640,27 @@ export class AgentHarnessRuntime {
                 ? input.createdAt.trim()
                 : new Date().toISOString(),
         };
-        return this.persistence.createArtifact(input.sessionId, input.requestId, artifact, input.content);
+        return this.persistence.createRequestArtifact(input.sessionId, input.requestId, artifact, input.content);
     }
-    async listRequestEvents(sessionId, requestId) {
-        return this.persistence.listRunEvents(sessionId, requestId);
+    async readRequestArtifact(sessionId, requestId, artifactPath) {
+        return this.persistence.readRequestArtifact(sessionId, requestId, artifactPath);
     }
-    async listRunEvents(threadId, runId) {
-        return this.listRequestEvents(threadId, runId);
+    async listRequestEvents(sessionId, requestId) {
+        return this.persistence.listRequestEvents(sessionId, requestId);
     }
     async exportRequestPackage(input) {
         const session = await this.getSessionRecord(input.sessionId);
         const request = await this.getRequest(input.requestId);
         const approvals = await this.listApprovals({ sessionId: input.sessionId, requestId: input.requestId });
-        const transcript = await this.persistence.listThreadMessages(input.sessionId, 500);
+        const transcript = await this.persistence.listSessionMessages(input.sessionId, 500);
         const events = await this.listRequestEvents(input.sessionId, input.requestId);
         const artifactsListing = input.includeArtifacts === false
             ? { items: [] }
-            : await this.persistence.listArtifacts(input.sessionId, input.requestId);
+            : await this.persistence.listRequestArtifacts(input.sessionId, input.requestId);
         const artifacts = await Promise.all(artifactsListing.items.map(async (artifact) => ({
             ...artifact,
             ...(input.includeArtifactContents === true
-                ? { content: await this.persistence.readArtifact(input.sessionId, input.requestId, artifact.path) }
+                ? { content: await this.persistence.readRequestArtifact(input.sessionId, input.requestId, artifact.path) }
                 : {}),
         })));
         const approvalSummary = summarizeApprovalEvidence(approvals);
@@ -708,7 +693,7 @@ export class AgentHarnessRuntime {
     async exportSessionPackage(input) {
         const session = await this.getSessionRecord(input.sessionId);
         const requestIds = Array.from(new Set((session?.requests ?? []).map((item) => item.requestId)));
-        const runs = await Promise.all(requestIds.map((requestId) => this.exportRequestPackage({
+        const requestPackages = await Promise.all(requestIds.map((requestId) => this.exportRequestPackage({
             sessionId: input.sessionId,
             requestId,
             includeArtifacts: input.includeArtifacts,
@@ -717,7 +702,7 @@ export class AgentHarnessRuntime {
         })));
         const approvals = await this.listApprovals({ sessionId: input.sessionId });
         const approvalSummary = summarizeApprovalEvidence(approvals);
-        const governanceRuns = runs
+        const governanceRequests = requestPackages
             .filter((item) => item.request?.requestId)
             .map((item) => ({
             requestId: item.request.requestId,
@@ -725,45 +710,45 @@ export class AgentHarnessRuntime {
         }));
         return {
             session,
-            requests: runs.map((item) => item.request).filter((item) => Boolean(item)),
+            requests: requestPackages.map((item) => item.request).filter((item) => Boolean(item)),
             approvals,
-            transcript: await this.persistence.listThreadMessages(input.sessionId, 500),
-            runs,
+            transcript: await this.persistence.listSessionMessages(input.sessionId, 500),
+            requestsPackages: requestPackages,
             governance: {
-                runs: governanceRuns,
+                requests: governanceRequests,
                 approvalSummary,
-                summary: `${governanceRuns.length} run evidence package(s), ${approvalSummary.total} approval record(s)`,
+                summary: `${governanceRequests.length} request evidence package(s), ${approvalSummary.total} approval record(s)`,
             },
             ...(input.includeRuntimeHealth === false ? {} : { runtimeHealth: await this.getHealth() }),
         };
     }
     async exportEvaluationBundle(input) {
-        const thread = await this.getThread(input.sessionId);
-        const run = await this.getRun(input.requestId);
-        const runRequest = await this.persistence.getRunRequest(input.sessionId, input.requestId);
+        const session = await this.getSessionRecord(input.sessionId);
+        const request = await this.getRequest(input.requestId);
+        const requestInput = await this.persistence.getRequestInput(input.sessionId, input.requestId);
         const approvals = await this.listApprovals({ sessionId: input.sessionId, requestId: input.requestId });
-        const transcript = await this.persistence.listThreadMessages(input.sessionId, 500);
-        const events = await this.persistence.listRunEvents(input.sessionId, input.requestId);
+        const transcript = await this.persistence.listSessionMessages(input.sessionId, 500);
+        const events = await this.persistence.listRequestEvents(input.sessionId, input.requestId);
         const runtimeHealth = await this.getHealth();
         const artifactsListing = input.includeArtifacts === false
             ? { items: [] }
-            : await this.persistence.listArtifacts(input.sessionId, input.requestId);
+            : await this.persistence.listRequestArtifacts(input.sessionId, input.requestId);
         const artifacts = await Promise.all(artifactsListing.items.map(async (artifact) => ({
             ...artifact,
             ...(input.includeArtifactContents === true
-                ? { content: await this.persistence.readArtifact(input.sessionId, input.requestId, artifact.path) }
+                ? { content: await this.persistence.readRequestArtifact(input.sessionId, input.requestId, artifact.path) }
                 : {}),
         })));
         return {
-            session: thread ? toSessionRecord(thread) : null,
-            request: run ? toRequestRecord(run) : null,
-            runRequest: runRequest
+            session: session ? toSessionRecord(session) : null,
+            request: request ? toRequestRecord(request) : null,
+            requestInput: requestInput
                 ? {
-                    input: runRequest.input,
-                    ...(runRequest.invocation ? { invocation: runRequest.invocation } : {}),
-                    ...(typeof runRequest.priority === "number" ? { priority: runRequest.priority } : {}),
+                    input: requestInput.input,
+                    ...(requestInput.invocation ? { invocation: requestInput.invocation } : {}),
+                    ...(typeof requestInput.priority === "number" ? { priority: requestInput.priority } : {}),
                 }
-                : (deriveRunRequestFromTranscript(transcript, input.requestId) ?? null),
+                : (deriveRequestInputFromTranscript(transcript, input.requestId) ?? null),
             approvals,
             transcript,
             events,
@@ -786,15 +771,15 @@ export class AgentHarnessRuntime {
         if (!replayAgentId) {
             throw new Error("Evaluation replay requires an agentId on the replay input or exported bundle.");
         }
-        const replayRequest = input.bundle.runRequest ?? deriveRunRequestFromTranscript(input.bundle.transcript, input.bundle.request?.requestId);
+        const replayRequest = input.bundle.requestInput ?? deriveRequestInputFromTranscript(input.bundle.transcript, input.bundle.request?.requestId);
         if (!replayRequest) {
-            throw new Error("Evaluation replay requires bundle.runRequest from exportEvaluationBundle.");
+            throw new Error("Evaluation replay requires bundle.requestInput from exportEvaluationBundle.");
         }
         const invocation = input.invocation ?? replayRequest.invocation;
         const result = await this.run({
             agentId: replayAgentId,
             input: replayRequest.input,
-            ...(input.sessionId ? { threadId: input.sessionId } : {}),
+            ...(input.sessionId ? { sessionId: input.sessionId } : {}),
             ...(invocation ? { invocation } : {}),
         });
         const expected = typeof input.bundle.expectedOutput === "string" ? input.bundle.expectedOutput.trim() : "";
@@ -829,7 +814,7 @@ export class AgentHarnessRuntime {
             ...options,
         });
     }
-    async deleteThreadCheckpoints(threadId) {
+    async deleteSessionCheckpoints(sessionId) {
         const resolver = this.resolvedRuntimeAdapterOptions.checkpointerResolver;
         if (!resolver) {
             return;
@@ -841,29 +826,20 @@ export class AgentHarnessRuntime {
                 continue;
             }
             seen.add(saver);
-            const maybeDeleteThread = saver.deleteThread;
-            if (typeof maybeDeleteThread === "function") {
-                await maybeDeleteThread.call(saver, threadId);
+            const maybeDeleteSession = saver.deleteSession;
+            if (typeof maybeDeleteSession === "function") {
+                await maybeDeleteSession.call(saver, sessionId);
+                continue;
             }
         }
     }
     async deleteSession(sessionId) {
         return deleteSessionRecord({
             getSession: (currentSessionId) => this.getSessionRecord(currentSessionId),
-            deleteSession: (currentSessionId) => this.persistence.deleteThread(currentSessionId),
-            deleteSessionCheckpoints: (currentSessionId) => this.deleteThreadCheckpoints(currentSessionId),
+            deleteSession: (currentSessionId) => this.persistence.deleteSession(currentSessionId),
+            deleteSessionCheckpoints: (currentSessionId) => this.deleteSessionCheckpoints(currentSessionId),
         }, sessionId);
     }
-    async deleteThread(threadId) {
-        return this.deleteSession(threadId);
-    }
-    async deleteThreadLegacy(threadId) {
-        return deleteThreadRecord({
-            getThread: (currentThreadId) => this.getThread(currentThreadId),
-            deleteThread: (currentThreadId) => this.persistence.deleteThread(currentThreadId),
-            deleteThreadCheckpoints: (currentThreadId) => this.deleteThreadCheckpoints(currentThreadId),
-        }, threadId);
-    }
     async createToolMcpServer(options) {
         const tools = this.resolveToolMcpServerTools(options.agentId);
         return createToolMcpServerFromTools(tools, options);
@@ -884,16 +860,16 @@ export class AgentHarnessRuntime {
             input,
             routingRules: this.routingRules,
             routingDefaultAgentId: this.routingDefaultAgentId,
-            threadId: options.threadId,
+            sessionId: options.sessionId,
         });
     }
-    async emit(threadId, runId, sequence, eventType, payload, source = "runtime") {
+    async emit(sessionId, requestId, sequence, eventType, payload, source = "runtime") {
         return emitHarnessEvent({
             persistence: this.persistence,
             publishEvent: (event) => this.eventBus.publish(event),
             trackBackgroundTask: (task) => this.trackBackgroundTask(task),
             backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
-        }, threadId, runId, sequence, eventType, payload, source);
+        }, sessionId, requestId, sequence, eventType, payload, source);
     }
     trackBackgroundTask(task) {
         this.backgroundTasks.add(task);
@@ -915,39 +891,39 @@ export class AgentHarnessRuntime {
             sourceTool: this.workspace.tools.get(compiledTool.id),
         }));
     }
-    async loadPriorHistory(threadId, runId) {
-        const history = await this.persistence.listThreadMessages(threadId);
-        return history.filter((message) => message.requestId !== runId);
+    async loadPriorHistory(sessionId, requestId) {
+        const history = await this.persistence.listSessionMessages(sessionId);
+        return history.filter((message) => message.requestId !== requestId);
     }
-    async loadRunInput(threadId, runId) {
-        const history = await this.persistence.listThreadMessages(threadId, 100);
-        const userTurn = history.find((message) => message.requestId === runId && message.role === "user");
+    async loadRequestInput(sessionId, requestId) {
+        const history = await this.persistence.listSessionMessages(sessionId, 100);
+        const userTurn = history.find((message) => message.requestId === requestId && message.role === "user");
         return userTurn?.content ?? "";
     }
-    async getRunCancellation(runId) {
-        const control = await this.persistence.getRunControl(runId);
+    async getRequestCancellation(requestId) {
+        const control = await this.persistence.getRequestControl(requestId);
         return {
             requested: control?.cancelRequested === true,
             ...(control?.cancelReason ? { reason: control.cancelReason } : {}),
         };
     }
-    async finalizeCancelledRun(threadId, runId, previousState, reason) {
-        return finalizeLifecycleCancelledRun({
+    async finalizeCancelledRequest(sessionId, requestId, previousState, reason) {
+        return finalizeLifecycleCancelledRequest({
             persistence: this.persistence,
-            emit: (currentThreadId, currentRunId, sequence, eventType, payload, source) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload, source),
-            setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, options) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, options),
-        }, threadId, runId, previousState, reason);
+            emit: (currentSessionId, currentRequestId, sequence, eventType, payload, source) => this.emit(currentSessionId, currentRequestId, sequence, eventType, payload, source),
+            setRequestStateAndEmit: (currentSessionId, currentRequestId, sequence, state, options) => this.setRequestStateAndEmit(currentSessionId, currentRequestId, sequence, state, options),
+        }, sessionId, requestId, previousState, reason);
     }
-    async invokeWithHistory(binding, input, threadId, runId, resumePayload, priorHistory, options = {}) {
-        const history = priorHistory ?? await this.loadPriorHistory(threadId, runId);
-        const memoryContext = options.memoryContext ?? await this.buildRuntimeMemoryContext(binding, threadId, input);
+    async invokeWithHistory(binding, input, sessionId, requestId, resumePayload, priorHistory, options = {}) {
+        const history = priorHistory ?? await this.loadPriorHistory(sessionId, requestId);
+        const memoryContext = options.memoryContext ?? await this.buildRuntimeMemoryContext(binding, sessionId, input);
         const startedAt = Date.now();
         try {
-            const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, history, {
+            const result = await this.runtimeAdapter.invoke(binding, input, sessionId, requestId, resumePayload, history, {
                 ...options,
                 ...(memoryContext ? { memoryContext } : {}),
             });
-            await this.persistRuntimeMemoryCandidates(binding, threadId, runId, result.metadata?.memoryCandidates);
+            await this.persistRuntimeMemoryCandidates(binding, sessionId, requestId, result.metadata?.memoryCandidates);
             this.recordLlmSuccess(startedAt);
             return result;
         }
@@ -971,18 +947,18 @@ export class AgentHarnessRuntime {
         const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
         return path.basename(workspaceRoot) || "default";
     }
-    async buildRuntimeMemoryContext(binding, threadId, input) {
+    async buildRuntimeMemoryContext(binding, sessionId, input) {
         const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
         return this.knowledgeModule.buildPromptContext({
             query,
             topK: this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? 8,
         }, {
-            sessionId: threadId,
+            sessionId,
             agentId: binding.agent.id,
             workspaceId: this.getWorkspaceId(binding),
         });
     }
-    async persistRuntimeMemoryCandidates(binding, threadId, runId, value) {
+    async persistRuntimeMemoryCandidates(binding, sessionId, requestId, value) {
         if (!Array.isArray(value) || value.length === 0) {
             return;
         }
@@ -996,62 +972,62 @@ export class AgentHarnessRuntime {
             return;
         }
         await this.knowledgeModule.memorizeCandidates(candidates, {
-            sessionId: threadId,
-            requestId: runId,
+            sessionId,
+            requestId,
             agentId: binding.agent.id,
             workspaceId: this.getWorkspaceId(binding),
             recordedAt: new Date().toISOString(),
         }, { storeCandidateLog: true });
     }
-    async resolvePersistedRunPriority(threadId, runId) {
-        const persisted = await this.persistence.getRunRequest(threadId, runId);
-        return normalizeRunPriority(persisted?.priority);
+    async resolvePersistedRequestPriority(sessionId, requestId) {
+        const persisted = await this.persistence.getRequestInput(sessionId, requestId);
+        return normalizeRequestPriority(persisted?.priority);
     }
-    enqueuePendingRunSlot(entry) {
-        return enqueuePendingRunSlot(this.pendingRunSlots, entry, this.pendingRunInsertionOrder++);
+    enqueuePendingRequestSlot(entry) {
+        return enqueuePendingRequestSlot(this.pendingRequestSlots, entry, this.pendingRunInsertionOrder++);
     }
-    async executeQueuedRun(binding, input, threadId, runId, agentId, options = {}) {
-        return executeQueuedRunOperation({
+    async executeQueuedRequest(binding, input, sessionId, requestId, agentId, options = {}) {
+        return executeQueuedRequestOperation({
             persistence: this.persistence,
-            getRunCancellation: (currentRunId) => this.getRunCancellation(currentRunId),
-            finalizeCancelledRun: (currentThreadId, currentRunId, previousRunState, reason) => this.finalizeCancelledRun(currentThreadId, currentRunId, previousRunState, reason),
-            emit: (currentThreadId, currentRunId, sequence, eventType, payload) => {
-                if (eventType === "run.dequeued") {
-                    return this.emit(currentThreadId, currentRunId, sequence, eventType, {
+            getRequestCancellation: (currentRequestId) => this.getRequestCancellation(currentRequestId),
+            finalizeCancelledRequest: (currentSessionId, currentRequestId, previousRequestState, reason) => this.finalizeCancelledRequest(currentSessionId, currentRequestId, previousRequestState, reason),
+            emit: (currentSessionId, currentRequestId, sequence, eventType, payload) => {
+                if (eventType === "request.dequeued") {
+                    return this.emit(currentSessionId, currentRequestId, sequence, eventType, {
                         ...payload,
-                        activeRunCount: this.activeRunSlots,
+                        activeRequestCount: this.activeRequestSlots,
                         maxConcurrentRuns: this.concurrencyConfig.maxConcurrentRuns,
                     });
                 }
-                return this.emit(currentThreadId, currentRunId, sequence, eventType, payload);
+                return this.emit(currentSessionId, currentRequestId, sequence, eventType, payload);
             },
-            setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, stateOptions) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, stateOptions),
-            invokeWithHistory: (activeBinding, activeInput, currentThreadId, currentRunId, resumePayload, priorHistory, invokeOptions) => this.invokeWithHistory(activeBinding, activeInput, currentThreadId, currentRunId, resumePayload, priorHistory, invokeOptions),
-            finalizeContinuedRun: (activeBinding, currentThreadId, currentRunId, currentInput, actual, finalizeOptions) => this.finalizeContinuedRun(activeBinding, currentThreadId, currentRunId, currentInput, actual, finalizeOptions),
-            emitSyntheticFallback: (currentThreadId, currentRunId, currentAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(currentThreadId, currentRunId, currentAgentId, error, 103),
+            setRequestStateAndEmit: (currentSessionId, currentRequestId, sequence, state, stateOptions) => this.setRequestStateAndEmit(currentSessionId, currentRequestId, sequence, state, stateOptions),
+            invokeWithHistory: (activeBinding, activeInput, currentSessionId, currentRequestId, resumePayload, priorHistory, invokeOptions) => this.invokeWithHistory(activeBinding, activeInput, currentSessionId, currentRequestId, resumePayload, priorHistory, invokeOptions),
+            finalizeContinuedRequest: (activeBinding, currentSessionId, currentRequestId, currentInput, actual, finalizeOptions) => this.finalizeContinuedRequest(activeBinding, currentSessionId, currentRequestId, currentInput, actual, finalizeOptions),
+            emitSyntheticFallback: (currentSessionId, currentRequestId, currentAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(currentSessionId, currentRequestId, currentAgentId, error, 103),
             renderRuntimeFailure,
         }, {
             binding,
             message: input,
-            threadId,
-            runId,
+            sessionId,
+            requestId,
             agentId,
             options,
         });
     }
-    async finalizeContinuedRun(binding, threadId, runId, input, actual, options) {
-        return finalizeLifecycleContinuedRun({
+    async finalizeContinuedRequest(binding, sessionId, requestId, input, actual, options) {
+        return finalizeLifecycleContinuedRequest({
             persistence: this.persistence,
-            emit: (currentThreadId, currentRunId, sequence, eventType, payload, source) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload, source),
-            setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, lifecycleOptions) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, lifecycleOptions),
-            requestApprovalAndEmit: (currentThreadId, currentRunId, lifecycleInput, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(currentThreadId, currentRunId, lifecycleInput, interruptContent, checkpointRef, sequence),
-        }, binding, threadId, runId, input, actual, options);
+            emit: (currentSessionId, currentRequestId, sequence, eventType, payload, source) => this.emit(currentSessionId, currentRequestId, sequence, eventType, payload, source),
+            setRequestStateAndEmit: (currentSessionId, currentRequestId, sequence, state, lifecycleOptions) => this.setRequestStateAndEmit(currentSessionId, currentRequestId, sequence, state, lifecycleOptions),
+            requestApprovalAndEmit: (currentSessionId, currentRequestId, lifecycleInput, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(currentSessionId, currentRequestId, lifecycleInput, interruptContent, checkpointRef, sequence),
+        }, binding, sessionId, requestId, input, actual, options);
     }
-    async setRunStateAndEmit(threadId, runId, sequence, state, options) {
-        return this.runtimeEventOperations.setRunStateAndEmit(threadId, runId, sequence, state, options);
+    async setRequestStateAndEmit(sessionId, requestId, sequence, state, options) {
+        return this.runtimeEventOperations.setRequestStateAndEmit(sessionId, requestId, sequence, state, options);
     }
-    async requestApprovalAndEmit(threadId, runId, input, interruptContent, checkpointRef, sequence) {
-        return this.runtimeEventOperations.requestApprovalAndEmit(threadId, runId, input, interruptContent, checkpointRef, sequence);
+    async requestApprovalAndEmit(sessionId, requestId, input, interruptContent, checkpointRef, sequence) {
+        return this.runtimeEventOperations.requestApprovalAndEmit(sessionId, requestId, input, interruptContent, checkpointRef, sequence);
     }
     isDecisionRun(options) {
         return "decision" in options;
@@ -1062,28 +1038,34 @@ export class AgentHarnessRuntime {
         }
         await listener(value);
     }
-    async acquireRunSlot(threadId, runId, activeState = "running", priority = 0) {
+    async acquireRequestSlot(sessionId, requestId, activeState = "running", priority = 0) {
         return acquireHarnessRunSlot({
-            persistence: this.persistence,
+            persistence: {
+                claimQueuedRequest: ({ sessionId, requestId, workerId, claimedAt, leaseExpiresAt }) => this.persistence.claimQueuedRequest({ sessionId, requestId, workerId, claimedAt, leaseExpiresAt }),
+                renewRequestLease: ({ requestId, workerId, heartbeatAt, leaseExpiresAt }) => this.persistence.renewRequestLease({ requestId, workerId, heartbeatAt, leaseExpiresAt }),
+                releaseRequestClaim: (requestId) => this.persistence.releaseRequestClaim(requestId),
+                enqueueRequest: ({ sessionId, requestId, priority }) => this.persistence.enqueueRequest({ sessionId, requestId, priority }),
+                getRequest: (requestId) => this.persistence.getRequest(requestId),
+            },
             workerId: this.workerId,
             concurrencyConfig: this.concurrencyConfig,
-            pendingRunSlots: this.pendingRunSlots,
-            getActiveRunSlots: () => this.activeRunSlots,
-            setActiveRunSlots: (count) => {
-                this.activeRunSlots = count;
+            pendingRequestSlots: this.pendingRequestSlots,
+            getActiveRequestSlots: () => this.activeRequestSlots,
+            setActiveRequestSlots: (count) => {
+                this.activeRequestSlots = count;
             },
-            enqueuePendingRunSlot: (entry) => this.enqueuePendingRunSlot(entry),
-            emit: (currentThreadId, currentRunId, sequence, eventType, payload) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload),
-            setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, stateOptions) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, stateOptions),
+            enqueuePendingRequestSlot: (entry) => this.enqueuePendingRequestSlot(entry),
+            emit: (currentSessionId, currentRequestId, sequence, eventType, payload) => this.emit(currentSessionId, currentRequestId, sequence, eventType, payload),
+            setRequestStateAndEmit: (currentSessionId, currentRequestId, sequence, state, stateOptions) => this.setRequestStateAndEmit(currentSessionId, currentRequestId, sequence, state, stateOptions),
         }, {
-            threadId,
-            runId,
+            sessionId,
+            requestId,
             activeState,
             priority,
         });
     }
-    dropPendingRunSlot(runId) {
-        return dropPendingRunSlot(this.pendingRunSlots, runId);
+    dropPendingRequestSlot(requestId) {
+        return dropPendingRequestSlot(this.pendingRequestSlots, requestId);
     }
     async run(options) {
         if (this.isDecisionRun(options)) {
@@ -1096,52 +1078,52 @@ export class AgentHarnessRuntime {
             };
             return this.resume(resumeOptions);
         }
-        const resolvedListeners = resolveRunListeners(options);
+        const resolvedListeners = resolveRequestListeners(options);
         if (resolvedListeners) {
             const result = await createListenerDispatchRuntime({
                 notifyListener: (listener, value) => this.notifyListener(listener, value),
-                getThread: async (threadId) => {
-                    const thread = await this.getThread(threadId);
-                    return thread
+                getSession: async (sessionId) => {
+                    const session = await this.getSessionRecord(sessionId);
+                    return session
                         ? {
-                            currentState: thread.currentState,
-                            latestRequestId: thread.latestRequestId,
-                            entryAgentId: thread.entryAgentId,
-                            currentAgentId: thread.currentAgentId,
-                            requests: thread.requests.map((run) => ({ agentId: run.agentId })),
-                            pendingDecision: thread.pendingDecision,
+                            currentState: session.currentState,
+                            latestRequestId: session.latestRequestId,
+                            entryAgentId: session.entryAgentId,
+                            currentAgentId: session.currentAgentId,
+                            requests: session.requests.map((request) => ({ agentId: request.agentId })),
+                            pendingDecision: session.pendingDecision,
                         }
                         : null;
                 },
-            }).dispatchRunListeners(this.streamEvents(options), resolvedListeners);
-            return toPublicRunResultShape(result);
+            }).dispatchRequestListeners(this.streamEvents(options), resolvedListeners);
+            return toPublicRequestResultShape(result);
         }
         const invocation = normalizeInvocationEnvelope(options);
-        const { binding, selectedAgentId, threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart(this.createPrepareRunStartRuntime(), {
+        const { binding, selectedAgentId, sessionId, requestId, isNewSession, requestCreatedEventPromise, releaseRequestSlotPromise, } = await prepareRunStart(this.createPrepareRunStartRuntime(), {
             options,
             invocation,
-            runCreatedPayload: (activeBinding, activeSelectedAgentId) => ({
+            requestCreatedPayload: (activeBinding, activeSelectedAgentId) => ({
                 agentId: activeBinding.agent.id,
                 requestedAgentId: defaultRequestedAgentId(options.agentId),
                 selectedAgentId: activeSelectedAgentId,
                 executionMode: getBindingRuntimeExecutionMode(activeBinding),
             }),
         });
-        await runCreatedEventPromise;
-        const releaseRunSlot = await releaseRunSlotPromise;
+        await requestCreatedEventPromise;
+        const releaseRequestSlot = await releaseRequestSlotPromise;
         try {
-            return toPublicRunResultShape(await this.executeQueuedRun(binding, options.input, threadId, runId, selectedAgentId, {
+            return toPublicRequestResultShape(await this.executeQueuedRequest(binding, options.input, sessionId, requestId, selectedAgentId, {
                 context: invocation.context,
                 state: invocation.state,
                 files: invocation.files,
                 previousState: "running",
                 stateSequence: 6,
                 approvalSequence: 7,
-                priorHistory: isNewThread ? [] : undefined,
+                priorHistory: isNewSession ? [] : undefined,
             }));
         }
         finally {
-            await releaseRunSlot();
+            await releaseRequestSlot();
         }
     }
     async *streamEvents(options) {
@@ -1156,10 +1138,10 @@ export class AgentHarnessRuntime {
             };
             return;
         }
-        const { threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart(this.createPrepareRunStartRuntime(), {
+        const { sessionId, requestId, isNewSession, requestCreatedEventPromise, releaseRequestSlotPromise, } = await prepareRunStart(this.createPrepareRunStartRuntime(), {
             options,
             invocation,
-            runCreatedPayload: (_binding, activeSelectedAgentId) => ({
+            requestCreatedPayload: (_binding, activeSelectedAgentId) => ({
                 agentId: activeSelectedAgentId,
                 requestedAgentId: defaultRequestedAgentId(options.agentId),
                 selectedAgentId: activeSelectedAgentId,
@@ -1172,53 +1154,53 @@ export class AgentHarnessRuntime {
             input: options.input,
             invocation: {
                 ...invocation,
-                memoryContext: await this.buildRuntimeMemoryContext(binding, threadId, options.input),
+                memoryContext: await this.buildRuntimeMemoryContext(binding, sessionId, options.input),
             },
-            threadId,
-            runId,
+            sessionId,
+            requestId,
             selectedAgentId,
-            isNewThread,
-            runCreatedEventPromise,
-            releaseRunSlotPromise,
+            isNewSession: isNewSession,
+            requestCreatedEventPromise,
+            releaseRequestSlotPromise,
             getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
-            loadPriorHistory: (threadId, runId) => this.loadPriorHistory(threadId, runId),
-            stream: (binding, message, threadId, priorHistory, streamOptions) => this.runtimeAdapter.stream(binding, message, threadId, priorHistory, streamOptions),
-            invokeWithHistory: (binding, input, threadId, runId) => this.invokeWithHistory(binding, input, threadId, runId),
-            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
-            setRunStateAndEmit: (threadId, runId, sequence, state, stateOptions) => this.setRunStateAndEmit(threadId, runId, sequence, state, stateOptions),
-            requestApprovalAndEmit: (threadId, runId, input, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(threadId, runId, input, interruptContent, checkpointRef, sequence),
-            appendAssistantMessage: (threadId, runId, content) => appendLifecycleAssistantMessage(this.persistence, threadId, runId, content),
-            clearRunRequest: (threadId, runId) => this.persistence.clearRunRequest(threadId, runId),
-            updateRunInspection: (threadId, runId, patch) => this.persistence.updateRunInspection(threadId, runId, patch),
-            appendRunTraceItem: (threadId, runId, item) => this.persistence.appendRunTraceItem(threadId, runId, item),
-            emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
+            loadPriorHistory: (sessionId, requestId) => this.loadPriorHistory(sessionId, requestId),
+            stream: (binding, message, sessionId, priorHistory, streamOptions) => this.runtimeAdapter.stream(binding, message, sessionId, priorHistory, streamOptions),
+            invokeWithHistory: (binding, input, sessionId, requestId) => this.invokeWithHistory(binding, input, sessionId, requestId),
+            emit: (sessionId, requestId, sequence, eventType, payload) => this.emit(sessionId, requestId, sequence, eventType, payload),
+            setRequestStateAndEmit: (sessionId, requestId, sequence, state, stateOptions) => this.setRequestStateAndEmit(sessionId, requestId, sequence, state, stateOptions),
+            requestApprovalAndEmit: (sessionId, requestId, input, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(sessionId, requestId, input, interruptContent, checkpointRef, sequence),
+            appendAssistantMessage: (sessionId, requestId, content) => appendLifecycleAssistantMessage(this.persistence, sessionId, requestId, content),
+            clearRequestInput: (sessionId, requestId) => this.persistence.clearRequestInput(sessionId, requestId),
+            updateRequestInspection: (sessionId, requestId, patch) => this.persistence.updateRequestInspection(sessionId, requestId, patch),
+            appendRequestTraceItem: (sessionId, requestId, item) => this.persistence.appendRequestTraceItem(sessionId, requestId, item),
+            emitSyntheticFallback: (sessionId, requestId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(sessionId, requestId, selectedAgentId, error),
         });
         for await (const item of stream) {
             yield toPublicHarnessStreamItem(item);
         }
     }
     async resume(options) {
-        return toPublicRunResultShape(await resumeRun({
+        return toPublicRequestResultShape(await resumeRequest({
             getApprovalById: (approvalId) => this.persistence.getApproval(approvalId),
-            getSession: (threadId) => this.getSession(threadId),
-            resolveApprovalRecord: (resumeOptions, thread) => resolveHarnessApprovalRecord(this.persistence, resumeOptions, thread),
+            getSession: (sessionId) => this.getSession(sessionId),
+            resolveApprovalRecord: (resumeOptions, session) => resolveHarnessApprovalRecord(this.persistence, resumeOptions, session),
             getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
             buildResumePayload: (binding, approval, resumeOptions) => buildHarnessResumePayload(binding, approval, resumeOptions),
-            getRunCancellation: (runId) => this.getRunCancellation(runId),
-            finalizeCancelledRun: (threadId, runId, previousState, reason) => this.finalizeCancelledRun(threadId, runId, previousState, reason),
-            setRunState: (threadId, runId, state, checkpointRef) => this.persistence.setRunState(threadId, runId, state, checkpointRef),
-            acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
-            resolvePersistedRunPriority: (threadId, runId) => this.resolvePersistedRunPriority(threadId, runId),
-            saveRecoveryIntent: (threadId, runId, payload) => this.persistence.saveRecoveryIntent(threadId, runId, payload),
-            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
-            resolveApproval: (threadId, runId, approvalId, resolution) => this.persistence.resolveApproval(threadId, runId, approvalId, resolution),
-            listThreadMessages: (threadId) => this.persistence.listThreadMessages(threadId),
-            loadRunInput: (threadId, runId) => this.loadRunInput(threadId, runId),
-            invoke: (binding, input, threadId, runId, resumePayload, priorHistory) => this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, priorHistory),
+            getRequestCancellation: (requestId) => this.getRequestCancellation(requestId),
+            finalizeCancelledRequest: (sessionId, requestId, previousState, reason) => this.finalizeCancelledRequest(sessionId, requestId, previousState, reason),
+            setRequestState: (sessionId, requestId, state, checkpointRef) => this.persistence.setRequestState(sessionId, requestId, state, checkpointRef),
+            acquireRequestSlot: (sessionId, requestId, activeState, priority) => this.acquireRequestSlot(sessionId, requestId, activeState, priority),
+            resolvePersistedRequestPriority: (sessionId, requestId) => this.resolvePersistedRequestPriority(sessionId, requestId),
+            saveRequestRecoveryIntent: (sessionId, requestId, payload) => this.persistence.saveRequestRecoveryIntent(sessionId, requestId, payload),
+            emit: (sessionId, requestId, sequence, eventType, payload) => this.emit(sessionId, requestId, sequence, eventType, payload),
+            resolveApproval: (sessionId, requestId, approvalId, resolution) => this.persistence.resolveApproval(sessionId, requestId, approvalId, resolution),
+            listSessionMessages: (sessionId) => this.persistence.listSessionMessages(sessionId),
+            loadRequestInput: (sessionId, requestId) => this.loadRequestInput(sessionId, requestId),
+            invoke: (binding, input, sessionId, requestId, resumePayload, priorHistory) => this.runtimeAdapter.invoke(binding, input, sessionId, requestId, resumePayload, priorHistory),
             recordLlmSuccess: (startedAt) => this.recordLlmSuccess(startedAt),
             recordLlmFailure: (startedAt) => this.recordLlmFailure(startedAt),
-            clearRecoveryIntent: (threadId, runId) => this.persistence.clearRecoveryIntent(threadId, runId),
-            finalizeContinuedRun: (binding, threadId, runId, input, actual, operationOptions) => this.finalizeContinuedRun(binding, threadId, runId, input, actual, operationOptions),
+            clearRequestRecoveryIntent: (sessionId, requestId) => this.persistence.clearRequestRecoveryIntent(sessionId, requestId),
+            finalizeContinuedRequest: (binding, sessionId, requestId, input, actual, operationOptions) => this.finalizeContinuedRequest(binding, sessionId, requestId, input, actual, operationOptions),
         }, {
             ...options,
         }));
@@ -1229,11 +1211,11 @@ export class AgentHarnessRuntime {
             throw new Error(`Unknown session ${options.sessionId}`);
         }
         const sourceRequestId = session.latestRequestId;
-        const targetSessionId = options.mode === "restart-new-thread" ? createPersistentId() : options.sessionId;
+        const targetSessionId = options.mode === "restart-new-session" ? createPersistentId() : options.sessionId;
         const result = await this.run({
-            agentId: session.agentId,
+            agentId: session.currentAgentId ?? session.entryAgentId,
             input: options.input,
-            sessionId: options.mode === "restart-new-thread" ? undefined : targetSessionId,
+            sessionId: options.mode === "restart-new-session" ? undefined : targetSessionId,
         });
         return {
             ...result,
@@ -1254,12 +1236,12 @@ export class AgentHarnessRuntime {
         }
         this.closed = true;
         await this.healthMonitor?.stop();
-        this.unregisterThreadMemorySync();
+        this.unregisterSessionMemorySync();
         this.unregisterRuntimeMemorySync();
         this.unregisterMem0IngestionSync();
         this.unregisterRuntimeMemoryFormationSync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
-        await this.threadMemorySync?.close();
+        await this.sessionMemorySync?.close();
         await this.runtimeMemorySync?.close();
         await this.mem0IngestionSync?.close();
         await this.runtimeMemoryFormationSync?.close();
@@ -1269,17 +1251,17 @@ export class AgentHarnessRuntime {
     async stop() {
         await this.close();
     }
-    async cancelRun(options) {
-        return toPublicRunResultShape(await cancelRunOperation({
-            getRun: (runId) => this.persistence.getRun(runId),
-            requestRunCancel: (runId, reason) => this.persistence.requestRunCancel(runId, reason),
-            dropPendingRunSlot: (runId) => this.dropPendingRunSlot(runId),
-            finalizeCancelledRun: (threadId, runId, previousState, reason) => this.finalizeCancelledRun(threadId, runId, previousState, reason),
-            setRunStateAndEmit: (threadId, runId, sequence, state, stateOptions) => this.setRunStateAndEmit(threadId, runId, sequence, state, stateOptions),
+    async cancelRequest(options) {
+        return toPublicRequestResultShape(await cancelRequestOperation({
+            getRequest: (requestId) => this.persistence.getRequest(requestId),
+            requestRequestCancel: (requestId, reason) => this.persistence.requestRequestCancel(requestId, reason),
+            dropPendingRequestSlot: (requestId) => this.dropPendingRequestSlot(requestId),
+            finalizeCancelledRequest: (sessionId, requestId, previousState, reason) => this.finalizeCancelledRequest(sessionId, requestId, previousState, reason),
+            setRequestStateAndEmit: (sessionId, requestId, sequence, state, stateOptions) => this.setRequestStateAndEmit(sessionId, requestId, sequence, state, stateOptions),
         }, options));
     }
-    async recoverStartupRuns() {
-        await recoverHarnessStartupRuns({
+    async recoverStartupRequests() {
+        await recoverHarnessStartupRequests({
             recoveryConfig: this.recoveryConfig,
             persistence: this.persistence,
             createStartupRecoveryContext: () => ({
@@ -1289,34 +1271,34 @@ export class AgentHarnessRuntime {
                 recoveryConfig: this.recoveryConfig,
                 concurrencyConfig: this.concurrencyConfig,
                 getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
-                acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
-                executeQueuedRun: (binding, input, threadId, runId, agentId, options) => this.executeQueuedRun(binding, input, threadId, runId, agentId, options),
-                setRunStateAndEmit: (threadId, runId, sequence, state, options) => this.setRunStateAndEmit(threadId, runId, sequence, state, options),
-                emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
-                loadRunInput: (threadId, runId) => this.loadRunInput(threadId, runId),
-                finalizeContinuedRun: (binding, threadId, runId, input, actual, options) => this.finalizeContinuedRun(binding, threadId, runId, input, actual, options),
+                acquireRequestSlot: (sessionId, requestId, activeState, priority) => this.acquireRequestSlot(sessionId, requestId, activeState, priority),
+                executeQueuedRequest: (binding, input, sessionId, requestId, agentId, options) => this.executeQueuedRequest(binding, input, sessionId, requestId, agentId, options),
+                setRequestStateAndEmit: (sessionId, requestId, sequence, state, options) => this.setRequestStateAndEmit(sessionId, requestId, sequence, state, options),
+                emit: (sessionId, requestId, sequence, eventType, payload) => this.emit(sessionId, requestId, sequence, eventType, payload),
+                loadRequestInput: (sessionId, requestId) => this.loadRequestInput(sessionId, requestId),
+                finalizeContinuedRequest: (binding, sessionId, requestId, input, actual, options) => this.finalizeContinuedRequest(binding, sessionId, requestId, input, actual, options),
                 supportsRunningReplay: (binding) => bindingSupportsRunningReplay(binding),
-                isStaleRunningRun: (thread, nowMs) => this.isStaleRunningRun(thread, nowMs),
+                isStaleRunningRequest: (session, nowMs) => this.isStaleRunningRequest(session, nowMs),
                 recordLlmSuccess: (startedAt) => this.recordLlmSuccess(startedAt),
                 recordLlmFailure: (startedAt) => this.recordLlmFailure(startedAt),
             }),
-            reclaimExpiredClaimedRuns: (nowIso) => this.reclaimExpiredClaimedRuns(nowIso),
+            reclaimExpiredClaimedRequests: (nowIso) => this.reclaimExpiredClaimedRequests(nowIso),
         });
     }
-    async reclaimExpiredClaimedRuns(nowIso = new Date().toISOString()) {
-        await reclaimHarnessExpiredClaimedRuns({
+    async reclaimExpiredClaimedRequests(nowIso = new Date().toISOString()) {
+        await reclaimHarnessExpiredClaimedRequests({
             persistence: this.persistence,
-            setRunStateAndEmit: (threadId, runId, sequence, state, options) => this.setRunStateAndEmit(threadId, runId, sequence, state, options),
-            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
+            setRequestStateAndEmit: (sessionId, requestId, sequence, state, options) => this.setRequestStateAndEmit(sessionId, requestId, sequence, state, options),
+            emit: (sessionId, requestId, sequence, eventType, payload) => this.emit(sessionId, requestId, sequence, eventType, payload),
             concurrencyConfig: this.concurrencyConfig,
-            getActiveRunSlots: () => this.activeRunSlots,
+            getActiveRequestSlots: () => this.activeRequestSlots,
         }, nowIso);
     }
-    async isStaleRunningRun(thread, nowMs = Date.now()) {
-        return isHarnessStaleRunningRun({
+    async isStaleRunningRequest(session, nowMs = Date.now()) {
+        return isHarnessStaleRunningRequest({
             persistence: this.persistence,
             concurrencyConfig: this.concurrencyConfig,
-        }, thread, nowMs);
+        }, session, nowMs);
     }
 }
 function toRequestSummary(summary) {
@@ -1324,7 +1306,7 @@ function toRequestSummary(summary) {
         requestId: summary.requestId,
         sessionId: summary.sessionId,
         agentId: summary.agentId,
-        parentRunId: summary.parentRunId,
+        parentRequestId: summary.parentRequestId,
         executionMode: summary.executionMode,
         adapterKind: summary.adapterKind,
         createdAt: summary.createdAt,
@@ -1361,7 +1343,7 @@ function toRequestRecord(record) {
         runtimeTimeline: record.runtimeTimeline,
     };
 }
-function deriveRunRequestFromTranscript(transcript, requestId) {
+function deriveRequestInputFromTranscript(transcript, requestId) {
     const candidate = [...transcript]
         .reverse()
         .find((message) => message.role === "user" && (!requestId || message.requestId === requestId));