@botbotgo/agent-harness 0.0.290 → 0.0.291

package/dist/persistence/file-store.js

@@ -6,30 +6,30 @@ function nowIso() {
     return new Date(Date.now()).toISOString();
 }
 export class FilePersistence {
-    runRoot;
-    constructor(runRoot) {
-        this.runRoot = runRoot;
+    runtimeRoot;
+    constructor(runtimeRoot) {
+        this.runtimeRoot = runtimeRoot;
     }
     artifactsRoot() {
-        return resolveRuntimeArtifactsRoot(this.runRoot);
+        return resolveRuntimeArtifactsRoot(this.runtimeRoot);
     }
-    threadIndexPath(threadId) {
-        return path.join(this.artifactsRoot(), "indexes", "sessions", `${threadId}.json`);
+    sessionIndexPath(sessionId) {
+        return path.join(this.artifactsRoot(), "indexes", "sessions", `${sessionId}.json`);
     }
-    runIndexPath(runId) {
-        return path.join(this.artifactsRoot(), "indexes", "requests", `${runId}.json`);
+    requestIndexPath(requestId) {
+        return path.join(this.artifactsRoot(), "indexes", "requests", `${requestId}.json`);
     }
     approvalIndexPath(approvalId) {
         return path.join(this.artifactsRoot(), "indexes", "approvals", `${approvalId}.json`);
     }
-    runQueuePath(runId) {
-        return path.join(this.artifactsRoot(), "indexes", "requests-queue", `${runId}.json`);
+    requestQueuePath(requestId) {
+        return path.join(this.artifactsRoot(), "indexes", "requests-queue", `${requestId}.json`);
     }
-    runControlPath(runId) {
-        return path.join(this.artifactsRoot(), "indexes", "requests-control", `${runId}.json`);
+    requestControlPath(requestId) {
+        return path.join(this.artifactsRoot(), "indexes", "requests-control", `${requestId}.json`);
     }
-    traceItemsPath(threadId, runId) {
-        return path.join(this.runDir(threadId, runId), "trace-items.ndjson");
+    traceItemsPath(sessionId, requestId) {
+        return path.join(this.requestDir(sessionId, requestId), "trace-items.ndjson");
     }
     async initialize() {
         await Promise.all([
@@ -41,44 +41,44 @@ export class FilePersistence {
             "sessions",
         ].map((segment) => ensureDir(path.join(this.artifactsRoot(), segment))));
     }
-    threadDir(threadId) {
-        return path.join(this.artifactsRoot(), "sessions", threadId);
+    sessionDir(sessionId) {
+        return path.join(this.artifactsRoot(), "sessions", sessionId);
     }
-    runDir(threadId, runId) {
-        return path.join(this.threadDir(threadId), "requests", runId);
+    requestDir(sessionId, requestId) {
+        return path.join(this.sessionDir(sessionId), "requests", requestId);
     }
-    async createThread(input) {
+    async createSession(input) {
         const meta = {
-            threadId: input.threadId,
+            sessionId: input.sessionId,
             workspaceId: "default",
             entryAgentId: input.agentId,
             createdAt: input.createdAt,
             updatedAt: input.createdAt,
             status: input.status,
-            latestRunId: input.runId,
+            latestRequestId: input.requestId,
         };
-        await writeJson(path.join(this.threadDir(input.threadId), "meta.json"), meta);
-        await writeJson(path.join(this.threadDir(input.threadId), "messages.json"), {
-            threadId: input.threadId,
+        await writeJson(path.join(this.sessionDir(input.sessionId), "meta.json"), meta);
+        await writeJson(path.join(this.sessionDir(input.sessionId), "messages.json"), {
+            sessionId: input.sessionId,
             items: [],
         });
-        await writeJson(this.threadIndexPath(input.threadId), {
-            threadId: input.threadId,
+        await writeJson(this.sessionIndexPath(input.sessionId), {
+            sessionId: input.sessionId,
             status: input.status,
-            latestRunId: input.runId,
+            latestRequestId: input.requestId,
             updatedAt: input.createdAt,
         });
     }
-    async createRun(input) {
-        const runDir = this.runDir(input.threadId, input.runId);
-        await ensureDir(path.join(runDir, "events"));
-        await ensureDir(path.join(runDir, "approvals"));
-        const threadMeta = await this.getThreadMeta(input.threadId);
+    async createRequest(input) {
+        const requestDir = this.requestDir(input.sessionId, input.requestId);
+        await ensureDir(path.join(requestDir, "events"));
+        await ensureDir(path.join(requestDir, "approvals"));
+        const sessionMeta = await this.getSessionMeta(input.sessionId);
         const meta = {
-            runId: input.runId,
-            threadId: input.threadId,
+            requestId: input.requestId,
+            sessionId: input.sessionId,
             agentId: input.agentId,
-            parentRunId: threadMeta?.latestRunId ?? null,
+            parentRequestId: sessionMeta?.latestRequestId ?? null,
             executionMode: input.executionMode,
             adapterKind: input.adapterKind ?? input.executionMode,
             createdAt: input.createdAt,
@@ -102,35 +102,35 @@ export class FilePersistence {
             traceItems: [],
         };
         await Promise.all([
-            writeJson(path.join(runDir, "meta.json"), meta),
-            writeJson(path.join(runDir, "lifecycle.json"), lifecycle),
-            writeJson(path.join(runDir, "inspection.json"), inspection),
-            writeFile(this.traceItemsPath(input.threadId, input.runId), "", "utf8"),
-            writeJson(path.join(runDir, "checkpoint-ref.json"), {
-                threadId: input.threadId,
-                runId: input.runId,
+            writeJson(path.join(requestDir, "meta.json"), meta),
+            writeJson(path.join(requestDir, "lifecycle.json"), lifecycle),
+            writeJson(path.join(requestDir, "inspection.json"), inspection),
+            writeFile(this.traceItemsPath(input.sessionId, input.requestId), "", "utf8"),
+            writeJson(path.join(requestDir, "checkpoint-ref.json"), {
+                sessionId: input.sessionId,
+                requestId: input.requestId,
                 checkpointRef: null,
                 savedAt: input.createdAt,
                 kind: "langgraph-checkpoint",
             }),
-            writeJson(path.join(runDir, "artifacts.json"), {
-                threadId: input.threadId,
-                runId: input.runId,
+            writeJson(path.join(requestDir, "artifacts.json"), {
+                sessionId: input.sessionId,
+                requestId: input.requestId,
                 items: [],
             }),
-            writeJson(path.join(runDir, "error.json"), {
+            writeJson(path.join(requestDir, "error.json"), {
                 hasError: false,
                 lastError: null,
             }),
-            writeJson(this.runIndexPath(input.runId), {
-                runId: input.runId,
-                threadId: input.threadId,
+            writeJson(this.requestIndexPath(input.requestId), {
+                requestId: input.requestId,
+                sessionId: input.sessionId,
                 state: "running",
                 resumable: false,
                 updatedAt: input.createdAt,
             }),
-            writeJson(this.runControlPath(input.runId), {
-                runId: input.runId,
+            writeJson(this.requestControlPath(input.requestId), {
+                requestId: input.requestId,
                 cancelRequested: false,
                 cancelReason: null,
                 cancelRequestedAt: null,
@@ -140,13 +140,13 @@ export class FilePersistence {
             }),
         ]);
     }
-    async setRunState(threadId, runId, state, checkpointRef) {
-        const lifecyclePath = path.join(this.runDir(threadId, runId), "lifecycle.json");
-        const runMetaPath = path.join(this.runDir(threadId, runId), "meta.json");
-        const inspectionPath = path.join(this.runDir(threadId, runId), "inspection.json");
-        const [lifecycle, runMeta, inspection] = await Promise.all([
+    async setRequestState(sessionId, requestId, state, checkpointRef) {
+        const lifecyclePath = path.join(this.requestDir(sessionId, requestId), "lifecycle.json");
+        const requestMetaPath = path.join(this.requestDir(sessionId, requestId), "meta.json");
+        const inspectionPath = path.join(this.requestDir(sessionId, requestId), "inspection.json");
+        const [lifecycle, requestMeta, inspection] = await Promise.all([
             readJson(lifecyclePath),
-            readJson(runMetaPath),
+            readJson(requestMetaPath),
             readJson(inspectionPath),
         ]);
         const now = nowIso();
@@ -160,8 +160,8 @@ export class FilePersistence {
         };
         await Promise.all([
             writeJson(lifecyclePath, next),
-            writeJson(runMetaPath, {
-                ...runMeta,
+            writeJson(requestMetaPath, {
+                ...requestMeta,
                 updatedAt: now,
             }),
             writeJson(inspectionPath, {
@@ -171,40 +171,40 @@ export class FilePersistence {
             }),
         ]);
         if (checkpointRef !== undefined) {
-            await writeJson(path.join(this.runDir(threadId, runId), "checkpoint-ref.json"), {
-                threadId,
-                runId,
+            await writeJson(path.join(this.requestDir(sessionId, requestId), "checkpoint-ref.json"), {
+                sessionId,
+                requestId,
                 checkpointRef,
                 savedAt: now,
                 kind: "langgraph-checkpoint",
             });
         }
-        await writeJson(this.runIndexPath(runId), {
-            runId,
-            threadId,
+        await writeJson(this.requestIndexPath(requestId), {
+            requestId,
+            sessionId,
             state,
             resumable: next.resumable,
             updatedAt: now,
         });
-        const threadMetaPath = path.join(this.threadDir(threadId), "meta.json");
-        const threadMeta = await readJson(threadMetaPath);
-        threadMeta.status = state;
-        threadMeta.updatedAt = now;
-        threadMeta.latestRunId = runId;
-        await writeJson(threadMetaPath, threadMeta);
-        await writeJson(this.threadIndexPath(threadId), {
-            threadId,
+        const sessionMetaPath = path.join(this.sessionDir(sessionId), "meta.json");
+        const sessionMeta = await readJson(sessionMetaPath);
+        sessionMeta.status = state;
+        sessionMeta.updatedAt = now;
+        sessionMeta.latestRequestId = requestId;
+        await writeJson(sessionMetaPath, sessionMeta);
+        await writeJson(this.sessionIndexPath(sessionId), {
+            sessionId,
             status: state,
-            latestRunId: runId,
+            latestRequestId: requestId,
             updatedAt: now,
         });
     }
     async appendEvent(event) {
         const sequenceId = String(event.sequence).padStart(6, "0");
-        const inspectionPath = path.join(this.runDir(event.sessionId, event.requestId), "inspection.json");
+        const inspectionPath = path.join(this.requestDir(event.sessionId, event.requestId), "inspection.json");
         const inspection = await readJson(inspectionPath);
         await Promise.all([
-            writeJson(path.join(this.runDir(event.sessionId, event.requestId), "events", `${sequenceId}.json`), event),
+            writeJson(path.join(this.requestDir(event.sessionId, event.requestId), "events", `${sequenceId}.json`), event),
             writeJson(inspectionPath, {
                 ...inspection,
                 lastActivityAt: event.timestamp,
@@ -212,21 +212,21 @@ export class FilePersistence {
         ]);
     }
     async listSessions(filter = {}) {
-        const threadIndexDir = path.join(this.artifactsRoot(), "indexes", "sessions");
-        if (!(await fileExists(threadIndexDir))) {
+        const sessionIndexDir = path.join(this.artifactsRoot(), "indexes", "sessions");
+        if (!(await fileExists(sessionIndexDir))) {
             return [];
         }
-        const entries = await readdir(threadIndexDir);
+        const entries = await readdir(sessionIndexDir);
         const records = await Promise.all(entries.map(async (entry) => {
-            const index = await readJson(path.join(threadIndexDir, entry));
+            const index = await readJson(path.join(sessionIndexDir, entry));
             const [meta, runInspection] = await Promise.all([
-                readJson(path.join(this.threadDir(index.threadId), "meta.json")),
-                readJson(path.join(this.runDir(index.threadId, index.latestRunId), "inspection.json")).catch(() => null),
+                readJson(path.join(this.sessionDir(index.sessionId), "meta.json")),
+                readJson(path.join(this.requestDir(index.sessionId, index.latestRequestId), "inspection.json")).catch(() => null),
             ]);
             return {
                 agentId: meta.entryAgentId,
-                sessionId: index.threadId,
-                latestRequestId: index.latestRunId,
+                sessionId: index.sessionId,
+                latestRequestId: index.latestRequestId,
                 createdAt: meta.createdAt,
                 updatedAt: index.updatedAt,
                 status: index.status,
@@ -241,9 +241,9 @@ export class FilePersistence {
         const sessions = await this.listSessions(filter);
         const summaries = await Promise.all(sessions.map(async (session) => {
             const [meta, messageBundle] = await Promise.all([
-                readJson(path.join(this.threadDir(session.sessionId), "meta.json")),
-                readJson(path.join(this.threadDir(session.sessionId), "messages.json"))
-                    .catch(() => ({ threadId: session.sessionId, items: [] })),
+                readJson(path.join(this.sessionDir(session.sessionId), "meta.json")),
+                readJson(path.join(this.sessionDir(session.sessionId), "messages.json"))
+                    .catch(() => ({ sessionId: session.sessionId, items: [] })),
             ]);
             const items = messageBundle.items;
             return {
@@ -256,7 +256,7 @@ export class FilePersistence {
         }));
         return summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
-    async listRunIndexes() {
+    async listRequestIndexes() {
         const runIndexDir = path.join(this.artifactsRoot(), "indexes", "requests");
         if (!(await fileExists(runIndexDir))) {
             return [];
@@ -264,18 +264,18 @@ export class FilePersistence {
         const entries = (await readdir(runIndexDir)).sort();
         return Promise.all(entries.map((entry) => readJson(path.join(runIndexDir, entry))));
     }
-    async readRunSummary(threadId, runId) {
-        const runDir = this.runDir(threadId, runId);
+    async readRequestSummary(sessionId, requestId) {
+        const requestDir = this.requestDir(sessionId, requestId);
         const [meta, lifecycle, inspection] = await Promise.all([
-            readJson(path.join(runDir, "meta.json")),
-            readJson(path.join(runDir, "lifecycle.json")),
-            readJson(path.join(runDir, "inspection.json")),
+            readJson(path.join(requestDir, "meta.json")),
+            readJson(path.join(requestDir, "lifecycle.json")),
+            readJson(path.join(requestDir, "inspection.json")),
         ]);
         return {
-            requestId: meta.runId,
-            sessionId: meta.threadId,
+            requestId: meta.requestId,
+            sessionId: meta.sessionId,
             agentId: meta.agentId,
-            ...(meta.parentRunId ? { parentRunId: meta.parentRunId } : {}),
+            ...(meta.parentRequestId ? { parentRequestId: meta.parentRequestId } : {}),
             executionMode: meta.executionMode,
             adapterKind: meta.adapterKind ?? meta.executionMode,
             createdAt: meta.createdAt,
@@ -291,70 +291,70 @@ export class FilePersistence {
             ...(inspection.runtimeSnapshot ? { runtimeSnapshot: inspection.runtimeSnapshot } : {}),
         };
     }
-    async listRuns(filter = {}) {
-        const indexes = await this.listRunIndexes();
-        const runs = await Promise.all(indexes.map((record) => this.readRunSummary(record.threadId, record.runId)));
-        return runs
-            .filter((run) => {
-            if (filter.agentId && run.agentId !== filter.agentId) {
+    async listRequests(filter = {}) {
+        const indexes = await this.listRequestIndexes();
+        const requests = await Promise.all(indexes.map((record) => this.readRequestSummary(record.sessionId, record.requestId)));
+        return requests
+            .filter((request) => {
+            if (filter.agentId && request.agentId !== filter.agentId) {
                 return false;
             }
-            if (filter.threadId && run.sessionId !== filter.threadId) {
+            if (filter.sessionId && request.sessionId !== filter.sessionId) {
                 return false;
             }
-            if (filter.state && run.state !== filter.state) {
+            if (filter.state && request.state !== filter.state) {
                 return false;
             }
             return true;
         })
             .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
     }
-    async getRun(runId) {
-        const indexPath = this.runIndexPath(runId);
+    async getRequest(requestId) {
+        const indexPath = this.requestIndexPath(requestId);
         if (!(await fileExists(indexPath))) {
             return null;
         }
         const index = await readJson(indexPath);
-        return this.readRunSummary(index.threadId, index.runId);
+        return this.readRequestSummary(index.sessionId, index.requestId);
     }
-    async getSession(threadId) {
-        const filePath = this.threadIndexPath(threadId);
+    async getSession(sessionId) {
+        const filePath = this.sessionIndexPath(sessionId);
         if (!(await fileExists(filePath))) {
             return null;
         }
         const [index, meta] = await Promise.all([
             readJson(filePath),
-            readJson(path.join(this.threadDir(threadId), "meta.json")),
+            readJson(path.join(this.sessionDir(sessionId), "meta.json")),
         ]);
-        const runInspection = await readJson(path.join(this.runDir(threadId, index.latestRunId), "inspection.json")).catch(() => null);
+        const runInspection = await readJson(path.join(this.requestDir(sessionId, index.latestRequestId), "inspection.json")).catch(() => null);
         return {
             agentId: meta.entryAgentId,
-            sessionId: threadId,
-            latestRequestId: index.latestRunId,
+            sessionId,
+            latestRequestId: index.latestRequestId,
             createdAt: meta.createdAt,
             updatedAt: index.updatedAt,
             status: index.status,
             currentAgentId: runInspection?.currentAgentId ?? undefined,
         };
     }
-    async getThreadMeta(threadId) {
-        const filePath = path.join(this.threadDir(threadId), "meta.json");
+    async getSessionMeta(sessionId) {
+        const filePath = path.join(this.sessionDir(sessionId), "meta.json");
         if (!(await fileExists(filePath))) {
             return null;
         }
         return readJson(filePath);
     }
-    async listThreadRuns(threadId) {
-        const runsDir = path.join(this.threadDir(threadId), "runs");
-        if (!(await fileExists(runsDir))) {
+    async listSessionRequests(sessionId) {
+        const requestsDir = path.join(this.sessionDir(sessionId), "requests");
+        if (!(await fileExists(requestsDir))) {
             return [];
         }
-        const runIds = (await readdir(runsDir)).sort();
-        const runs = await Promise.all(runIds.map(async (runId) => this.readRunSummary(threadId, runId)));
-        return runs.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+        const requestIds = (await readdir(requestsDir)).sort();
+        const requests = await Promise.all(requestIds.map(async (requestId) => this.readRequestSummary(sessionId, requestId)));
+        return requests.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
     }
-    async listRunEvents(threadId, runId) {
-        const eventsDir = path.join(this.runDir(threadId, runId), "events");
+    async listRequestEvents(sessionId, requestId) {
+        const eventsDir = path.join(this.requestDir(sessionId, requestId), "events");
         if (!(await fileExists(eventsDir))) {
             return [];
         }
@@ -374,10 +374,10 @@ export class FilePersistence {
             if (filter.status && approval.status !== filter.status) {
                 return false;
             }
-            if (filter.threadId && approval.sessionId !== filter.threadId) {
+            if (filter.sessionId && approval.sessionId !== filter.sessionId) {
                 return false;
             }
-            if (filter.runId && approval.requestId !== filter.runId) {
+            if (filter.requestId && approval.requestId !== filter.requestId) {
                 return false;
             }
             return true;
@@ -390,25 +390,25 @@ export class FilePersistence {
         }
         return readJson(approvalPath);
     }
-    async getRunApprovals(threadId, runId) {
-        const approvalsDir = path.join(this.runDir(threadId, runId), "approvals");
+    async getRequestApprovals(sessionId, requestId) {
+        const approvalsDir = path.join(this.requestDir(sessionId, requestId), "approvals");
         if (!(await fileExists(approvalsDir))) {
             return [];
         }
         const entries = (await readdir(approvalsDir)).sort();
         return Promise.all(entries.map((entry) => readJson(path.join(approvalsDir, entry))));
     }
-    async getRunMeta(threadId, runId) {
-        return readJson(path.join(this.runDir(threadId, runId), "meta.json"));
+    async getRequestMeta(sessionId, requestId) {
+        return readJson(path.join(this.requestDir(sessionId, requestId), "meta.json"));
     }
-    async getRunLifecycle(threadId, runId) {
-        return readJson(path.join(this.runDir(threadId, runId), "lifecycle.json"));
+    async getRequestLifecycle(sessionId, requestId) {
+        return readJson(path.join(this.requestDir(sessionId, requestId), "lifecycle.json"));
     }
-    async getRunInspection(threadId, runId) {
-        const inspection = await readJson(path.join(this.runDir(threadId, runId), "inspection.json"));
+    async getRequestInspection(sessionId, requestId) {
+        const inspection = await readJson(path.join(this.requestDir(sessionId, requestId), "inspection.json"));
         return {
             ...inspection,
-            traceItems: (await this.listRunTraceItems(threadId, runId))
+            traceItems: (await this.listRequestTraceItems(sessionId, requestId))
                 ?? (Array.isArray(inspection.traceItems)
                     ? inspection.traceItems
                     : Array.isArray(inspection.upstreamEvents)
@@ -416,8 +416,8 @@ export class FilePersistence {
                         : []),
         };
     }
-    async updateRunInspection(threadId, runId, patch) {
-        const inspectionPath = path.join(this.runDir(threadId, runId), "inspection.json");
+    async updateRequestInspection(sessionId, requestId, patch) {
+        const inspectionPath = path.join(this.requestDir(sessionId, requestId), "inspection.json");
         const current = await readJson(inspectionPath);
         await writeJson(inspectionPath, {
             ...current,
@@ -429,11 +429,11 @@ export class FilePersistence {
             traceItems: Array.isArray(current.traceItems) ? current.traceItems : [],
         });
     }
-    async appendRunTraceItem(threadId, runId, item) {
-        await appendFile(this.traceItemsPath(threadId, runId), `${JSON.stringify(item)}\n`, "utf8");
+    async appendRequestTraceItem(sessionId, requestId, item) {
+        await appendFile(this.traceItemsPath(sessionId, requestId), `${JSON.stringify(item)}\n`, "utf8");
     }
-    async listRunTraceItems(threadId, runId) {
-        const traceItemsPath = this.traceItemsPath(threadId, runId);
+    async listRequestTraceItems(sessionId, requestId) {
+        const traceItemsPath = this.traceItemsPath(sessionId, requestId);
         if (await fileExists(traceItemsPath)) {
             const contents = await readFile(traceItemsPath, "utf8");
             return contents
@@ -442,69 +442,69 @@ export class FilePersistence {
                 .filter((line) => line.length > 0)
                 .map((line) => JSON.parse(line));
         }
-        const inspection = await readJson(path.join(this.runDir(threadId, runId), "inspection.json"));
+        const inspection = await readJson(path.join(this.requestDir(sessionId, requestId), "inspection.json"));
         return Array.isArray(inspection.traceItems)
             ? inspection.traceItems
             : Array.isArray(inspection.upstreamEvents)
                 ? inspection.upstreamEvents
                 : [];
     }
-    async deleteThread(threadId) {
-        const threadDir = this.threadDir(threadId);
-        const threadIndexPath = this.threadIndexPath(threadId);
-        if (!(await fileExists(threadDir)) && !(await fileExists(threadIndexPath))) {
+    async deleteSession(sessionId) {
+        const sessionDir = this.sessionDir(sessionId);
+        const sessionIndexPath = this.sessionIndexPath(sessionId);
+        if (!(await fileExists(sessionDir)) && !(await fileExists(sessionIndexPath))) {
             return false;
         }
         const [runIndexes, approvals] = await Promise.all([
-            this.listRunIndexes(),
+            this.listRequestIndexes(),
             this.listApprovals(),
         ]);
         await Promise.all([
             ...runIndexes
-                .filter((record) => record.threadId === threadId)
-                .map((record) => rm(this.runIndexPath(record.runId), { force: true })),
+                .filter((record) => record.sessionId === sessionId)
+                .map((record) => rm(this.requestIndexPath(record.requestId), { force: true })),
             ...approvals
-                .filter((record) => record.sessionId === threadId)
+                .filter((record) => record.sessionId === sessionId)
                 .map((record) => rm(this.approvalIndexPath(record.approvalId), { force: true })),
             ...runIndexes
-                .filter((record) => record.threadId === threadId)
-                .flatMap((record) => [rm(this.runQueuePath(record.runId), { force: true }), rm(this.runControlPath(record.runId), { force: true })]),
-            rm(threadIndexPath, { force: true }),
-            rm(threadDir, { recursive: true, force: true }),
+                .filter((record) => record.sessionId === sessionId)
+                .flatMap((record) => [rm(this.requestQueuePath(record.requestId), { force: true }), rm(this.requestControlPath(record.requestId), { force: true })]),
+            rm(sessionIndexPath, { force: true }),
+            rm(sessionDir, { recursive: true, force: true }),
         ]);
         return true;
     }
-    async saveRunRequest(threadId, runId, request) {
-        await writeJson(path.join(this.runDir(threadId, runId), "request.json"), request);
+    async saveRequestInput(sessionId, requestId, request) {
+        await writeJson(path.join(this.requestDir(sessionId, requestId), "request.json"), request);
     }
-    async getRunRequest(threadId, runId) {
-        const requestPath = path.join(this.runDir(threadId, runId), "request.json");
+    async getRequestInput(sessionId, requestId) {
+        const requestPath = path.join(this.requestDir(sessionId, requestId), "request.json");
         if (!(await fileExists(requestPath))) {
             return null;
         }
         return readJson(requestPath);
     }
-    async clearRunRequest(threadId, runId) {
-        const requestPath = path.join(this.runDir(threadId, runId), "request.json");
+    async clearRequestInput(sessionId, requestId) {
+        const requestPath = path.join(this.requestDir(sessionId, requestId), "request.json");
         if (await fileExists(requestPath)) {
             await rm(requestPath, { force: true });
         }
     }
     async createApproval(record) {
-        const sessionId = record.sessionId ?? record.threadId ?? "";
-        const requestId = record.requestId ?? record.runId ?? "";
+        const sessionId = record.sessionId;
+        const requestId = record.requestId;
         const normalized = {
             ...record,
             sessionId,
             requestId,
         };
         await Promise.all([
-            writeJson(path.join(this.runDir(sessionId, requestId), "approvals", `${record.approvalId}.json`), normalized),
+            writeJson(path.join(this.requestDir(sessionId, requestId), "approvals", `${record.approvalId}.json`), normalized),
             writeJson(this.approvalIndexPath(record.approvalId), normalized),
         ]);
     }
-    async resolveApproval(threadId, runId, approvalId, status) {
-        const approvalPath = path.join(this.runDir(threadId, runId), "approvals", `${approvalId}.json`);
+    async resolveApproval(sessionId, requestId, approvalId, status) {
+        const approvalPath = path.join(this.requestDir(sessionId, requestId), "approvals", `${approvalId}.json`);
         const current = await readJson(approvalPath);
         const updated = {
             ...current,
@@ -517,62 +517,65 @@ export class FilePersistence {
         ]);
         return updated;
     }
-    async createArtifact(threadId, runId, artifact, content) {
-        const runDir = this.runDir(threadId, runId);
-        await writeJson(path.join(runDir, artifact.path), content);
-        const artifactsPath = path.join(runDir, "artifacts.json");
+    async createRequestArtifact(sessionId, requestId, artifact, content) {
+        const requestDir = this.requestDir(sessionId, requestId);
+        await writeJson(path.join(requestDir, artifact.path), content);
+        const artifactsPath = path.join(requestDir, "artifacts.json");
         const current = await readJson(artifactsPath);
         current.items.push(artifact);
         await writeJson(artifactsPath, current);
         return artifact;
     }
-    async listArtifacts(threadId, runId) {
-        return readJson(path.join(this.runDir(threadId, runId), "artifacts.json"));
+    async listRequestArtifacts(sessionId, requestId) {
+        return readJson(path.join(this.requestDir(sessionId, requestId), "artifacts.json"));
     }
-    async readArtifact(threadId, runId, artifactPath) {
-        const filePath = path.join(this.runDir(threadId, runId), artifactPath);
+    async readRequestArtifact(sessionId, requestId, artifactPath) {
+        const filePath = path.join(this.requestDir(sessionId, requestId), artifactPath);
         if (!(await fileExists(filePath))) {
             return null;
         }
         return readJson(filePath);
     }
-    async appendThreadMessage(threadId, message) {
-        const messagesPath = path.join(this.threadDir(threadId), "messages.json");
+    async appendSessionMessage(sessionId, message) {
+        const messagesPath = path.join(this.sessionDir(sessionId), "messages.json");
         const current = (await fileExists(messagesPath))
             ? await readJson(messagesPath)
-            : { threadId, items: [] };
+            : { sessionId, items: [] };
         current.items.push(message);
-        await writeJson(messagesPath, current);
+        await writeJson(messagesPath, {
+            sessionId: current.sessionId ?? sessionId,
+            items: current.items,
+        });
     }
-    async listThreadMessages(threadId, limit = 12) {
-        const messagesPath = path.join(this.threadDir(threadId), "messages.json");
+    async listSessionMessages(sessionId, limit = 12) {
+        const messagesPath = path.join(this.sessionDir(sessionId), "messages.json");
         if (!(await fileExists(messagesPath))) {
             return [];
         }
         const current = await readJson(messagesPath);
         return current.items.slice(-limit);
     }
-    async saveRecoveryIntent(threadId, runId, intent) {
-        await writeJson(path.join(this.runDir(threadId, runId), "recovery-intent.json"), intent);
+    async saveRequestRecoveryIntent(sessionId, requestId, intent) {
+        await writeJson(path.join(this.requestDir(sessionId, requestId), "recovery-intent.json"), intent);
     }
-    async getRecoveryIntent(threadId, runId) {
-        const intentPath = path.join(this.runDir(threadId, runId), "recovery-intent.json");
+    async getRequestRecoveryIntent(sessionId, requestId) {
+        const intentPath = path.join(this.requestDir(sessionId, requestId), "recovery-intent.json");
         if (!(await fileExists(intentPath))) {
             return null;
         }
         return readJson(intentPath);
     }
-    async clearRecoveryIntent(threadId, runId) {
-        const intentPath = path.join(this.runDir(threadId, runId), "recovery-intent.json");
+    async clearRequestRecoveryIntent(sessionId, requestId) {
+        const intentPath = path.join(this.requestDir(sessionId, requestId), "recovery-intent.json");
         if (!(await fileExists(intentPath))) {
             return;
         }
         await rm(intentPath, { force: true });
     }
-    async enqueueRun(input) {
-        const current = (await this.getQueuedRun(input.runId)) ?? {
-            runId: input.runId,
-            threadId: input.threadId,
+    async enqueueRequest(input) {
+        const current = (await this.getQueuedRequest(input.requestId)) ?? {
+            requestId: input.requestId,
+            sessionId: input.sessionId,
             priority: input.priority ?? 0,
             queueKey: input.queueKey ?? null,
             enqueuedAt: nowIso(),
@@ -583,9 +586,9 @@ export class FilePersistence {
             attemptCount: 0,
             lastError: null,
         };
-        await writeJson(this.runQueuePath(input.runId), {
+        await writeJson(this.requestQueuePath(input.requestId), {
             ...current,
-            threadId: input.threadId,
+            sessionId: input.sessionId,
             priority: input.priority ?? current.priority,
             queueKey: input.queueKey ?? current.queueKey,
             availableAt: input.availableAt ?? current.availableAt,
@@ -595,31 +598,31 @@ export class FilePersistence {
             lastError: null,
         });
     }
-    async getQueuedRun(runId) {
-        const filePath = this.runQueuePath(runId);
+    async getQueuedRequest(requestId) {
+        const filePath = this.requestQueuePath(requestId);
         if (!(await fileExists(filePath))) {
             return null;
         }
         return readJson(filePath);
     }
-    async claimQueuedRun(input) {
-        const current = await this.getQueuedRun(input.runId);
+    async claimQueuedRequest(input) {
+        const current = await this.getQueuedRequest(input.requestId);
         if (!current) {
-            throw new Error(`Missing queued run ${input.runId}`);
+            throw new Error(`Missing queued request ${input.requestId}`);
         }
         const claimedAt = input.claimedAt ?? nowIso();
         const next = {
             ...current,
-            threadId: input.threadId,
+            sessionId: input.sessionId,
             claimedBy: input.workerId,
             claimedAt,
             leaseExpiresAt: input.leaseExpiresAt,
             attemptCount: current.attemptCount + 1,
         };
-        await writeJson(this.runQueuePath(input.runId), next);
-        await writeJson(this.runControlPath(input.runId), {
-            ...(await this.getRunControl(input.runId) ?? {
-                runId: input.runId,
+        await writeJson(this.requestQueuePath(input.requestId), next);
+        await writeJson(this.requestControlPath(input.requestId), {
+            ...(await this.getRequestControl(input.requestId) ?? {
+                requestId: input.requestId,
                 cancelRequested: false,
                 cancelReason: null,
                 cancelRequestedAt: null,
@@ -633,19 +636,19 @@ export class FilePersistence {
         });
         return next;
     }
-    async renewRunLease(input) {
-        const current = await this.getQueuedRun(input.runId);
+    async renewRequestLease(input) {
+        const current = await this.getQueuedRequest(input.requestId);
         if (current) {
-            await writeJson(this.runQueuePath(input.runId), {
+            await writeJson(this.requestQueuePath(input.requestId), {
                 ...current,
                 claimedBy: input.workerId,
                 claimedAt: current.claimedAt ?? input.heartbeatAt ?? nowIso(),
                 leaseExpiresAt: input.leaseExpiresAt,
             });
         }
-        await writeJson(this.runControlPath(input.runId), {
-            ...(await this.getRunControl(input.runId) ?? {
-                runId: input.runId,
+        await writeJson(this.requestControlPath(input.requestId), {
+            ...(await this.getRequestControl(input.requestId) ?? {
+                requestId: input.requestId,
                 cancelRequested: false,
                 cancelReason: null,
                 cancelRequestedAt: null,
@@ -655,23 +658,23 @@ export class FilePersistence {
             }),
             heartbeatAt: input.heartbeatAt ?? nowIso(),
             workerId: input.workerId,
-            workerStartedAt: (await this.getRunControl(input.runId))?.workerStartedAt ?? input.heartbeatAt ?? nowIso(),
+            workerStartedAt: (await this.getRequestControl(input.requestId))?.workerStartedAt ?? input.heartbeatAt ?? nowIso(),
         });
     }
-    async releaseRunClaim(runId) {
-        await rm(this.runQueuePath(runId), { force: true });
-        const current = await this.getRunControl(runId);
+    async releaseRequestClaim(requestId) {
+        await rm(this.requestQueuePath(requestId), { force: true });
+        const current = await this.getRequestControl(requestId);
         if (!current) {
             return;
         }
-        await writeJson(this.runControlPath(runId), {
+        await writeJson(this.requestControlPath(requestId), {
             ...current,
             heartbeatAt: null,
             workerId: null,
             workerStartedAt: null,
         });
     }
-    async listExpiredClaimedRuns(cutoffIso) {
+    async listExpiredClaimedRequests(cutoffIso) {
         const queueDir = path.join(this.artifactsRoot(), "indexes", "requests-queue");
         if (!(await fileExists(queueDir))) {
             return [];
@@ -680,17 +683,17 @@ export class FilePersistence {
         const records = await Promise.all(entries.map((entry) => readJson(path.join(queueDir, entry))));
         return records.filter((record) => record.claimedBy && record.leaseExpiresAt && record.leaseExpiresAt <= cutoffIso);
     }
-    async getRunControl(runId) {
-        const filePath = this.runControlPath(runId);
+    async getRequestControl(requestId) {
+        const filePath = this.requestControlPath(requestId);
         if (!(await fileExists(filePath))) {
             return null;
         }
         return readJson(filePath);
     }
-    async requestRunCancel(runId, reason) {
-        const current = await this.getRunControl(runId);
+    async requestRequestCancel(requestId, reason) {
+        const current = await this.getRequestControl(requestId);
         if (!current) {
-            throw new Error(`Missing run control for ${runId}`);
+            throw new Error(`Missing request control for ${requestId}`);
         }
         const updated = {
             ...current,
@@ -698,15 +701,15 @@ export class FilePersistence {
             cancelReason: reason ?? null,
             cancelRequestedAt: nowIso(),
         };
-        await writeJson(this.runControlPath(runId), updated);
+        await writeJson(this.requestControlPath(requestId), updated);
         return updated;
     }
-    async clearRunCancel(runId) {
-        const current = await this.getRunControl(runId);
+    async clearRequestCancel(requestId) {
+        const current = await this.getRequestControl(requestId);
         if (!current) {
             return;
         }
-        await writeJson(this.runControlPath(runId), {
+        await writeJson(this.requestControlPath(requestId), {
             ...current,
             cancelRequested: false,
             cancelReason: null,