@actiondock/core 2.17.0 → 2.19.0

package/dist/client/runs.d.ts

@@ -22,6 +22,13 @@ export declare function fetchRemoteRuns(serverUrl: string, token?: string, optio
     status?: string;
     actionId?: string;
     packageId?: string;
+    channel?: string;
+    view?: string;
+    since?: string;
+    until?: string;
+    rootRunId?: string;
+    parentRunId?: string;
+    withTotal?: boolean;
     intent?: string;
     limit?: number;
     offset?: number;
@@ -30,6 +37,8 @@ export declare function fetchRemoteRuns(serverUrl: string, token?: string, optio
     ok: boolean;
     total?: number;
     items: RunRecord[];
+    limit?: number;
+    offset?: number;
 }>;
 /**
  * 清空远端运行记录（可按包、Action、状态、保留时长、保留数量过滤清除范围）。

package/dist/client/runs.js

@@ -35,6 +35,13 @@ export async function fetchRemoteRuns(serverUrl, token, options) {
         status: options?.status,
         actionId: options?.actionId,
         packageId: options?.packageId,
+        channel: options?.channel,
+        view: options?.view,
+        since: options?.since,
+        until: options?.until,
+        rootRunId: options?.rootRunId,
+        parentRunId: options?.parentRunId,
+        withTotal: options?.withTotal ? true : undefined,
         intent: options?.intent,
         limit: options?.limit,
         offset: options?.offset,

package/dist/host/host.js

@@ -906,6 +906,12 @@ export class DefaultActionDockHost {
                     const batch = await runtime.listRuns({
                         actionId: query.actionId,
                         status: query.status,
+                        channel: query.channel,
+                        view: query.view,
+                        since: query.since,
+                        until: query.until,
+                        rootRunId: query.rootRunId,
+                        parentRunId: query.parentRunId,
                         requestIds: query.requestIds,
                         limit: BATCH_SIZE,
                         offset: batchOffset,
@@ -921,8 +927,21 @@ export class DefaultActionDockHost {
                         ...r,
                         packageId: r.packageId || runtime.packageId,
                     }));
-                    const filtered = filterByIntent(normalized, intentStr, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
-                    matchedRecords.push(...filtered);
+                    let filtered = normalized;
+                    if (query.channel)
+                        filtered = filtered.filter((r) => r.origin?.channel === query.channel);
+                    if (query.view)
+                        filtered = filtered.filter((r) => r.origin?.viewName === query.view);
+                    if (query.since)
+                        filtered = filtered.filter((r) => r.startedAt >= query.since);
+                    if (query.until)
+                        filtered = filtered.filter((r) => r.startedAt <= query.until);
+                    if (query.rootRunId)
+                        filtered = filtered.filter((r) => r.rootRunId === query.rootRunId);
+                    if (query.parentRunId)
+                        filtered = filtered.filter((r) => r.parentRunId === query.parentRunId);
+                    const intentMatched = filterByIntent(filtered, intentStr, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
+                    matchedRecords.push(...intentMatched);
                     if (matchedRecords.length >= neededCount) {
                         break;
                     }
@@ -944,6 +963,12 @@ export class DefaultActionDockHost {
                         const batch = await runtime.listRuns({
                             actionId: query.actionId,
                             status: query.status,
+                            channel: query.channel,
+                            view: query.view,
+                            since: query.since,
+                            until: query.until,
+                            rootRunId: query.rootRunId,
+                            parentRunId: query.parentRunId,
                             requestIds: query.requestIds,
                             limit: BATCH_SIZE,
                             offset: batchOffset,
@@ -959,8 +984,21 @@ export class DefaultActionDockHost {
                             ...r,
                             packageId: r.packageId || runtime.packageId,
                         }));
-                        const filtered = filterByIntent(normalized, intentStr, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
-                        matchedRecords.push(...filtered);
+                        let filtered = normalized;
+                        if (query.channel)
+                            filtered = filtered.filter((r) => r.origin?.channel === query.channel);
+                        if (query.view)
+                            filtered = filtered.filter((r) => r.origin?.viewName === query.view);
+                        if (query.since)
+                            filtered = filtered.filter((r) => r.startedAt >= query.since);
+                        if (query.until)
+                            filtered = filtered.filter((r) => r.startedAt <= query.until);
+                        if (query.rootRunId)
+                            filtered = filtered.filter((r) => r.rootRunId === query.rootRunId);
+                        if (query.parentRunId)
+                            filtered = filtered.filter((r) => r.parentRunId === query.parentRunId);
+                        const intentMatched = filterByIntent(filtered, intentStr, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
+                        matchedRecords.push(...intentMatched);
                         if (batch.length < BATCH_SIZE) {
                             break;
                         }
@@ -1043,6 +1081,12 @@ export class DefaultActionDockHost {
                     const batch = await runtime.listRuns({
                         actionId: query.actionId,
                         status: query.status,
+                        channel: query.channel,
+                        view: query.view,
+                        since: query.since,
+                        until: query.until,
+                        rootRunId: query.rootRunId,
+                        parentRunId: query.parentRunId,
                         requestIds: query.requestIds,
                         limit: BATCH_SIZE,
                         offset: batchOffset,
@@ -1058,8 +1102,21 @@ export class DefaultActionDockHost {
                         ...r,
                         packageId: r.packageId || runtime.packageId,
                     }));
-                    const filtered = filterByIntent(normalized, intentStr, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
-                    count += filtered.length;
+                    let filtered = normalized;
+                    if (query.channel)
+                        filtered = filtered.filter((r) => r.origin?.channel === query.channel);
+                    if (query.view)
+                        filtered = filtered.filter((r) => r.origin?.viewName === query.view);
+                    if (query.since)
+                        filtered = filtered.filter((r) => r.startedAt >= query.since);
+                    if (query.until)
+                        filtered = filtered.filter((r) => r.startedAt <= query.until);
+                    if (query.rootRunId)
+                        filtered = filtered.filter((r) => r.rootRunId === query.rootRunId);
+                    if (query.parentRunId)
+                        filtered = filtered.filter((r) => r.parentRunId === query.parentRunId);
+                    const intentMatched = filterByIntent(filtered, intentStr, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
+                    count += intentMatched.length;
                     if (batch.length < BATCH_SIZE) {
                         break;
                     }
@@ -1079,6 +1136,12 @@ export class DefaultActionDockHost {
                 const all = await runtime.listRuns({
                     actionId: query?.actionId,
                     status: query?.status,
+                    channel: query?.channel,
+                    view: query?.view,
+                    since: query?.since,
+                    until: query?.until,
+                    rootRunId: query?.rootRunId,
+                    parentRunId: query?.parentRunId,
                     requestIds: query?.requestIds,
                     limit: 100_000,
                     signal: effectiveSignal,
@@ -1086,7 +1149,20 @@ export class DefaultActionDockHost {
                 if (effectiveSignal?.aborted) {
                     throw createAbortError(effectiveSignal.reason);
                 }
-                total += all.length;
+                let filtered = all;
+                if (query?.channel)
+                    filtered = filtered.filter((r) => r.origin?.channel === query.channel);
+                if (query?.view)
+                    filtered = filtered.filter((r) => r.origin?.viewName === query.view);
+                if (query?.since)
+                    filtered = filtered.filter((r) => r.startedAt >= query.since);
+                if (query?.until)
+                    filtered = filtered.filter((r) => r.startedAt <= query.until);
+                if (query?.rootRunId)
+                    filtered = filtered.filter((r) => r.rootRunId === query.rootRunId);
+                if (query?.parentRunId)
+                    filtered = filtered.filter((r) => r.parentRunId === query.parentRunId);
+                total += filtered.length;
             }
         }
         return total;

package/dist/package/runtime.js

@@ -851,13 +851,31 @@ export class DefaultPackageRuntime {
             if (typeof storage.listRunsByRequestIds !== "function") {
                 return [];
             }
-            let records = storage.listRunsByRequestIds(options.requestIds);
+            let records = storage.listRunsByRequestIds(options.requestIds, options);
             if (options.actionId) {
                 records = records.filter((r) => r.actionId === options.actionId);
             }
             if (options.status) {
                 records = records.filter((r) => r.status === options.status);
             }
+            if (options.channel) {
+                records = records.filter((r) => r.origin?.channel === options.channel);
+            }
+            if (options.view) {
+                records = records.filter((r) => r.origin?.viewName === options.view);
+            }
+            if (options.since) {
+                records = records.filter((r) => r.startedAt >= options.since);
+            }
+            if (options.until) {
+                records = records.filter((r) => r.startedAt <= options.until);
+            }
+            if (options.rootRunId) {
+                records = records.filter((r) => r.rootRunId === options.rootRunId);
+            }
+            if (options.parentRunId) {
+                records = records.filter((r) => r.parentRunId === options.parentRunId);
+            }
             records.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
             if (typeof options.offset === "number" && options.offset > 0) {
                 records = records.slice(options.offset);
@@ -870,6 +888,12 @@ export class DefaultPackageRuntime {
         const records = storage.listRuns({
             actionId: options?.actionId,
             status: options?.status,
+            channel: options?.channel,
+            view: options?.view,
+            since: options?.since,
+            until: options?.until,
+            rootRunId: options?.rootRunId,
+            parentRunId: options?.parentRunId,
             limit: options?.limit,
             offset: options?.offset,
         });
@@ -897,18 +921,42 @@ export class DefaultPackageRuntime {
             return storage.countRuns({
                 actionId: options?.actionId,
                 status: options?.status,
+                channel: options?.channel,
+                view: options?.view,
+                since: options?.since,
+                until: options?.until,
+                rootRunId: options?.rootRunId,
+                parentRunId: options?.parentRunId,
                 requestIds: options?.requestIds,
             });
         }
         if (options?.requestIds && options.requestIds.length > 0) {
             if (typeof storage.listRunsByRequestIds === "function") {
-                let records = storage.listRunsByRequestIds(options.requestIds);
+                let records = storage.listRunsByRequestIds(options.requestIds, options);
                 if (options.actionId) {
                     records = records.filter((r) => r.actionId === options.actionId);
                 }
                 if (options.status) {
                     records = records.filter((r) => r.status === options.status);
                 }
+                if (options.channel) {
+                    records = records.filter((r) => r.origin?.channel === options.channel);
+                }
+                if (options.view) {
+                    records = records.filter((r) => r.origin?.viewName === options.view);
+                }
+                if (options.since) {
+                    records = records.filter((r) => r.startedAt >= options.since);
+                }
+                if (options.until) {
+                    records = records.filter((r) => r.startedAt <= options.until);
+                }
+                if (options.rootRunId) {
+                    records = records.filter((r) => r.rootRunId === options.rootRunId);
+                }
+                if (options.parentRunId) {
+                    records = records.filter((r) => r.parentRunId === options.parentRunId);
+                }
                 return records.length;
             }
             return 0;
@@ -916,9 +964,32 @@ export class DefaultPackageRuntime {
         const records = storage.listRuns({
             actionId: options?.actionId,
             status: options?.status,
+            channel: options?.channel,
+            view: options?.view,
+            since: options?.since,
+            until: options?.until,
+            rootRunId: options?.rootRunId,
+            parentRunId: options?.parentRunId,
             limit: 100_000,
         });
-        return records.length;
+        let filtered = records;
+        if (options?.actionId)
+            filtered = filtered.filter((r) => r.actionId === options.actionId);
+        if (options?.status)
+            filtered = filtered.filter((r) => r.status === options.status);
+        if (options?.channel)
+            filtered = filtered.filter((r) => r.origin?.channel === options.channel);
+        if (options?.view)
+            filtered = filtered.filter((r) => r.origin?.viewName === options.view);
+        if (options?.since)
+            filtered = filtered.filter((r) => r.startedAt >= options.since);
+        if (options?.until)
+            filtered = filtered.filter((r) => r.startedAt <= options.until);
+        if (options?.rootRunId)
+            filtered = filtered.filter((r) => r.rootRunId === options.rootRunId);
+        if (options?.parentRunId)
+            filtered = filtered.filter((r) => r.parentRunId === options.parentRunId);
+        return filtered.length;
     }
     async clearRuns(options) {
         this.assertOpen();

package/dist/project/init.js

@@ -86,10 +86,10 @@ export function initProject(targetDir, options = {}) {
             node: ">=24.12.0",
         },
         dependencies: {
-            "@actiondock/sdk": "^2.17.0",
+            "@actiondock/sdk": "^2.19.0",
         },
         devDependencies: {
-            "@actiondock/testing": "^2.17.0",
+            "@actiondock/testing": "^2.19.0",
             "@types/node": "^22.13.0",
             "tsx": "^4.19.0",
             "typescript": "^5.7.0",

package/dist/server/routes/runs.js

@@ -16,6 +16,13 @@ export async function handleRunsRoutes(ctx) {
             const status = url.searchParams.get("status") || undefined;
             const actionId = url.searchParams.get("actionId") || undefined;
             const packageId = url.searchParams.get("packageId") || undefined;
+            const channel = url.searchParams.get("channel") || undefined;
+            const view = url.searchParams.get("view") || undefined;
+            const since = url.searchParams.get("since") || undefined;
+            const until = url.searchParams.get("until") || undefined;
+            const rootRunId = url.searchParams.get("rootRunId") || undefined;
+            const parentRunId = url.searchParams.get("parentRunId") || undefined;
+            const withTotal = url.searchParams.get("withTotal") === "true";
             const intent = url.searchParams.get("intent") || undefined;
             // requestId 反查：支持 requestId 与 requestIds 重复查询参数，将每一个参数值作为原样字符串保存
             const requestIds = [
@@ -69,6 +76,13 @@ export async function handleRunsRoutes(ctx) {
                 actionId,
                 status,
                 packageId,
+                channel,
+                view,
+                since,
+                until,
+                rootRunId,
+                parentRunId,
+                withTotal,
                 intent,
                 requestIds: requestIds.length > 0 ? requestIds : undefined,
                 signal: req.signal,
@@ -153,6 +167,8 @@ export async function handleRunsRoutes(ctx) {
             const responseData = {
                 ok: true,
                 items: runs,
+                limit,
+                offset,
             };
             if (typeof total === "number") {
                 responseData.total = total;

package/dist/server/server.d.ts

@@ -1,3 +1,4 @@
+import type { ActionDockService } from "../service/types.js";
 import type { ActionDockServerInstance, CoreHttpServerInstance, ServerOptions, ServerTlsOptions } from "./types.js";
 /**
  * 规范化主机地址用于拼接 URL。
@@ -12,4 +13,4 @@ export declare function launchHttpServer(port: number, host: string, fetchHandle
  * 启动 ActionDock 原生轻量级 HTTP 服务端。
  * 面向 ActionDockService 服务端口，负责中间件流转、认证拦截与路由分发。
  */
-export declare function startActionDockServer(options?: ServerOptions): Promise<ActionDockServerInstance>;
+export declare function startActionDockServer(arg1?: ServerOptions | ActionDockService, arg2?: ServerOptions): Promise<ActionDockServerInstance>;

package/dist/server/server.js

@@ -40,8 +40,19 @@ export async function launchHttpServer(port, host, fetchHandler, tls) {
  * 启动 ActionDock 原生轻量级 HTTP 服务端。
  * 面向 ActionDockService 服务端口，负责中间件流转、认证拦截与路由分发。
  */
-export async function startActionDockServer(options = {}) {
-    const hostString = options.hostname ?? options.host ?? "127.0.0.1";
+export async function startActionDockServer(arg1, arg2) {
+    let options;
+    if (arg1 && typeof arg1 === "object" && ("discovery" in arg1 || "execution" in arg1 || "runs" in arg1)) {
+        options = { ...(arg2 || {}), service: arg1 };
+    }
+    else {
+        options = arg1 || {};
+    }
+    const hostString = typeof options.hostname === "string"
+        ? options.hostname
+        : typeof options.host === "string"
+            ? options.host
+            : "127.0.0.1";
     const port = options.port ?? 5177;
     const host = hostString;
     const token = options.token;

package/dist/service/remote.js

@@ -259,6 +259,13 @@ export class RemoteActionDockService {
                             packageId: query?.packageId,
                             actionId: query?.actionId,
                             status: query?.status,
+                            channel: query?.channel,
+                            view: query?.view,
+                            since: query?.since,
+                            until: query?.until,
+                            rootRunId: query?.rootRunId,
+                            parentRunId: query?.parentRunId,
+                            withTotal: query?.withTotal,
                             intent: query?.intent,
                             limit: batchLimit,
                             offset,
@@ -307,6 +314,13 @@ export class RemoteActionDockService {
                         packageId: query?.packageId,
                         actionId: query?.actionId,
                         status: query?.status,
+                        channel: query?.channel,
+                        view: query?.view,
+                        since: query?.since,
+                        until: query?.until,
+                        rootRunId: query?.rootRunId,
+                        parentRunId: query?.parentRunId,
+                        withTotal: true,
                         intent: query?.intent,
                         limit: 1,
                         offset: 0,

package/dist/service/types.d.ts

@@ -72,6 +72,18 @@ export interface ListRunsOptions {
     actionId?: string;
     /** 运行终态状态筛选 */
     status?: string;
+    /** 运行通道筛选（如 http、mcp） */
+    channel?: string;
+    /** 服务视图名称筛选（如 default、admin） */
+    view?: string;
+    /** 起始时间筛选（UTC ISO 8601 或时间戳字符串，匹配 startedAt >= since） */
+    since?: string;
+    /** 截止时间筛选（UTC ISO 8601 或时间戳字符串，匹配 startedAt <= until） */
+    until?: string;
+    /** 根运行标识筛选 */
+    rootRunId?: string;
+    /** 父运行标识筛选 */
+    parentRunId?: string;
     /** 模糊意图检索模式 */
     intent?: string;
     /** 幂等请求标识集合（经 idempotency_keys 反查关联运行记录） */
@@ -80,6 +92,8 @@ export interface ListRunsOptions {
     offset?: number;
     /** 最大返回记录条数限制 */
     limit?: number;
+    /** 是否需要附带总数统计 */
+    withTotal?: boolean;
     /** 取消信号，用于中止读取请求 */
     signal?: AbortSignal;
     /** 包白名单过滤集合（可选） */

package/dist/storage/sqlite-runs.d.ts

@@ -1,5 +1,5 @@
 import type { Logger, RuntimeError, RunRecord } from "@actiondock/sdk";
-import type { SqliteDriver, TerminalRunStatus, RunsRetentionPolicy, IdempotencyRecord, IdempotencyCheckResult } from "./types.js";
+import type { SqliteDriver, TerminalRunStatus, RunsRetentionPolicy, IdempotencyRecord, IdempotencyCheckResult, RunsQueryFilterOptions } from "./types.js";
 import type { Clock } from "./clock.js";
 import { type ProcessLivenessProbe } from "./run-liveness.js";
 export declare class SqliteRunsStore {
@@ -52,28 +52,16 @@ export declare class SqliteRunsStore {
      * 查询单条运行记录并补齐幂等请求标识关联（详情路径专用）。
      */
     getRunWithRequestId(id: string, isClosed: boolean): RunRecord | null;
-    listRuns(options?: {
-        actionId?: string;
-        status?: string;
-        limit?: number;
-        offset?: number;
-    }): RunRecord[];
+    listRuns(options?: RunsQueryFilterOptions): RunRecord[];
     /**
      * 统计符合过滤条件的真实运行记录总数。
      * 支持按 actionId、status 以及包含 requestIds 的反查场景统计总数。
      */
-    countRuns(options?: {
-        actionId?: string;
-        status?: string;
-        requestIds?: string[];
-    }, isClosed?: boolean): number;
+    countRuns(options?: RunsQueryFilterOptions, isClosed?: boolean): number;
     /**
      * 按客户端幂等请求标识反查关联运行记录总数。
      */
-    countRunsByRequestIds(isClosed: boolean, requestIds: string[], options?: {
-        actionId?: string;
-        status?: string;
-    }): number;
+    countRunsByRequestIds(isClosed: boolean, requestIds: string[], options?: RunsQueryFilterOptions): number;
     /**
      * 构造 IN (…) 占位符列表。
      */
@@ -85,7 +73,7 @@ export declare class SqliteRunsStore {
      * 当前包，保证多包共库（全局库）时不越界读取其他包的运行记录。
      * 不按 owner_id 过滤：写入方与查询方分属不同宿主进程，ownerId 必然不同。
      */
-    listRunsByRequestIds(isClosed: boolean, requestIds: string[]): RunRecord[];
+    listRunsByRequestIds(isClosed: boolean, requestIds: string[], options?: RunsQueryFilterOptions): RunRecord[];
     /**
      * 反查当前包范围内运行记录关联的幂等请求标识。
      *

package/dist/storage/sqlite-runs.js

@@ -244,6 +244,30 @@ export class SqliteRunsStore {
             sql += " AND status = ?";
             params.push(options.status);
         }
+        if (options.channel) {
+            sql += " AND json_extract(origin_json, '$.channel') = ?";
+            params.push(options.channel);
+        }
+        if (options.view) {
+            sql += " AND json_extract(origin_json, '$.viewName') = ?";
+            params.push(options.view);
+        }
+        if (options.since) {
+            sql += " AND started_at >= ?";
+            params.push(options.since);
+        }
+        if (options.until) {
+            sql += " AND started_at <= ?";
+            params.push(options.until);
+        }
+        if (options.rootRunId) {
+            sql += " AND root_run_id = ?";
+            params.push(options.rootRunId);
+        }
+        if (options.parentRunId) {
+            sql += " AND parent_run_id = ?";
+            params.push(options.parentRunId);
+        }
         sql += " ORDER BY started_at DESC LIMIT ?";
         params.push(limit);
         if (typeof options.offset === "number" && options.offset > 0) {
@@ -281,6 +305,30 @@ export class SqliteRunsStore {
                 sql += " AND runs.status = ?";
                 params.push(options.status);
             }
+            if (options.channel) {
+                sql += " AND json_extract(runs.origin_json, '$.channel') = ?";
+                params.push(options.channel);
+            }
+            if (options.view) {
+                sql += " AND json_extract(runs.origin_json, '$.viewName') = ?";
+                params.push(options.view);
+            }
+            if (options.since) {
+                sql += " AND runs.started_at >= ?";
+                params.push(options.since);
+            }
+            if (options.until) {
+                sql += " AND runs.started_at <= ?";
+                params.push(options.until);
+            }
+            if (options.rootRunId) {
+                sql += " AND runs.root_run_id = ?";
+                params.push(options.rootRunId);
+            }
+            if (options.parentRunId) {
+                sql += " AND runs.parent_run_id = ?";
+                params.push(options.parentRunId);
+            }
             const stmt = this.getStatement(sql);
             const row = stmt.get(...params);
             return row?.count ?? 0;
@@ -295,6 +343,30 @@ export class SqliteRunsStore {
             sql += " AND status = ?";
             params.push(options.status);
         }
+        if (options.channel) {
+            sql += " AND json_extract(origin_json, '$.channel') = ?";
+            params.push(options.channel);
+        }
+        if (options.view) {
+            sql += " AND json_extract(origin_json, '$.viewName') = ?";
+            params.push(options.view);
+        }
+        if (options.since) {
+            sql += " AND started_at >= ?";
+            params.push(options.since);
+        }
+        if (options.until) {
+            sql += " AND started_at <= ?";
+            params.push(options.until);
+        }
+        if (options.rootRunId) {
+            sql += " AND root_run_id = ?";
+            params.push(options.rootRunId);
+        }
+        if (options.parentRunId) {
+            sql += " AND parent_run_id = ?";
+            params.push(options.parentRunId);
+        }
         const stmt = this.getStatement(sql);
         const row = stmt.get(...params);
         return row?.count ?? 0;
@@ -318,23 +390,56 @@ export class SqliteRunsStore {
      * 当前包，保证多包共库（全局库）时不越界读取其他包的运行记录。
      * 不按 owner_id 过滤：写入方与查询方分属不同宿主进程，ownerId 必然不同。
      */
-    listRunsByRequestIds(isClosed, requestIds) {
+    listRunsByRequestIds(isClosed, requestIds, options = {}) {
         if (isClosed || requestIds.length === 0)
             return [];
         const uniqueIds = Array.from(new Set(requestIds.filter((id) => typeof id === "string" && id.length > 0)));
         if (uniqueIds.length === 0)
             return [];
-        const sql = `
+        let sql = `
       SELECT runs.*, ik.request_id AS request_id
       FROM runs
       INNER JOIN idempotency_keys AS ik ON ik.run_id = runs.id
       WHERE runs.package_id = ?
         AND ik.request_id IN (${SqliteRunsStore.placeholders(uniqueIds.length)})
-      ORDER BY runs.started_at DESC
     `;
+        const params = [this.packageId, ...uniqueIds];
+        if (options.actionId) {
+            sql += " AND runs.action_id = ?";
+            params.push(options.actionId);
+        }
+        if (options.status) {
+            sql += " AND runs.status = ?";
+            params.push(options.status);
+        }
+        if (options.channel) {
+            sql += " AND json_extract(runs.origin_json, '$.channel') = ?";
+            params.push(options.channel);
+        }
+        if (options.view) {
+            sql += " AND json_extract(runs.origin_json, '$.viewName') = ?";
+            params.push(options.view);
+        }
+        if (options.since) {
+            sql += " AND runs.started_at >= ?";
+            params.push(options.since);
+        }
+        if (options.until) {
+            sql += " AND runs.started_at <= ?";
+            params.push(options.until);
+        }
+        if (options.rootRunId) {
+            sql += " AND runs.root_run_id = ?";
+            params.push(options.rootRunId);
+        }
+        if (options.parentRunId) {
+            sql += " AND runs.parent_run_id = ?";
+            params.push(options.parentRunId);
+        }
+        sql += " ORDER BY runs.started_at DESC";
         const stmt = this.getStatement(sql);
-        const rows = stmt.all(this.packageId, ...uniqueIds);
-        const records = rows.map((r) => this.mapRunRecord(r));
+        const rows = stmt.all(...params);
+        let records = rows.map((r) => this.mapRunRecord(r));
         // requestId 来自联查列，直接补齐（mapRunRecord 无法从 runs 行还原）
         const requestIdByRunId = new Map();
         for (const row of rows) {
@@ -347,6 +452,23 @@ export class SqliteRunsStore {
             if (requestId)
                 record.requestId = requestId;
         }
+        // 内存过滤适配
+        if (options.actionId)
+            records = records.filter((r) => r.actionId === options.actionId);
+        if (options.status)
+            records = records.filter((r) => r.status === options.status);
+        if (options.channel)
+            records = records.filter((r) => r.origin?.channel === options.channel);
+        if (options.view)
+            records = records.filter((r) => r.origin?.viewName === options.view);
+        if (options.since)
+            records = records.filter((r) => r.startedAt >= options.since);
+        if (options.until)
+            records = records.filter((r) => r.startedAt <= options.until);
+        if (options.rootRunId)
+            records = records.filter((r) => r.rootRunId === options.rootRunId);
+        if (options.parentRunId)
+            records = records.filter((r) => r.parentRunId === options.parentRunId);
         return records;
     }
     /**

package/dist/storage/sqlite.d.ts

@@ -1,5 +1,5 @@
 import { decodeStateKey, encodeStateKey, escapeStateSegment, unescapeStateSegment, type Logger, type RuntimeError, type RunRecord } from "@actiondock/sdk";
-import { type IdempotencyCheckResult, type IdempotencyRecord, type RunsRetentionPolicy, type RuntimeStorage, type StateEntry, type StorageOptions, type TerminalRunStatus } from "./types.js";
+import { type IdempotencyCheckResult, type IdempotencyRecord, type RunsQueryFilterOptions, type RunsRetentionPolicy, type RuntimeStorage, type StateEntry, type StorageOptions, type TerminalRunStatus } from "./types.js";
 export { decodeStateKey, encodeStateKey, escapeStateSegment, unescapeStateSegment, };
 export interface SqliteStorageOptions extends StorageOptions {
     logger?: Logger;
@@ -48,17 +48,8 @@ export declare class SqliteRuntimeStorage implements RuntimeStorage {
     createRun(record: RunRecord | any): void;
     updateRun(id: string, status: TerminalRunStatus, output?: unknown, error?: RuntimeError, finishedAt?: string): void;
     getRun(id: string): RunRecord | null;
-    listRuns(options?: {
-        actionId?: string;
-        status?: string;
-        limit?: number;
-        offset?: number;
-    }): RunRecord[];
-    countRuns(options?: {
-        actionId?: string;
-        status?: string;
-        requestIds?: string[];
-    }): number;
+    listRuns(options?: RunsQueryFilterOptions): RunRecord[];
+    countRuns(options?: RunsQueryFilterOptions): number;
     clearRuns(options?: {
         actionId?: string;
         status?: string;
@@ -69,11 +60,8 @@ export declare class SqliteRuntimeStorage implements RuntimeStorage {
     touchRunHeartbeat(runIds: string[]): number;
     checkAndRecordIdempotency(record: IdempotencyRecord): IdempotencyCheckResult;
     getIdempotencyRecord(ownerId: string, actionRef: string, requestId: string): IdempotencyRecord | undefined;
-    listRunsByRequestIds(requestIds: string[]): RunRecord[];
-    countRunsByRequestIds(requestIds: string[], options?: {
-        actionId?: string;
-        status?: string;
-    }): number;
+    listRunsByRequestIds(requestIds: string[], options?: RunsQueryFilterOptions): RunRecord[];
+    countRunsByRequestIds(requestIds: string[], options?: RunsQueryFilterOptions): number;
     getRunRequestIds(runIds: string[]): Record<string, string>;
     getRunWithRequestId(id: string): RunRecord | null;
     appendEvent(eventType: string, payload: unknown): void;

package/dist/storage/sqlite.js

@@ -159,8 +159,8 @@ export class SqliteRuntimeStorage {
     getIdempotencyRecord(ownerId, actionRef, requestId) {
         return this.runsStore.getIdempotencyRecord(this.isClosed, ownerId, actionRef, requestId);
     }
-    listRunsByRequestIds(requestIds) {
-        return this.runsStore.listRunsByRequestIds(this.isClosed, requestIds);
+    listRunsByRequestIds(requestIds, options = {}) {
+        return this.runsStore.listRunsByRequestIds(this.isClosed, requestIds, options);
     }
     countRunsByRequestIds(requestIds, options = {}) {
         return this.runsStore.countRunsByRequestIds(this.isClosed, requestIds, options);

package/dist/storage/types.d.ts

@@ -32,6 +32,33 @@ export interface RunsRetentionPolicy {
     /** 最小保底保留终态记录数（默认 50，防止全清空） */
     minRetainRuns?: number;
 }
+/**
+ * 运行记录通用检索与统计过滤选项。
+ */
+export interface RunsQueryFilterOptions {
+    /** 目标动作标识筛选 */
+    actionId?: string;
+    /** 运行生命周期状态筛选 */
+    status?: string;
+    /** 运行通道筛选（如 http、mcp） */
+    channel?: string;
+    /** 服务视图名称筛选（如 default、admin） */
+    view?: string;
+    /** 起始时间筛选（匹配 started_at >= since） */
+    since?: string;
+    /** 截止时间筛选（匹配 started_at <= until） */
+    until?: string;
+    /** 根运行标识筛选 */
+    rootRunId?: string;
+    /** 父运行标识筛选 */
+    parentRunId?: string;
+    /** 最大返回记录条数限制 */
+    limit?: number;
+    /** 偏移游标条数（跳过的记录数） */
+    offset?: number;
+    /** 幂等请求标识列表（经 idempotency_keys 反查） */
+    requestIds?: string[];
+}
 /**
  * SQLite 基础参数值类型。
  */
@@ -196,18 +223,9 @@ export interface RuntimeStorage {
     createRun(record: RunRecord): void;
     updateRun(id: string, status: TerminalRunStatus, output?: unknown, error?: RuntimeError, finishedAt?: string): void;
     getRun(id: string): RunRecord | null;
-    listRuns(options?: {
-        actionId?: string;
-        status?: string;
-        limit?: number;
-        offset?: number;
-    }): RunRecord[];
+    listRuns(options?: RunsQueryFilterOptions): RunRecord[];
     /** 统计符合条件的运行记录总数 */
-    countRuns?(options?: {
-        actionId?: string;
-        status?: string;
-        requestIds?: string[];
-    }): number;
+    countRuns?(options?: RunsQueryFilterOptions): number;
     /** 查询单条运行记录并补齐幂等请求标识关联（详情路径专用） */
     getRunWithRequestId?(id: string): RunRecord | null;
     clearRuns(options?: {
@@ -241,12 +259,9 @@ export interface RuntimeStorage {
      * 不同宿主会话，ownerId 天然不一致；requestId 本身即跨进程全局唯一的外部
      * 事实源，包维度隔离已提供足够边界。
      */
-    listRunsByRequestIds?(requestIds: string[]): RunRecord[];
+    listRunsByRequestIds?(requestIds: string[], options?: RunsQueryFilterOptions): RunRecord[];
     /** 按客户端幂等请求标识反查关联运行记录总数 */
-    countRunsByRequestIds?(requestIds: string[], options?: {
-        actionId?: string;
-        status?: string;
-    }): number;
+    countRunsByRequestIds?(requestIds: string[], options?: RunsQueryFilterOptions): number;
     /** 反查运行记录关联的幂等请求标识映射（仅限当前包范围，无关联时不含对应键） */
     getRunRequestIds?(runIds: string[]): Record<string, string>;
     appendEvent?(eventType: string, payload: unknown): void;

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export declare const ACTIONDOCK_VERSION = "2.17.0";
+export declare const ACTIONDOCK_VERSION = "2.19.0";

package/dist/version.js

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export const ACTIONDOCK_VERSION = "2.17.0";
+export const ACTIONDOCK_VERSION = "2.19.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/core",
-  "version": "2.17.0",
+  "version": "2.19.0",
   "description": "ActionDock Core Engine - Project loader, runtime execution, SQLite storage, standalone builder, and skill exporter",
   "type": "module",
   "main": "./dist/index.js",
@@ -59,7 +59,7 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/sdk": "^2.17.0",
+    "@actiondock/sdk": "^2.19.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "undici": "^7.29.1"