@botbotgo/agent-harness 0.0.138 → 0.0.141

package/README.md

@@ -135,10 +135,14 @@ Boundary documents live in:
 - `docs/acp-support-plan.md`
 - `docs/recovery-policy-matrix.md`
 - `docs/operator-timeline.md`
+- `docs/runtime-inspection-contract.md`
 - `docs/queue-concurrency-inspection.md`
 - `docs/tool-execution-policy.md`
 - `docs/feature-checklist.md`
 - `docs/long-term-memory.md`
+- `docs/memory-runtime-design.md`
+- `docs/memory-runtime-usage.md`
+- `docs/memory-policy-reference.md`
 - `docs/app-task-pattern.md`
 - `docs/model-layering.md`
 - `docs/coding-agent-guide.md`

package/README.zh.md

@@ -135,6 +135,7 @@ AI 让 agent 逻辑、工具调用和工作流代码更容易生成，真正变
 - `docs/acp-support-plan.md`
 - `docs/recovery-policy-matrix.md`
 - `docs/operator-timeline.md`
+- `docs/runtime-inspection-contract.md`
 - `docs/queue-concurrency-inspection.md`
 - `docs/tool-execution-policy.md`
 - `docs/feature-checklist.md`

package/dist/api.js

@@ -10,6 +10,7 @@ function toSessionSummary(summary) {
         createdAt: summary.createdAt,
         updatedAt: summary.updatedAt,
         status: summary.status,
+        currentAgentId: summary.currentAgentId,
     };
 }
 function toRequestSummary(summary) {
@@ -24,12 +25,19 @@ function toRequestSummary(summary) {
         state: summary.state,
         checkpointRef: summary.checkpointRef,
         resumable: summary.resumable,
+        startedAt: summary.startedAt,
+        endedAt: summary.endedAt,
+        lastActivityAt: summary.lastActivityAt,
+        currentAgentId: summary.currentAgentId,
+        delegationChain: summary.delegationChain,
+        runtimeSnapshot: summary.runtimeSnapshot,
     };
 }
 function toSessionRecord(record) {
     return {
         sessionId: record.threadId,
         entryAgentId: record.entryAgentId,
+        currentAgentId: record.currentAgentId,
         currentState: record.currentState,
         latestRequestId: record.latestRunId,
         createdAt: record.createdAt,

package/dist/contracts/runtime.d.ts

@@ -12,6 +12,7 @@ export type ThreadSummary = {
     createdAt: string;
     updatedAt: string;
     status: RunState;
+    currentAgentId?: string;
 };
 export type SessionSummary = Omit<ThreadSummary, "threadId" | "latestRunId"> & {
     sessionId: string;
@@ -74,6 +75,28 @@ export type RuntimeToolExecutionToolPolicy = {
     hasInputSchema: boolean;
     requiresApproval: boolean;
 };
+export type RuntimeSnapshotModel = {
+    id: string;
+    provider: string;
+    model: string;
+    baseUrl?: string;
+};
+export type RuntimeSnapshotTool = {
+    name: string;
+    description: string;
+};
+export type RuntimeSnapshotSkill = {
+    name: string;
+    path: string;
+    description?: string;
+};
+export type RuntimeSnapshot = {
+    agentId: string;
+    model?: RuntimeSnapshotModel;
+    tools: RuntimeSnapshotTool[];
+    skills: RuntimeSnapshotSkill[];
+    memory: string[];
+};
 /**
  * Operator-facing projection of tool execution policy already compiled into a binding.
  * This summarizes existing timeout, retry, validation, and retry-safety hints without
@@ -228,6 +251,12 @@ export type ThreadRunRecord = {
     state: RunState;
     checkpointRef: string | null;
     resumable: boolean;
+    startedAt: string;
+    endedAt?: string;
+    lastActivityAt: string;
+    currentAgentId?: string;
+    delegationChain: string[];
+    runtimeSnapshot?: RuntimeSnapshot;
 };
 /**
  * Persisted run summary projected from upstream execution state plus runtime lifecycle metadata.
@@ -246,6 +275,7 @@ export type RequestRecord = RequestSummary;
 export type ThreadRecord = {
     threadId: string;
     entryAgentId: string;
+    currentAgentId?: string;
     currentState: RunState;
     latestRunId: string;
     createdAt: string;

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.137";
+export declare const AGENT_HARNESS_VERSION = "0.0.140";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.137";
+export const AGENT_HARNESS_VERSION = "0.0.140";

package/dist/persistence/file-store.d.ts

@@ -1,5 +1,5 @@
 import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, RunSummary, RunState, ThreadSummary, ThreadRunRecord, TranscriptMessage } from "../contracts/types.js";
-import type { ApprovalFilter, PersistedRunRequest, PersistedRunControlRecord, PersistedRunQueueRecord, PersistenceLifecycle as Lifecycle, RuntimePersistence, RecoveryIntent, PersistenceRunMeta as RunMeta, RunSummaryFilter, ThreadSummaryFilter, PersistenceThreadMeta as ThreadMeta } from "./types.js";
+import type { ApprovalFilter, PersistedRunRequest, PersistedRunControlRecord, PersistedRunInspection, PersistedRunQueueRecord, PersistenceLifecycle as Lifecycle, RuntimePersistence, RecoveryIntent, PersistenceRunMeta as RunMeta, RunSummaryFilter, ThreadSummaryFilter, PersistenceThreadMeta as ThreadMeta } from "./types.js";
 type RunIndexRecord = {
     runId: string;
     threadId: string;
@@ -32,6 +32,10 @@ export declare class FilePersistence implements RuntimePersistence {
         executionMode: string;
         adapterKind?: string;
         createdAt: string;
+        startedAt?: string;
+        currentAgentId?: string;
+        delegationChain?: string[];
+        runtimeSnapshot?: RunSummary["runtimeSnapshot"];
     }): Promise<void>;
     setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
     appendEvent(event: HarnessEvent): Promise<void>;
@@ -49,6 +53,14 @@ export declare class FilePersistence implements RuntimePersistence {
     getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
     getRunMeta(threadId: string, runId: string): Promise<RunMeta>;
     getRunLifecycle(threadId: string, runId: string): Promise<Lifecycle>;
+    getRunInspection(threadId: string, runId: string): Promise<PersistedRunInspection>;
+    updateRunInspection(threadId: string, runId: string, patch: {
+        endedAt?: string | null;
+        lastActivityAt?: string;
+        currentAgentId?: string | null;
+        delegationChain?: string[];
+        runtimeSnapshot?: RunSummary["runtimeSnapshot"] | null;
+    }): Promise<void>;
     deleteThread(threadId: string): Promise<boolean>;
     saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;
     getRunRequest(threadId: string, runId: string): Promise<PersistedRunRequest | null>;

package/dist/persistence/file-store.js

@@ -84,9 +84,18 @@ export class FilePersistence {
             resumable: false,
             checkpointRef: null,
         };
+        const inspection = {
+            startedAt: input.startedAt ?? input.createdAt,
+            endedAt: null,
+            lastActivityAt: input.createdAt,
+            currentAgentId: input.currentAgentId ?? input.agentId,
+            delegationChain: input.delegationChain ?? [input.currentAgentId ?? input.agentId],
+            runtimeSnapshot: input.runtimeSnapshot ?? null,
+        };
         await Promise.all([
             writeJson(path.join(runDir, "meta.json"), meta),
             writeJson(path.join(runDir, "lifecycle.json"), lifecycle),
+            writeJson(path.join(runDir, "inspection.json"), inspection),
             writeJson(path.join(runDir, "checkpoint-ref.json"), {
                 threadId: input.threadId,
                 runId: input.runId,
@@ -124,9 +133,11 @@ 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 [lifecycle, runMeta] = await Promise.all([
+        const inspectionPath = path.join(this.runDir(threadId, runId), "inspection.json");
+        const [lifecycle, runMeta, inspection] = await Promise.all([
             readJson(lifecyclePath),
             readJson(runMetaPath),
+            readJson(inspectionPath),
         ]);
         const now = nowIso();
         const next = {
@@ -143,6 +154,11 @@ export class FilePersistence {
                 ...runMeta,
                 updatedAt: now,
             }),
+            writeJson(inspectionPath, {
+                ...inspection,
+                endedAt: state === "completed" || state === "failed" || state === "cancelled" ? now : inspection.endedAt,
+                lastActivityAt: now,
+            }),
         ]);
         if (checkpointRef !== undefined) {
             await writeJson(path.join(this.runDir(threadId, runId), "checkpoint-ref.json"), {
@@ -175,7 +191,15 @@ export class FilePersistence {
     }
     async appendEvent(event) {
         const sequenceId = String(event.sequence).padStart(6, "0");
-        await writeJson(path.join(this.runDir(event.threadId, event.runId), "events", `${sequenceId}.json`), event);
+        const inspectionPath = path.join(this.runDir(event.threadId, event.runId), "inspection.json");
+        const inspection = await readJson(inspectionPath);
+        await Promise.all([
+            writeJson(path.join(this.runDir(event.threadId, event.runId), "events", `${sequenceId}.json`), event),
+            writeJson(inspectionPath, {
+                ...inspection,
+                lastActivityAt: event.timestamp,
+            }),
+        ]);
     }
     async listSessions(filter = {}) {
         const threadIndexDir = path.join(this.runRoot, "indexes", "threads");
@@ -185,7 +209,10 @@ export class FilePersistence {
         const entries = await readdir(threadIndexDir);
         const records = await Promise.all(entries.map(async (entry) => {
             const index = await readJson(path.join(threadIndexDir, entry));
-            const meta = await readJson(path.join(this.threadDir(index.threadId), "meta.json"));
+            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),
+            ]);
             return {
                 agentId: meta.entryAgentId,
                 threadId: index.threadId,
@@ -193,6 +220,7 @@ export class FilePersistence {
                 createdAt: meta.createdAt,
                 updatedAt: index.updatedAt,
                 status: index.status,
+                currentAgentId: runInspection?.currentAgentId ?? undefined,
             };
         }));
         return records
@@ -209,9 +237,10 @@ export class FilePersistence {
     }
     async readRunSummary(threadId, runId) {
         const runDir = this.runDir(threadId, runId);
-        const [meta, lifecycle] = await Promise.all([
+        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")),
         ]);
         return {
             runId: meta.runId,
@@ -224,6 +253,12 @@ export class FilePersistence {
             state: lifecycle.state,
             checkpointRef: lifecycle.checkpointRef,
             resumable: lifecycle.resumable,
+            startedAt: inspection.startedAt,
+            ...(inspection.endedAt ? { endedAt: inspection.endedAt } : {}),
+            lastActivityAt: inspection.lastActivityAt,
+            ...(inspection.currentAgentId ? { currentAgentId: inspection.currentAgentId } : {}),
+            delegationChain: inspection.delegationChain,
+            ...(inspection.runtimeSnapshot ? { runtimeSnapshot: inspection.runtimeSnapshot } : {}),
         };
     }
     async listRuns(filter = {}) {
@@ -261,6 +296,7 @@ export class FilePersistence {
             readJson(filePath),
             readJson(path.join(this.threadDir(threadId), "meta.json")),
         ]);
+        const runInspection = await readJson(path.join(this.runDir(threadId, index.latestRunId), "inspection.json")).catch(() => null);
         return {
             agentId: meta.entryAgentId,
             threadId,
@@ -268,6 +304,7 @@ export class FilePersistence {
             createdAt: meta.createdAt,
             updatedAt: index.updatedAt,
             status: index.status,
+            currentAgentId: runInspection?.currentAgentId ?? undefined,
         };
     }
     async getThreadMeta(threadId) {
@@ -335,6 +372,21 @@ export class FilePersistence {
     async getRunLifecycle(threadId, runId) {
         return readJson(path.join(this.runDir(threadId, runId), "lifecycle.json"));
     }
+    async getRunInspection(threadId, runId) {
+        return readJson(path.join(this.runDir(threadId, runId), "inspection.json"));
+    }
+    async updateRunInspection(threadId, runId, patch) {
+        const inspectionPath = path.join(this.runDir(threadId, runId), "inspection.json");
+        const current = await readJson(inspectionPath);
+        await writeJson(inspectionPath, {
+            ...current,
+            ...(patch.endedAt !== undefined ? { endedAt: patch.endedAt } : {}),
+            ...(patch.lastActivityAt ? { lastActivityAt: patch.lastActivityAt } : {}),
+            ...(patch.currentAgentId !== undefined ? { currentAgentId: patch.currentAgentId } : {}),
+            ...(patch.delegationChain ? { delegationChain: patch.delegationChain } : {}),
+            ...(patch.runtimeSnapshot !== undefined ? { runtimeSnapshot: patch.runtimeSnapshot } : {}),
+        });
+    }
     async deleteThread(threadId) {
         const threadDir = this.threadDir(threadId);
         const threadIndexPath = this.threadIndexPath(threadId);

package/dist/persistence/sqlite-store.d.ts

@@ -1,5 +1,5 @@
 import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, RunState, RunSummary, ThreadRunRecord, ThreadSummary, TranscriptMessage } from "../contracts/types.js";
-import type { PersistedRunRequest, PersistedRunControlRecord, PersistedRunQueueRecord, PersistenceLifecycle, PersistenceRunMeta, PersistenceThreadMeta, RecoveryIntent, RuntimePersistence, ApprovalFilter, RunSummaryFilter, ThreadSummaryFilter } from "./types.js";
+import type { PersistedRunRequest, PersistedRunControlRecord, PersistedRunInspection, PersistedRunQueueRecord, PersistenceLifecycle, PersistenceRunMeta, PersistenceThreadMeta, RecoveryIntent, RuntimePersistence, ApprovalFilter, RunSummaryFilter, ThreadSummaryFilter } from "./types.js";
 export declare function listProtectedCheckpointThreadIds(dbPath: string): Promise<Set<string>>;
 export declare class SqlitePersistence implements RuntimePersistence {
     private readonly runRoot;
@@ -43,6 +43,10 @@ export declare class SqlitePersistence implements RuntimePersistence {
         userMessage: TranscriptMessage;
         runRequest: PersistedRunRequest;
         createThread: boolean;
+        startedAt?: string;
+        currentAgentId?: string;
+        delegationChain?: string[];
+        runtimeSnapshot?: RunSummary["runtimeSnapshot"];
     }): Promise<void>;
     createRun(input: {
         threadId: string;
@@ -51,6 +55,10 @@ export declare class SqlitePersistence implements RuntimePersistence {
         executionMode: string;
         adapterKind?: string;
         createdAt: string;
+        startedAt?: string;
+        currentAgentId?: string;
+        delegationChain?: string[];
+        runtimeSnapshot?: RunSummary["runtimeSnapshot"];
     }): Promise<void>;
     setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
     appendEvent(event: HarnessEvent): Promise<void>;
@@ -66,6 +74,14 @@ export declare class SqlitePersistence implements RuntimePersistence {
     getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
     getRunMeta(threadId: string, runId: string): Promise<PersistenceRunMeta>;
     getRunLifecycle(threadId: string, runId: string): Promise<PersistenceLifecycle>;
+    getRunInspection(threadId: string, runId: string): Promise<PersistedRunInspection>;
+    updateRunInspection(threadId: string, runId: string, patch: {
+        endedAt?: string | null;
+        lastActivityAt?: string;
+        currentAgentId?: string | null;
+        delegationChain?: string[];
+        runtimeSnapshot?: RunSummary["runtimeSnapshot"] | null;
+    }): Promise<void>;
     deleteThread(threadId: string): Promise<boolean>;
     saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;
     getRunRequest(threadId: string, runId: string): Promise<PersistedRunRequest | null>;

package/dist/persistence/sqlite-store.js

@@ -4,7 +4,7 @@ import { createClient } from "@libsql/client";
 import { fileExists, readJson, writeJson } from "../utils/fs.js";
 import { SqliteRunContextStore } from "./sqlite-run-context-store.js";
 import { SqliteRunQueueStore } from "./sqlite-run-queue-store.js";
-const RUNTIME_SQLITE_SCHEMA_VERSION = 2;
+const RUNTIME_SQLITE_SCHEMA_VERSION = 3;
 const RUNTIME_SQLITE_SCHEMA_FAMILY = "agent-harness-runtime";
 function asRow(value) {
     return value;
@@ -143,10 +143,25 @@ export class SqlitePersistence {
           checkpoint_ref TEXT,
           FOREIGN KEY (thread_id) REFERENCES threads(thread_id)
         )
+      `);
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS run_inspection (
+          run_id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          started_at TEXT NOT NULL,
+          ended_at TEXT,
+          last_activity_at TEXT NOT NULL,
+          current_agent_id TEXT,
+          delegation_chain_json TEXT NOT NULL,
+          runtime_snapshot_json TEXT,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
       `);
             await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_thread_updated_idx ON runs(thread_id, updated_at DESC)");
             await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_state_updated_idx ON runs(state, updated_at DESC)");
             await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_agent_updated_idx ON runs(agent_id, updated_at DESC)");
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS run_inspection_thread_activity_idx ON run_inspection(thread_id, last_activity_at DESC)");
             await this.rawExecute(`
         CREATE TABLE IF NOT EXISTS thread_messages (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -323,9 +338,11 @@ export class SqlitePersistence {
             createdAt: asString(row.created_at),
             updatedAt: asString(row.updated_at),
             status: asString(row.status),
+            currentAgentId: asNullableString(row.current_agent_id) ?? undefined,
         };
     }
     mapRunSummary(row) {
+        const runtimeSnapshot = row.runtime_snapshot_json ? parseJson(row.runtime_snapshot_json) : null;
         return {
             runId: asString(row.run_id),
             threadId: asString(row.thread_id),
@@ -337,6 +354,12 @@ export class SqlitePersistence {
             state: asString(row.state),
             checkpointRef: asNullableString(row.checkpoint_ref),
             resumable: asBoolean(row.resumable),
+            startedAt: asNullableString(row.started_at) ?? asString(row.created_at),
+            endedAt: asNullableString(row.ended_at) ?? undefined,
+            lastActivityAt: asNullableString(row.last_activity_at) ?? asString(row.updated_at),
+            currentAgentId: asNullableString(row.current_agent_id) ?? undefined,
+            delegationChain: row.delegation_chain_json ? parseJson(row.delegation_chain_json) : [asString(row.agent_id)],
+            ...(runtimeSnapshot ? { runtimeSnapshot } : {}),
         };
     }
     mapApproval(row) {
@@ -372,7 +395,27 @@ export class SqlitePersistence {
         if (family !== RUNTIME_SQLITE_SCHEMA_FAMILY) {
             throw new Error(`Unsupported runtime sqlite schema family ${JSON.stringify(family)} in ${this.dbPath}. Expected ${JSON.stringify(RUNTIME_SQLITE_SCHEMA_FAMILY)}.`);
         }
-        if (version === "1") {
+        if (version === "1" || version === "2") {
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS run_inspection (
+          run_id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          started_at TEXT NOT NULL,
+          ended_at TEXT,
+          last_activity_at TEXT NOT NULL,
+          current_agent_id TEXT,
+          delegation_chain_json TEXT NOT NULL,
+          runtime_snapshot_json TEXT,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
+      `);
+            await this.rawExecute(`
+        INSERT OR IGNORE INTO run_inspection
+        (run_id, thread_id, started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json)
+        SELECT run_id, thread_id, created_at, NULL, updated_at, agent_id, json_array(agent_id), NULL
+        FROM runs
+      `);
             await this.rawExecute("INSERT OR REPLACE INTO runtime_metadata (key, value) VALUES (?, ?)", ["schema_version", String(RUNTIME_SQLITE_SCHEMA_VERSION)]);
             return;
         }
@@ -422,6 +465,19 @@ export class SqlitePersistence {
        (run_id, cancel_requested, cancel_reason, cancel_requested_at, heartbeat_at, worker_id, worker_started_at)
        VALUES (?, 0, NULL, NULL, NULL, NULL, NULL)`,
             args: [input.runId],
+        }, {
+            sql: `INSERT OR REPLACE INTO run_inspection
+       (run_id, thread_id, started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json)
+       VALUES (?, ?, ?, NULL, ?, ?, ?, ?)`,
+            args: [
+                input.runId,
+                input.threadId,
+                input.startedAt ?? input.createdAt,
+                input.createdAt,
+                input.currentAgentId ?? input.agentId,
+                JSON.stringify(input.delegationChain ?? [input.currentAgentId ?? input.agentId]),
+                input.runtimeSnapshot ? JSON.stringify(input.runtimeSnapshot) : null,
+            ],
         }, {
             sql: `INSERT INTO thread_messages
        (thread_id, role, content_json, run_id, created_at)
@@ -463,6 +519,17 @@ export class SqlitePersistence {
         await this.execute(`INSERT OR REPLACE INTO run_control
        (run_id, cancel_requested, cancel_reason, cancel_requested_at, heartbeat_at, worker_id, worker_started_at)
        VALUES (?, 0, NULL, NULL, NULL, NULL, NULL)`, [input.runId]);
+        await this.execute(`INSERT OR REPLACE INTO run_inspection
+       (run_id, thread_id, started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json)
+       VALUES (?, ?, ?, NULL, ?, ?, ?, ?)`, [
+            input.runId,
+            input.threadId,
+            input.startedAt ?? input.createdAt,
+            input.createdAt,
+            input.currentAgentId ?? input.agentId,
+            JSON.stringify(input.delegationChain ?? [input.currentAgentId ?? input.agentId]),
+            input.runtimeSnapshot ? JSON.stringify(input.runtimeSnapshot) : null,
+        ]);
     }
     async setRunState(threadId, runId, state, checkpointRef) {
         const current = await this.getRunLifecycle(threadId, runId);
@@ -475,42 +542,59 @@ export class SqlitePersistence {
         await this.execute(`UPDATE threads
        SET status = ?, latest_run_id = ?, updated_at = ?
        WHERE thread_id = ?`, [state, runId, now, threadId]);
+        await this.execute(`UPDATE run_inspection
+       SET last_activity_at = ?, ended_at = CASE
+         WHEN ? IN ('completed', 'failed', 'cancelled') THEN ?
+         ELSE ended_at
+       END
+       WHERE run_id = ? AND thread_id = ?`, [now, state, now, runId, threadId]);
     }
     async appendEvent(event) {
         await this.execute(`INSERT OR REPLACE INTO events
        (thread_id, run_id, sequence, event_json, created_at)
        VALUES (?, ?, ?, ?, ?)`, [event.threadId, event.runId, event.sequence, JSON.stringify(event), event.timestamp]);
+        await this.execute(`UPDATE run_inspection
+       SET last_activity_at = ?
+       WHERE run_id = ? AND thread_id = ?`, [event.timestamp, event.runId, event.threadId]);
     }
     async listSessions(filter = {}) {
         const { clause, args } = buildWhereClause([
-            ["entry_agent_id = ?", filter.agentId],
+            ["threads.entry_agent_id = ?", filter.agentId],
         ]);
-        const rows = await this.selectAll(`SELECT thread_id, entry_agent_id, latest_run_id, created_at, updated_at, status
-       FROM threads${clause}
+        const rows = await this.selectAll(`SELECT threads.thread_id, threads.entry_agent_id, threads.latest_run_id, threads.created_at, threads.updated_at, threads.status, run_inspection.current_agent_id
+       FROM threads
+       LEFT JOIN run_inspection ON run_inspection.run_id = threads.latest_run_id
+       ${clause}
        ORDER BY updated_at DESC`, args);
         return rows.map((row) => this.mapThreadSummary(row));
     }
     async listRuns(filter = {}) {
         const { clause, args } = buildWhereClause([
-            ["agent_id = ?", filter.agentId],
-            ["thread_id = ?", filter.threadId],
-            ["state = ?", filter.state],
+            ["runs.agent_id = ?", filter.agentId],
+            ["runs.thread_id = ?", filter.threadId],
+            ["runs.state = ?", filter.state],
         ]);
-        const rows = await this.selectAll(`SELECT run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, checkpoint_ref, resumable
-       FROM runs${clause}
+        const rows = await this.selectAll(`SELECT runs.run_id, runs.thread_id, runs.agent_id, runs.execution_mode, runs.adapter_kind, runs.created_at, runs.updated_at, runs.state, runs.checkpoint_ref, runs.resumable,
+              run_inspection.started_at, run_inspection.ended_at, run_inspection.last_activity_at, run_inspection.current_agent_id, run_inspection.delegation_chain_json, run_inspection.runtime_snapshot_json
+       FROM runs
+       LEFT JOIN run_inspection ON run_inspection.run_id = runs.run_id
+       ${clause}
        ORDER BY updated_at DESC`, args);
         return rows.map((row) => this.mapRunSummary(row));
     }
     async getRun(runId) {
-        const row = await this.selectOne(`SELECT run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, checkpoint_ref, resumable
+        const row = await this.selectOne(`SELECT runs.run_id, runs.thread_id, runs.agent_id, runs.execution_mode, runs.adapter_kind, runs.created_at, runs.updated_at, runs.state, runs.checkpoint_ref, runs.resumable,
+              run_inspection.started_at, run_inspection.ended_at, run_inspection.last_activity_at, run_inspection.current_agent_id, run_inspection.delegation_chain_json, run_inspection.runtime_snapshot_json
        FROM runs
-       WHERE run_id = ?`, [runId]);
+       LEFT JOIN run_inspection ON run_inspection.run_id = runs.run_id
+       WHERE runs.run_id = ?`, [runId]);
         return row ? this.mapRunSummary(row) : null;
     }
     async getSession(threadId) {
-        const row = await this.selectOne(`SELECT thread_id, entry_agent_id, latest_run_id, created_at, updated_at, status
+        const row = await this.selectOne(`SELECT threads.thread_id, threads.entry_agent_id, threads.latest_run_id, threads.created_at, threads.updated_at, threads.status, run_inspection.current_agent_id
        FROM threads
-       WHERE thread_id = ?`, [threadId]);
+       LEFT JOIN run_inspection ON run_inspection.run_id = threads.latest_run_id
+       WHERE threads.thread_id = ?`, [threadId]);
         return row ? this.mapThreadSummary(row) : null;
     }
     async getThreadMeta(threadId) {
@@ -529,9 +613,11 @@ export class SqlitePersistence {
         };
     }
     async listThreadRuns(threadId) {
-        const rows = await this.selectAll(`SELECT run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, checkpoint_ref, resumable
+        const rows = await this.selectAll(`SELECT runs.run_id, runs.thread_id, runs.agent_id, runs.execution_mode, runs.adapter_kind, runs.created_at, runs.updated_at, runs.state, runs.checkpoint_ref, runs.resumable,
+              run_inspection.started_at, run_inspection.ended_at, run_inspection.last_activity_at, run_inspection.current_agent_id, run_inspection.delegation_chain_json, run_inspection.runtime_snapshot_json
        FROM runs
-       WHERE thread_id = ?
+       LEFT JOIN run_inspection ON run_inspection.run_id = runs.run_id
+       WHERE runs.thread_id = ?
        ORDER BY created_at DESC`, [threadId]);
         return rows.map((row) => this.mapRunSummary(row));
     }
@@ -592,6 +678,36 @@ export class SqlitePersistence {
             checkpointRef: asNullableString(row.checkpoint_ref),
         };
     }
+    async getRunInspection(threadId, runId) {
+        const row = await this.selectOne(`SELECT started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json
+       FROM run_inspection
+       WHERE thread_id = ? AND run_id = ?`, [threadId, runId]);
+        if (!row) {
+            throw new Error(`Missing run inspection ${runId} for thread ${threadId}`);
+        }
+        return {
+            startedAt: asString(row.started_at),
+            endedAt: asNullableString(row.ended_at),
+            lastActivityAt: asString(row.last_activity_at),
+            currentAgentId: asNullableString(row.current_agent_id),
+            delegationChain: parseJson(row.delegation_chain_json),
+            runtimeSnapshot: row.runtime_snapshot_json ? parseJson(row.runtime_snapshot_json) : null,
+        };
+    }
+    async updateRunInspection(threadId, runId, patch) {
+        const current = await this.getRunInspection(threadId, runId);
+        await this.execute(`UPDATE run_inspection
+       SET ended_at = ?, last_activity_at = ?, current_agent_id = ?, delegation_chain_json = ?, runtime_snapshot_json = ?
+       WHERE run_id = ? AND thread_id = ?`, [
+            patch.endedAt === undefined ? current.endedAt : patch.endedAt,
+            patch.lastActivityAt ?? current.lastActivityAt,
+            patch.currentAgentId === undefined ? current.currentAgentId : patch.currentAgentId,
+            JSON.stringify(patch.delegationChain ?? current.delegationChain),
+            JSON.stringify(patch.runtimeSnapshot === undefined ? current.runtimeSnapshot : patch.runtimeSnapshot),
+            runId,
+            threadId,
+        ]);
+    }
     async deleteThread(threadId) {
         const exists = await this.getSession(threadId);
         if (!exists) {
@@ -600,6 +716,7 @@ export class SqlitePersistence {
         await this.execute("DELETE FROM artifacts WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM approvals WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM events WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM run_inspection WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM run_queue WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM run_requests WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM recovery_intents WHERE thread_id = ?", [threadId]);

package/dist/persistence/types.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, InvocationEnvelope, MessageContent, RunState, RunSummary, ThreadRunRecord, ThreadSummary, TranscriptMessage } from "../contracts/types.js";
+import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, InvocationEnvelope, MessageContent, RuntimeSnapshot, RunState, RunSummary, ThreadRunRecord, ThreadSummary, TranscriptMessage } from "../contracts/types.js";
 export type PersistenceThreadMeta = {
     threadId: string;
     workspaceId: string;
@@ -25,6 +25,14 @@ export type PersistenceLifecycle = {
     resumable: boolean;
     checkpointRef: string | null;
 };
+export type PersistedRunInspection = {
+    startedAt: string;
+    endedAt: string | null;
+    lastActivityAt: string;
+    currentAgentId: string | null;
+    delegationChain: string[];
+    runtimeSnapshot: RuntimeSnapshot | null;
+};
 export type PersistedRunRequest = {
     input: MessageContent;
     priority?: number;
@@ -86,6 +94,10 @@ export interface RuntimePersistence {
         userMessage: TranscriptMessage;
         runRequest: PersistedRunRequest;
         createThread: boolean;
+        startedAt?: string;
+        currentAgentId?: string;
+        delegationChain?: string[];
+        runtimeSnapshot?: RuntimeSnapshot;
     }): Promise<void>;
     createThread(input: {
         threadId: string;
@@ -101,6 +113,10 @@ export interface RuntimePersistence {
         executionMode: string;
         adapterKind?: string;
         createdAt: string;
+        startedAt?: string;
+        currentAgentId?: string;
+        delegationChain?: string[];
+        runtimeSnapshot?: RuntimeSnapshot;
     }): Promise<void>;
     setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
     appendEvent(event: HarnessEvent): Promise<void>;
@@ -115,6 +131,14 @@ export interface RuntimePersistence {
     getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
     getRunMeta(threadId: string, runId: string): Promise<PersistenceRunMeta>;
     getRunLifecycle(threadId: string, runId: string): Promise<PersistenceLifecycle>;
+    getRunInspection(threadId: string, runId: string): Promise<PersistedRunInspection>;
+    updateRunInspection(threadId: string, runId: string, patch: {
+        endedAt?: string | null;
+        lastActivityAt?: string;
+        currentAgentId?: string | null;
+        delegationChain?: string[];
+        runtimeSnapshot?: RuntimeSnapshot | null;
+    }): Promise<void>;
     deleteThread(threadId: string): Promise<boolean>;
     saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;
     getRunRequest(threadId: string, runId: string): Promise<PersistedRunRequest | null>;

package/dist/runtime/harness/events/events.d.ts

@@ -1,6 +1,6 @@
 import type { HarnessEvent, InternalApprovalRecord, MessageContent, RunResult } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
-type EventPersistence = Pick<RuntimePersistence, "appendEvent" | "setRunState" | "createApproval" | "createArtifact">;
+type EventPersistence = Pick<RuntimePersistence, "appendEvent" | "setRunState" | "createApproval" | "createArtifact" | "updateRunInspection">;
 type EventRuntime = {
     persistence: EventPersistence;
     publishEvent: (event: HarnessEvent) => void;

package/dist/runtime/harness/events/events.js

@@ -18,6 +18,11 @@ export async function emitRunCreatedEvent(runtime, threadId, runId, payload) {
 }
 export async function setRunStateAndEmitEvent(runtime, threadId, runId, sequence, state, options) {
     await runtime.persistence.setRunState(threadId, runId, state, options.checkpointRef ?? null);
+    const now = new Date(Date.now()).toISOString();
+    await runtime.persistence.updateRunInspection(threadId, runId, {
+        lastActivityAt: now,
+        ...(state === "completed" || state === "failed" || state === "cancelled" ? { endedAt: now } : {}),
+    });
     return emitHarnessEvent(runtime, threadId, runId, sequence, "run.state.changed", {
         previousState: options.previousState,
         state,

package/dist/runtime/harness/events/listener-runtime.d.ts

@@ -6,6 +6,7 @@ export declare function createListenerDispatchRuntime(input: {
         currentState: RunResult["state"];
         latestRunId: string;
         entryAgentId: string;
+        currentAgentId?: string;
         runs: Array<{
             agentId: string;
         }>;

package/dist/runtime/harness/events/streaming.d.ts

@@ -29,6 +29,7 @@ export declare function dispatchRunListeners(stream: AsyncGenerator<InternalHarn
         currentState: RunResult["state"];
         latestRunId: string;
         entryAgentId: string;
+        currentAgentId?: string;
         runs: Array<{
             agentId: string;
         }>;

package/dist/runtime/harness/events/streaming.js

@@ -68,7 +68,7 @@ export async function dispatchRunListeners(stream, listeners, options) {
         currentState: thread.currentState,
         latestRunId: thread.latestRunId,
         entryAgentId: thread.entryAgentId,
-        latestAgentId: thread.runs[0]?.agentId,
+        latestAgentId: thread.currentAgentId ?? thread.runs[0]?.agentId,
         approvalId: thread.pendingDecision?.approvalId,
         pendingActionId: thread.pendingDecision?.pendingActionId,
         output,

package/dist/runtime/harness/run/inspection.d.ts

@@ -0,0 +1,11 @@
+import type { CompiledAgentBinding, RuntimeSnapshot } from "../../../contracts/types.js";
+export declare function buildRunRuntimeSnapshot(binding: CompiledAgentBinding): RuntimeSnapshot;
+export declare function consumeRunInspectionUpstreamEvent(input: {
+    event: unknown;
+    currentAgentId: string;
+    delegationChain: string[];
+    binding: CompiledAgentBinding;
+}): {
+    currentAgentId: string;
+    delegationChain: string[];
+};

package/dist/runtime/harness/run/inspection.js

@@ -0,0 +1,97 @@
+import { readSkillMetadata } from "../../support/skill-metadata.js";
+import { getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, } from "../../support/compiled-binding.js";
+function asObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+}
+export function buildRunRuntimeSnapshot(binding) {
+    const model = getBindingPrimaryModel(binding);
+    const init = typeof model?.init === "object" && model.init ? model.init : {};
+    const baseUrl = typeof init.baseUrl === "string" && init.baseUrl.trim().length > 0
+        ? init.baseUrl.trim()
+        : typeof init.baseURL === "string" && init.baseURL.trim().length > 0
+            ? init.baseURL.trim()
+            : undefined;
+    return {
+        agentId: binding.agent.id,
+        ...(model ? {
+            model: {
+                id: model.id,
+                provider: model.provider,
+                model: model.model,
+                ...(baseUrl ? { baseUrl } : {}),
+            },
+        } : {}),
+        tools: getBindingPrimaryTools(binding).map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+        })),
+        skills: getBindingSkills(binding).map((skillPath) => {
+            const metadata = readSkillMetadata(skillPath);
+            return {
+                name: metadata.name,
+                path: skillPath,
+                ...(metadata.description ? { description: metadata.description } : {}),
+            };
+        }),
+        memory: getBindingMemorySources(binding),
+    };
+}
+function maybeAppendAgent(chain, agentId) {
+    if (!agentId) {
+        return chain;
+    }
+    if (chain[chain.length - 1] === agentId) {
+        return chain;
+    }
+    if (chain.includes(agentId)) {
+        return [...chain.filter((entry) => entry !== agentId), agentId];
+    }
+    return [...chain, agentId];
+}
+function extractSubagentFromTaskToolEvent(event) {
+    const eventName = typeof event.event === "string" ? event.event : "";
+    const toolName = typeof event.name === "string" ? event.name : "";
+    if (toolName !== "task" || (eventName !== "on_tool_start" && !(eventName === "on_chain_start" && event.run_type === "tool"))) {
+        return null;
+    }
+    const data = asObject(event.data);
+    const input = asObject(data?.input);
+    const subagentType = typeof input?.subagent_type === "string"
+        ? input.subagent_type
+        : typeof input?.subagentType === "string"
+            ? input.subagentType
+            : null;
+    return subagentType && subagentType.trim().length > 0 ? subagentType.trim() : null;
+}
+function extractKnownSubagentFromEvent(event, knownSubagentIds) {
+    const names = [
+        typeof event.name === "string" ? event.name : "",
+        ...readStringArray(event.tags),
+        ...readStringArray(event.ns),
+    ];
+    return names.find((name) => knownSubagentIds.has(name)) ?? null;
+}
+export function consumeRunInspectionUpstreamEvent(input) {
+    const typed = asObject(input.event);
+    if (!typed) {
+        return {
+            currentAgentId: input.currentAgentId,
+            delegationChain: input.delegationChain,
+        };
+    }
+    const knownSubagentIds = new Set(getBindingSubagents(input.binding).map((subagent) => subagent.name));
+    const delegatedAgentId = extractSubagentFromTaskToolEvent(typed) ?? extractKnownSubagentFromEvent(typed, knownSubagentIds);
+    if (!delegatedAgentId) {
+        return {
+            currentAgentId: input.currentAgentId,
+            delegationChain: input.delegationChain,
+        };
+    }
+    return {
+        currentAgentId: delegatedAgentId,
+        delegationChain: maybeAppendAgent(input.delegationChain, delegatedAgentId),
+    };
+}

package/dist/runtime/harness/run/start-run.d.ts

@@ -20,6 +20,10 @@ type EnsureThreadStartedRuntime = {
             };
             runRequest: PersistedRunRequest;
             createThread: boolean;
+            startedAt?: string;
+            currentAgentId?: string;
+            delegationChain?: string[];
+            runtimeSnapshot?: import("../../../contracts/types.js").RuntimeSnapshot;
         }) => Promise<void>;
         createThread: (input: {
             threadId: string;
@@ -41,6 +45,10 @@ type EnsureThreadStartedRuntime = {
             executionMode: string;
             adapterKind: string;
             createdAt: string;
+            startedAt?: string;
+            currentAgentId?: string;
+            delegationChain?: string[];
+            runtimeSnapshot?: import("../../../contracts/types.js").RuntimeSnapshot;
         }) => Promise<void>;
         saveRunRequest: (threadId: string, runId: string, runRequest: PersistedRunRequest) => Promise<void>;
     };

package/dist/runtime/harness/run/start-run.js

@@ -4,12 +4,17 @@ import { normalizeMessageContent } from "../../../utils/message-content.js";
 import { buildPersistedRunRequest, normalizeRunPriority } from "./helpers.js";
 import { getRequiredWorkspaceBinding } from "../bindings.js";
 import { getBindingAdapterKind, getBindingRuntimeExecutionMode } from "../../support/compiled-binding.js";
+import { buildRunRuntimeSnapshot } from "./inspection.js";
 export async function ensureThreadStarted(runtime, input) {
     const { selectedAgentId, binding, message, runRequest, existingThreadId } = input;
     const threadId = existingThreadId ?? createPersistentId();
     const runId = createPersistentId();
     const createdAt = new Date().toISOString();
     const isNewThread = !existingThreadId;
+    const startedAt = createdAt;
+    const currentAgentId = selectedAgentId;
+    const delegationChain = [selectedAgentId];
+    const runtimeSnapshot = buildRunRuntimeSnapshot(binding);
     const userMessage = {
         role: "user",
         content: normalizeMessageContent(message),
@@ -28,6 +33,10 @@ export async function ensureThreadStarted(runtime, input) {
             userMessage,
             runRequest,
             createThread: isNewThread,
+            startedAt,
+            currentAgentId,
+            delegationChain,
+            runtimeSnapshot,
         });
     }
     else {
@@ -49,6 +58,10 @@ export async function ensureThreadStarted(runtime, input) {
                 executionMode: getBindingRuntimeExecutionMode(binding),
                 adapterKind: getBindingAdapterKind(binding),
                 createdAt,
+                startedAt,
+                currentAgentId,
+                delegationChain,
+                runtimeSnapshot,
             }),
             runtime.persistence.saveRunRequest(threadId, runId, runRequest),
         ]);

package/dist/runtime/harness/run/stream-run.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, HarnessEvent, MessageContent, RunResult, TranscriptMessage } from "../../../contracts/types.js";
+import type { CompiledAgentBinding, HarnessEvent, MessageContent, RunResult, RuntimeSnapshot, TranscriptMessage } from "../../../contracts/types.js";
 import { type InternalHarnessStreamItem } from "../events/streaming.js";
 type RuntimeStreamChunk = string | {
     kind: "content" | "interrupt" | "reasoning" | "step" | "tool-result" | "upstream-event";
@@ -45,6 +45,13 @@ type StreamRunOptions = {
     }>;
     appendAssistantMessage: (threadId: string, runId: string, content?: string) => Promise<void>;
     clearRunRequest: (threadId: string, runId: string) => Promise<void>;
+    updateRunInspection: (threadId: string, runId: string, patch: {
+        endedAt?: string | null;
+        lastActivityAt?: string;
+        currentAgentId?: string | null;
+        delegationChain?: string[];
+        runtimeSnapshot?: RuntimeSnapshot | null;
+    }) => Promise<void>;
     emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown) => Promise<void>;
 };
 export declare function streamHarnessRun(options: StreamRunOptions): AsyncGenerator<InternalHarnessStreamItem>;

package/dist/runtime/harness/run/stream-run.js

@@ -2,6 +2,7 @@ import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from ".
 import { renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { getBindingPrimaryModel } from "../../support/compiled-binding.js";
 import { createContentBlocksItem, createToolResultKey, } from "../events/streaming.js";
+import { consumeRunInspectionUpstreamEvent } from "./inspection.js";
 function normalizeStreamChunk(chunk) {
     if (typeof chunk === "string") {
         if (chunk.startsWith(AGENT_INTERRUPT_SENTINEL_PREFIX)) {
@@ -43,6 +44,8 @@ export async function* streamHarnessRun(options) {
     let emitted = false;
     let streamActivityObserved = false;
     let nonUpstreamStreamActivityObserved = false;
+    let currentAgentId = options.selectedAgentId;
+    let delegationChain = [options.selectedAgentId];
     try {
         const [priorHistory, acquiredReleaseRunSlot] = await Promise.all([
             priorHistoryPromise,
@@ -64,6 +67,18 @@ export async function* streamHarnessRun(options) {
             streamActivityObserved = true;
             const normalizedChunk = normalizeStreamChunk(rawChunk);
             if (normalizedChunk.kind === "upstream-event") {
+                const inspection = consumeRunInspectionUpstreamEvent({
+                    event: normalizedChunk.event,
+                    currentAgentId,
+                    delegationChain,
+                    binding: options.binding,
+                });
+                currentAgentId = inspection.currentAgentId;
+                delegationChain = inspection.delegationChain;
+                await options.updateRunInspection(options.threadId, options.runId, {
+                    currentAgentId,
+                    delegationChain,
+                });
                 yield {
                     type: "upstream-event",
                     threadId: options.threadId,
@@ -88,7 +103,7 @@ export async function* streamHarnessRun(options) {
                     result: {
                         threadId: options.threadId,
                         runId: options.runId,
-                        agentId: options.selectedAgentId,
+                        agentId: currentAgentId,
                         state: "waiting_for_approval",
                         output: assistantOutput,
                         finalMessageText: assistantOutput,
@@ -145,7 +160,7 @@ export async function* streamHarnessRun(options) {
             result: {
                 threadId: options.threadId,
                 runId: options.runId,
-                agentId: options.selectedAgentId,
+                agentId: currentAgentId,
                 state: "completed",
                 output: assistantOutput,
                 finalMessageText: assistantOutput,
@@ -183,7 +198,7 @@ export async function* streamHarnessRun(options) {
                 result: {
                     threadId: options.threadId,
                     runId: options.runId,
-                    agentId: options.selectedAgentId,
+                    agentId: currentAgentId,
                     state: "failed",
                     output: runtimeFailure,
                     finalMessageText: runtimeFailure,
@@ -232,7 +247,7 @@ export async function* streamHarnessRun(options) {
                     ...actual,
                     threadId: options.threadId,
                     runId: options.runId,
-                    agentId: options.selectedAgentId,
+                    agentId: currentAgentId,
                 },
             };
             yield {
@@ -265,7 +280,7 @@ export async function* streamHarnessRun(options) {
                 result: {
                     threadId: options.threadId,
                     runId: options.runId,
-                    agentId: options.selectedAgentId,
+                    agentId: currentAgentId,
                     state: "failed",
                     output: runtimeFailure,
                     finalMessageText: runtimeFailure,

package/dist/runtime/harness/run/thread-records.js

@@ -20,6 +20,7 @@ export async function buildThreadInspectionRecord(input, threadId) {
     return {
         threadId,
         entryAgentId: meta.entryAgentId,
+        currentAgentId: threadSummary.currentAgentId,
         currentState: threadSummary.status,
         latestRunId,
         createdAt: meta.createdAt,

package/dist/runtime/harness/system/runtime-memory-sync.d.ts

@@ -0,0 +1,24 @@
+import type { HarnessEvent, HarnessEventProjection } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+import type { StoreLike } from "./store.js";
+export type ResolvedRuntimeMemorySyncConfig = {
+    enabled: true;
+    writeOnApprovalResolution: boolean;
+    writeOnRunCompletion: boolean;
+    backgroundConsolidation: boolean;
+    maxMessagesPerRun: number;
+};
+export declare function readRuntimeMemorySyncConfig(runtimeMemory: Record<string, unknown> | undefined): ResolvedRuntimeMemorySyncConfig | undefined;
+export declare class RuntimeMemorySync implements HarnessEventProjection {
+    private readonly persistence;
+    readonly store: StoreLike;
+    private readonly config;
+    private readonly pending;
+    private syncChain;
+    readonly name = "runtime-memory-sync";
+    constructor(persistence: RuntimePersistence, store: StoreLike, config: ResolvedRuntimeMemorySyncConfig);
+    shouldHandle(event: HarnessEvent): boolean;
+    handleEvent(event: HarnessEvent): Promise<void>;
+    private syncRun;
+    close(): Promise<void>;
+}

package/dist/runtime/harness/system/runtime-memory-sync.js

@@ -0,0 +1,193 @@
+import { extractMessageText } from "../../../utils/message-content.js";
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function asPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+function excerpt(message) {
+    if (!message?.content) {
+        return "(none)";
+    }
+    const normalized = extractMessageText(message.content).replace(/\s+/g, " ").trim();
+    return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
+}
+function formatMessageSection(title, messages) {
+    const lines = [`## ${title}`, ""];
+    if (messages.length === 0) {
+        lines.push("(none)", "");
+        return lines;
+    }
+    for (const message of messages) {
+        lines.push(`- ${excerpt(message)}`);
+    }
+    lines.push("");
+    return lines;
+}
+function formatApprovalSection(approvals) {
+    const lines = ["## Approval Snapshot", ""];
+    if (approvals.length === 0) {
+        lines.push("(none)", "");
+        return lines;
+    }
+    for (const approval of approvals) {
+        lines.push(`- ${approval.approvalId}: ${approval.toolName} (${approval.status})`);
+    }
+    lines.push("");
+    return lines;
+}
+function renderRunSummaryMarkdown(input) {
+    const userMessages = input.messages.filter((message) => message.role === "user").slice(-3);
+    const assistantMessages = input.messages.filter((message) => message.role === "assistant").slice(-3);
+    return [
+        "# Run Memory Summary",
+        "",
+        `- thread_id: ${input.thread.threadId}`,
+        `- run_id: ${input.runId}`,
+        `- agent_id: ${input.agentId}`,
+        `- status: ${input.thread.status}`,
+        `- trigger: ${input.trigger}`,
+        `- captured_at: ${input.capturedAt}`,
+        "",
+        ...formatMessageSection("Recent User Messages", userMessages),
+        ...formatMessageSection("Recent Assistant Messages", assistantMessages),
+        ...formatApprovalSection(input.approvals),
+    ].join("\n");
+}
+function renderThreadDigestMarkdown(input) {
+    const latestUser = input.messages.filter((message) => message.role === "user").at(-1);
+    const latestAssistant = input.messages.filter((message) => message.role === "assistant").at(-1);
+    return [
+        "# Durable Thread Digest",
+        "",
+        `- thread_id: ${input.thread.threadId}`,
+        `- latest_run_id: ${input.runId}`,
+        `- status: ${input.thread.status}`,
+        `- last_memory_trigger: ${input.trigger}`,
+        `- updated_at: ${input.capturedAt}`,
+        "",
+        "## Latest Durable User Context",
+        excerpt(latestUser),
+        "",
+        "## Latest Durable Assistant Context",
+        excerpt(latestAssistant),
+        "",
+    ].join("\n");
+}
+const RUNTIME_MEMORY_EVENT_TYPES = new Set(["run.state.changed", "approval.resolved"]);
+export function readRuntimeMemorySyncConfig(runtimeMemory) {
+    if (runtimeMemory?.enabled !== true) {
+        return undefined;
+    }
+    const ingestion = asRecord(runtimeMemory.ingestion);
+    const writeOnApprovalResolution = asBoolean(ingestion?.writeOnApprovalResolution) ?? true;
+    const writeOnRunCompletion = asBoolean(ingestion?.writeOnRunCompletion) ?? true;
+    if (!writeOnApprovalResolution && !writeOnRunCompletion) {
+        return undefined;
+    }
+    return {
+        enabled: true,
+        writeOnApprovalResolution,
+        writeOnRunCompletion,
+        backgroundConsolidation: asBoolean(ingestion?.backgroundConsolidation) ?? true,
+        maxMessagesPerRun: asPositiveInteger(ingestion?.maxMessagesPerRun) ?? 40,
+    };
+}
+export class RuntimeMemorySync {
+    persistence;
+    store;
+    config;
+    pending = new Set();
+    syncChain = Promise.resolve();
+    name = "runtime-memory-sync";
+    constructor(persistence, store, config) {
+        this.persistence = persistence;
+        this.store = store;
+        this.config = config;
+    }
+    shouldHandle(event) {
+        if (!RUNTIME_MEMORY_EVENT_TYPES.has(event.eventType)) {
+            return false;
+        }
+        if (event.eventType === "approval.resolved") {
+            return this.config.writeOnApprovalResolution;
+        }
+        return this.config.writeOnRunCompletion && event.payload.state === "completed";
+    }
+    async handleEvent(event) {
+        if (!this.shouldHandle(event)) {
+            return;
+        }
+        const trigger = event.eventType === "approval.resolved" ? "approval.resolved" : "run.completed";
+        const task = this.syncChain
+            .then(() => this.syncRun(event.threadId, event.runId, trigger, event.timestamp))
+            .catch(() => {
+            // Fail open: runtime memory sync must not break the hot path.
+        });
+        this.syncChain = task
+            .catch(() => {
+            // Fail open: runtime memory sync must not break the hot path.
+        })
+            .finally(() => {
+            this.pending.delete(task);
+        });
+        this.pending.add(task);
+    }
+    async syncRun(threadId, runId, trigger, capturedAt) {
+        const [thread, run, allMessages, approvals] = await Promise.all([
+            this.persistence.getSession(threadId),
+            this.persistence.getRun(runId),
+            this.persistence.listThreadMessages(threadId, this.config.maxMessagesPerRun),
+            this.persistence.getRunApprovals(threadId, runId),
+        ]);
+        if (!thread || !run) {
+            return;
+        }
+        const messages = allMessages.filter((message) => message.runId === runId);
+        if (messages.length === 0) {
+            return;
+        }
+        const agentId = run.agentId ?? thread.agentId;
+        const summaryMarkdown = renderRunSummaryMarkdown({
+            thread,
+            runId,
+            agentId,
+            trigger,
+            capturedAt,
+            messages,
+            approvals,
+        });
+        await Promise.all([
+            this.store.put(["memories", "runs", threadId], `${runId}.summary.md`, { content: `${summaryMarkdown}\n` }),
+            this.store.put(["memories", "runs", threadId], `${runId}.record.json`, {
+                kind: "summary",
+                scope: "thread",
+                threadId,
+                runId,
+                agentId,
+                trigger,
+                capturedAt,
+                status: thread.status,
+                messageCount: messages.length,
+                approvalCount: approvals.length,
+            }),
+        ]);
+        if (!this.config.backgroundConsolidation) {
+            return;
+        }
+        const digestMarkdown = renderThreadDigestMarkdown({
+            thread,
+            runId,
+            trigger,
+            capturedAt,
+            messages,
+        });
+        await this.store.put(["memories", "threads", threadId], "durable-summary.md", { content: `${digestMarkdown}\n` });
+    }
+    async close() {
+        await Promise.allSettled(Array.from(this.pending));
+    }
+}

package/dist/runtime/harness.d.ts

@@ -23,6 +23,8 @@ export declare class AgentHarnessRuntime {
     private readonly routingDefaultAgentId?;
     private readonly threadMemorySync;
     private readonly unregisterThreadMemorySync;
+    private readonly runtimeMemorySync;
+    private readonly unregisterRuntimeMemorySync;
     private readonly mem0IngestionSync;
     private readonly unregisterMem0IngestionSync;
     private readonly resolvedRuntimeAdapterOptions;

package/dist/runtime/harness.js

@@ -7,6 +7,7 @@ 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 { RuntimeMemorySync, readRuntimeMemorySyncConfig } from "./harness/system/runtime-memory-sync.js";
 import { FileBackedStore } from "./harness/system/store.js";
 import { HealthMonitor, readHealthMonitorConfig, } from "./harness/system/health-monitor.js";
 import { normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, } from "./harness/run/helpers.js";
@@ -58,6 +59,8 @@ export class AgentHarnessRuntime {
     routingDefaultAgentId;
     threadMemorySync;
     unregisterThreadMemorySync;
+    runtimeMemorySync;
+    unregisterRuntimeMemorySync;
     mem0IngestionSync;
     unregisterMem0IngestionSync;
     resolvedRuntimeAdapterOptions;
@@ -143,6 +146,15 @@ export class AgentHarnessRuntime {
             this.threadMemorySync = null;
             this.unregisterThreadMemorySync = () => { };
         }
+        const runtimeMemorySyncConfig = readRuntimeMemorySyncConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory);
+        if (runtimeMemorySyncConfig) {
+            this.runtimeMemorySync = new RuntimeMemorySync(this.persistence, this.runtimeMemoryStore, runtimeMemorySyncConfig);
+            this.unregisterRuntimeMemorySync = this.eventBus.registerProjection(this.runtimeMemorySync);
+        }
+        else {
+            this.runtimeMemorySync = null;
+            this.unregisterRuntimeMemorySync = () => { };
+        }
         const mem0RuntimeConfig = readMem0RuntimeConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory, this.workspace.workspaceRoot);
         if (mem0RuntimeConfig) {
             this.mem0IngestionSync = new Mem0IngestionSync(this.persistence, mem0RuntimeConfig, runRoot);
@@ -517,6 +529,7 @@ export class AgentHarnessRuntime {
             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),
             emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
         });
         for await (const item of stream) {
@@ -581,9 +594,11 @@ export class AgentHarnessRuntime {
         this.closed = true;
         await this.healthMonitor?.stop();
         this.unregisterThreadMemorySync();
+        this.unregisterRuntimeMemorySync();
         this.unregisterMem0IngestionSync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
         await this.threadMemorySync?.close();
+        await this.runtimeMemorySync?.close();
         await this.mem0IngestionSync?.close();
         await closeMcpClientsForWorkspace(this.workspace);
         this.initialized = false;

package/dist/runtime/maintenance/runtime-record-maintenance.js

@@ -91,6 +91,7 @@ export async function maintainSqliteRuntimeRecords(dbPath, config, nowMs = Date.
             "DELETE FROM artifacts WHERE thread_id = ?",
             "DELETE FROM approvals WHERE thread_id = ?",
             "DELETE FROM events WHERE thread_id = ?",
+            "DELETE FROM run_inspection WHERE thread_id = ?",
             "DELETE FROM run_queue WHERE thread_id = ?",
             "DELETE FROM run_requests WHERE thread_id = ?",
             "DELETE FROM recovery_intents WHERE thread_id = ?",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.138",
+  "version": "0.0.141",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",