@nanobpm/urban 0.92.0 → 0.93.0

package/src/runtime/core/host.ts

@@ -3,6 +3,19 @@
 // written against these interfaces and MUST NOT import `node:*` or reference `Deno`.
 // The adapters/ directory supplies concrete implementations.
 
+// The engine-native AgentHistory read shapes ({@link AgentHistoryRecord}) reuse the
+// Camunda `AgentHistoryRecordValue`-parity types the transcript store already models
+// (roles, content blocks, per-turn metrics, tool calls) rather than forking a second
+// projection of the same conversation grammar (No Drift Surfaces). This is a type-only
+// import — fully erased at runtime — so `core/` stays free of any concrete host/engine
+// module load, exactly as the rule above requires.
+import type {
+  TranscriptContentBlock,
+  TranscriptToolCall,
+  TranscriptTurnMetrics,
+  TranscriptTurnRole,
+} from "@nanobpm/agentic/transcript";
+
 /** A minimal HTTP request as seen by a mounted surface/trigger handler. */
 export interface HttpRequest {
   method: string;
@@ -603,6 +616,100 @@ export interface JobSummary {
   readonly deadline?: string;
 }
 
+/**
+ * Aggregated metrics for an agent instance across all of its model calls — the
+ * `AgentInstanceMetrics` the engine rolls up on the instance itself (distinct from the
+ * per-turn {@link TranscriptTurnMetrics} carried on an {@link AgentHistoryRecord}). Total
+ * `inputTokens`/`outputTokens` consumed, and the count of `modelCalls`/`toolCalls` made.
+ */
+export interface AgentInstanceMetrics {
+  readonly inputTokens: number;
+  readonly outputTokens: number;
+  readonly modelCalls: number;
+  readonly toolCalls: number;
+}
+
+/**
+ * A single engine-native agent instance as {@link EngineClient.searchAgentInstances} /
+ * {@link EngineClient.getAgentInstance} report it — the projection of the engine's
+ * `AgentInstanceResult`. Carries the `agentInstanceKey` a caller passes to
+ * {@link EngineClient.searchAgentInstanceHistory}, the lifecycle `status` (a bare string —
+ * the engine's `AgentInstanceStatusEnum` is broad: `INITIALIZING`/`THINKING`/`TOOL_CALLING`/
+ * `IDLE`/`COMPLETED`/…), the owning `processInstanceKey`, and best-effort diagnostics
+ * (`elementId`, the owning `elementInstanceKeys`, the process-definition linkage, aggregated
+ * `metrics`, and the creation/update/completion timestamps). Optional fields are omitted when
+ * the engine does not report them.
+ */
+export interface AgentInstanceSummary {
+  readonly agentInstanceKey: string;
+  readonly status: string;
+  readonly processInstanceKey: string;
+  readonly elementId?: string;
+  readonly elementInstanceKeys?: readonly string[];
+  readonly rootProcessInstanceKey?: string;
+  readonly processDefinitionKey?: string;
+  readonly processDefinitionId?: string;
+  readonly metrics?: AgentInstanceMetrics;
+  readonly creationDate?: string;
+  readonly lastUpdatedDate?: string;
+  readonly completionDate?: string;
+}
+
+/**
+ * A single agent-instance history item as {@link EngineClient.searchAgentInstanceHistory}
+ * reports it — the projection of the engine's `AgentInstanceHistoryItemResult`, i.e. one
+ * Camunda `AgentHistoryRecordValue`. Its conversation grammar (`role`, `content` blocks,
+ * `toolCalls`, per-turn `metrics`) reuses the `@nanobpm/agentic/transcript` parity types the
+ * transcript store already models, so the engine-read seam and the transcript store project
+ * the same shape (No Drift Surfaces). `historyItemKey` is the stable, creation-ordered
+ * identity; `loopIteration` is the agent-loop counter (one LLM call + its tool dispatches +
+ * their results share an iteration); `commitStatus` is the engine's `COMMITTED`/`PENDING`/
+ * `DISCARDED` flag (a bare string). `metrics` is present only when the engine recorded per-call
+ * metrics for the item; `elementInstanceKey`/`jobKey`/`producedAt` are best-effort diagnostics,
+ * omitted when unreported.
+ */
+export interface AgentHistoryRecord {
+  readonly historyItemKey: string;
+  readonly agentInstanceKey: string;
+  readonly loopIteration: number;
+  readonly role: TranscriptTurnRole;
+  readonly content: readonly TranscriptContentBlock[];
+  readonly toolCalls: readonly TranscriptToolCall[];
+  readonly metrics?: TranscriptTurnMetrics;
+  readonly commitStatus: string;
+  readonly elementInstanceKey?: string;
+  readonly jobKey?: string;
+  readonly producedAt?: string;
+}
+
+/** Selectors for {@link EngineClient.searchAgentInstances}. Every field is optional; an
+ *  omitted/blank selector is not applied (No Drift Surfaces — the same presence rule the key
+ *  selectors elsewhere in this seam use). */
+export interface AgentInstanceFilter {
+  /** Only agent instances owned by this process instance. */
+  readonly processInstanceKey?: string;
+  /** Only agent instances belonging to this *root* process-instance hierarchy. */
+  readonly rootProcessInstanceKey?: string;
+  /** Only agent instances in this lifecycle status (the engine's `AgentInstanceStatusEnum`). */
+  readonly status?: string;
+  /** Only agent instances owned by this BPMN element (the AI-agent task / ad-hoc sub-process). */
+  readonly elementId?: string;
+}
+
+/** Selectors for {@link EngineClient.searchAgentInstanceHistory} (the `agentInstanceKey` is a
+ *  required positional argument, not a filter field). Every field is optional. Note the engine
+ *  defaults an unfiltered history search to `COMMITTED` items only. */
+export interface AgentHistoryFilter {
+  /** Only history items with this conversation role. Note that `TranscriptTurnRole` is the wider
+   *  transcript union: only the engine-side subset `"USER" | "ASSISTANT" | "TOOL_RESULT"` is
+   *  applied as a filter — `"CONFIGURATION"`/`"UNSPECIFIED"` are ignored (not forwarded). */
+  readonly role?: TranscriptTurnRole;
+  /** Only history items produced in this agent-loop iteration. */
+  readonly loopIteration?: number;
+  /** Only history items produced under this element instance. */
+  readonly elementInstanceKey?: string;
+}
+
 /**
  * EngineClient is the seam onto a Nano engine. The SDK/REST-backed adapter implements
  * it against a live engine; tests implement it in-memory. Core modules depend only on this.
@@ -772,6 +879,42 @@ export interface EngineClient {
    * caller distinguishes "have it" from "don't" without a try/catch. A zero-wait read.
    */
   getProcessDefinitionXml(processDefinitionKey: string): Promise<string | null>;
+  /**
+   * Search engine-native agent instances (`POST /agent-instances/search`), optionally narrowed
+   * by owning `processInstanceKey`/`rootProcessInstanceKey`, lifecycle `status`, or `elementId`.
+   * The read entry point onto the engine's AgentInstance/AgentHistory model: an
+   * {@link AgentInstanceSummary} carries the `agentInstanceKey` a caller passes to
+   * {@link searchAgentInstanceHistory} to read that instance's conversation. An eventually
+   * consistent (zero-wait) read; each malformed row (no `agentInstanceKey`/`processInstanceKey`)
+   * is dropped rather than surfaced.
+   */
+  searchAgentInstances(filter?: AgentInstanceFilter): Promise<AgentInstanceSummary[]>;
+  /**
+   * Search one agent instance's conversation history
+   * (`POST /agent-instances/{agentInstanceKey}/history/search`) — the ordered
+   * {@link AgentHistoryRecord}s (turns) the engine retains for `agentInstanceKey`, optionally
+   * narrowed by `role`/`loopIteration`/`elementInstanceKey`. This is the production read path
+   * onto engine AgentHistory the historical-transcript + metrics consumer builds on
+   * (nanobpm/nano-workforce#747). Each record's conversation grammar reuses the
+   * `@nanobpm/agentic/transcript` parity shapes (roles, content blocks, per-turn metrics, tool
+   * calls). Note the engine defaults an unfiltered search to `COMMITTED` items only. A blank
+   * `agentInstanceKey` addresses no instance, so it returns the empty list rather than issuing a
+   * request with an empty path segment. An eventually consistent (zero-wait) read; malformed rows
+   * are dropped.
+   */
+  searchAgentInstanceHistory(
+    agentInstanceKey: string,
+    filter?: AgentHistoryFilter,
+  ): Promise<AgentHistoryRecord[]>;
+  /**
+   * Fetch a single agent instance by its key (`GET /agent-instances/{agentInstanceKey}`), or
+   * `null` when it cannot be resolved — the key is blank, no such agent instance exists (a 404),
+   * or the fetch otherwise fails. A read is treated as absence rather than propagating (mirroring
+   * {@link getForm}/{@link getElementInstance}/{@link getProcessDefinitionXml}), so a caller
+   * distinguishes "have it" from "don't" without a try/catch. A zero-wait read returning the same
+   * {@link AgentInstanceSummary} shape as {@link searchAgentInstances}.
+   */
+  getAgentInstance(agentInstanceKey: string): Promise<AgentInstanceSummary | null>;
   /**
    * Resolve an open incident by key (`POST /v2/incidents/{incidentKey}/resolution`), unblocking
    * the parked token: a job incident returns the job to the activatable pool (so it must have
@@ -839,6 +982,9 @@ export const ENGINE_CLIENT_METHODS = [
   "searchVariables",
   "searchJobs",
   "getProcessDefinitionXml",
+  "searchAgentInstances",
+  "searchAgentInstanceHistory",
+  "getAgentInstance",
   "resolveIncident",
   "updateJobRetries",
   "setVariables",

package/src/runtime/core/modules/actions.test.ts

@@ -40,6 +40,9 @@ const engine: EngineClient = {
   searchVariables: async () => [],
   searchJobs: async () => [],
   getProcessDefinitionXml: async () => null,
+  searchAgentInstances: async () => [],
+  searchAgentInstanceHistory: async () => [],
+  getAgentInstance: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

package/src/runtime/core/modules/agent.test.ts

@@ -25,6 +25,9 @@ const fakeEngine: EngineClient = {
   searchVariables: async () => [],
   searchJobs: async () => [],
   getProcessDefinitionXml: async () => null,
+  searchAgentInstances: async () => [],
+  searchAgentInstanceHistory: async () => [],
+  getAgentInstance: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

package/src/runtime/core/modules/api.test.ts

@@ -38,6 +38,9 @@ const engine: EngineClient = {
   searchVariables: async () => [],
   searchJobs: async () => [],
   getProcessDefinitionXml: async () => null,
+  searchAgentInstances: async () => [],
+  searchAgentInstanceHistory: async () => [],
+  getAgentInstance: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

package/src/runtime/core/modules/cancel.test.ts

@@ -92,6 +92,9 @@ function cancelEngine(opts: {
     searchVariables: notUsed("searchVariables"),
     searchJobs: notUsed("searchJobs"),
     getProcessDefinitionXml: notUsed("getProcessDefinitionXml"),
+    searchAgentInstances: notUsed("searchAgentInstances"),
+    searchAgentInstanceHistory: notUsed("searchAgentInstanceHistory"),
+    getAgentInstance: notUsed("getAgentInstance"),
     resolveIncident: notUsed("resolveIncident"),
     updateJobRetries: notUsed("updateJobRetries"),
     setVariables: notUsed("setVariables"),

package/src/runtime/core/modules/connectors.test.ts

@@ -28,6 +28,9 @@ class MiniEngine implements EngineClient {
   async searchVariables(): Promise<never[]> { return []; }
   async searchJobs(): Promise<never[]> { return []; }
   async getProcessDefinitionXml(): Promise<null> { return null; }
+  async searchAgentInstances(): Promise<never[]> { return []; }
+  async searchAgentInstanceHistory(): Promise<never[]> { return []; }
+  async getAgentInstance(): Promise<null> { return null; }
   async resolveIncident(): Promise<void> {}
   async updateJobRetries(): Promise<void> {}
   async setVariables(): Promise<void> {}

package/src/runtime/core/modules/datasource.migrations.test.ts

@@ -27,6 +27,9 @@ const noEngine: EngineClient = {
   searchVariables: async () => [],
   searchJobs: async () => [],
   getProcessDefinitionXml: async () => null,
+  searchAgentInstances: async () => [],
+  searchAgentInstanceHistory: async () => [],
+  getAgentInstance: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

package/src/runtime/core/modules/instance-tracking.test.ts

@@ -97,6 +97,9 @@ function fakeEngine(
     searchVariables: notUsed("searchVariables"),
     searchJobs: notUsed("searchJobs"),
     getProcessDefinitionXml: notUsed("getProcessDefinitionXml"),
+    searchAgentInstances: notUsed("searchAgentInstances"),
+    searchAgentInstanceHistory: notUsed("searchAgentInstanceHistory"),
+    getAgentInstance: notUsed("getAgentInstance"),
     resolveIncident: notUsed("resolveIncident"),
     updateJobRetries: notUsed("updateJobRetries"),
     setVariables: notUsed("setVariables"),

package/src/runtime/core/modules/mcp.test.ts

@@ -29,7 +29,6 @@ import { makeRouter } from "../router.ts";
 import { mountApi } from "./api.ts";
 import { makeGateway } from "./gateway.ts";
 import { DataLayer, type ProvisionedSource } from "./datasource.ts";
-import { InstanceStateStore } from "./instance-state-store.ts";
 import { OpenUserTasksStore } from "./open-user-tasks-store.ts";
 import { evictExcessSessions, isLoopbackRequest, missingRequiredArgs, mountMcp, newSessionId, readHeader, readMcpConfig } from "./mcp.ts";
 import { collectMcpToolProjection, diffMcpToolProjection, parseSpec } from "../../../openapi/spec.ts";
@@ -94,6 +93,9 @@ function fakeEngine(overrides: Partial<EngineClient> = {}): EngineClient {
     searchVariables: async () => [],
     searchJobs: async () => [],
     getProcessDefinitionXml: async () => null,
+    searchAgentInstances: async () => [],
+    searchAgentInstanceHistory: async () => [],
+    getAgentInstance: async () => null,
     resolveIncident: async () => {},
     updateJobRetries: async () => {},
     setVariables: async () => {},
@@ -647,6 +649,9 @@ test("urban_debug_search_variables / search_jobs / get_process_definition_xml ar
       seenXmlKeys.push(key);
       return key === "pd-1" ? "<bpmn:definitions/>" : null;
     },
+    searchAgentInstances: async () => [],
+    searchAgentInstanceHistory: async () => [],
+    getAgentInstance: async () => null,
   });
   const { router } = buildHarness({ engine });
   const session = await connect(router);
@@ -769,13 +774,11 @@ test("the reserved-namespace drop warns once, not on every tools/list and tools/
   assert.equal(drops.length, 1, "the reserved-namespace drop must warn exactly once across many requests");
 });
 
-test("the projection debug tools read the ADR 0065 canonical stores", async () => {
+test("urban_debug_open_user_tasks reads the ADR 0065 canonical projection", async () => {
   const dir = await mkdtemp(join(tmpdir(), "urban-mcp-proj-"));
   const host = createNodeHost({ cwd: dir, log: () => {} });
   const db: SqliteDb = host.openSqlite(join(dir, "test.db"));
   try {
-    new InstanceStateStore(db, { clock: { now: () => 0 } }).ensureSchema();
-    new InstanceStateStore(db, { clock: { now: () => 0 } }).recordState("pi-7", "ACTIVE");
     const openStore = new OpenUserTasksStore(db, { clock: { now: () => 0 } });
     openStore.ensureSchema();
     openStore.recordOpenTask("pi-7", { userTaskKey: "ut-1", elementId: "Task_A" });
@@ -792,13 +795,6 @@ test("the projection debug tools read the ADR 0065 canonical stores", async () =
     const { router } = buildHarness({ data });
     const session = await connect(router);
 
-    const stateCall = await rpc(router, session, "tools/call", {
-      name: "urban_debug_instance_state",
-      arguments: { processInstanceKey: "pi-7" },
-    });
-    const state = JSON.parse(toolContentText(stateCall.result));
-    assert.equal(Reflect.get(state, "state"), "ACTIVE");
-
     const tasksCall = await rpc(router, session, "tools/call", {
       name: "urban_debug_open_user_tasks",
       arguments: { processInstanceKey: "pi-7" },
@@ -812,6 +808,66 @@ test("the projection debug tools read the ADR 0065 canonical stores", async () =
   }
 });
 
+test("urban_debug_instance_state returns engine truth for a live (ACTIVE) instance", async () => {
+  const snapshot: ProcessInstanceSnapshot = { processInstanceKey: "pi-7", state: "ACTIVE" };
+  const engine = fakeEngine({
+    searchProcessInstances: async (filter) => {
+      assert.deepEqual(filter?.processInstanceKeys, ["pi-7"]);
+      return [snapshot];
+    },
+    openUserTasks: async () => [],
+  });
+  const { router } = buildHarness({ engine });
+  const session = await connect(router);
+
+  const call = await rpc(router, session, "tools/call", {
+    name: "urban_debug_instance_state",
+    arguments: { processInstanceKey: "pi-7" },
+  });
+  const state = JSON.parse(toolContentText(call.result));
+  assert.deepEqual(state, { processInstanceKey: "pi-7", state: "ACTIVE", waitingOnHuman: false });
+});
+
+test("urban_debug_instance_state reports waitingOnHuman from open user tasks", async () => {
+  const snapshot: ProcessInstanceSnapshot = { processInstanceKey: "pi-7", state: "ACTIVE" };
+  const engine = fakeEngine({
+    searchProcessInstances: async () => [snapshot],
+    openUserTasks: async (filter) => {
+      assert.equal(filter?.processInstanceKey, "pi-7");
+      return [{ userTaskKey: "ut-1", processInstanceKey: "pi-7" }];
+    },
+  });
+  const { router } = buildHarness({ engine });
+  const session = await connect(router);
+
+  const call = await rpc(router, session, "tools/call", {
+    name: "urban_debug_instance_state",
+    arguments: { processInstanceKey: "pi-7" },
+  });
+  const state = JSON.parse(toolContentText(call.result));
+  assert.deepEqual(state, { processInstanceKey: "pi-7", state: "ACTIVE", waitingOnHuman: true });
+});
+
+test("urban_debug_instance_state returns null when the engine has no such instance", async () => {
+  let openUserTasksCalled = false;
+  const engine = fakeEngine({
+    searchProcessInstances: async () => [],
+    openUserTasks: async () => {
+      openUserTasksCalled = true;
+      return [];
+    },
+  });
+  const { router } = buildHarness({ engine });
+  const session = await connect(router);
+
+  const call = await rpc(router, session, "tools/call", {
+    name: "urban_debug_instance_state",
+    arguments: { processInstanceKey: "nope" },
+  });
+  assert.equal(toolContentText(call.result), "null");
+  assert.equal(openUserTasksCalled, false, "must not probe user tasks for an instance the engine doesn't know");
+});
+
 // ---- mutation guard (Slice 3) -----------------------------------------------------------------
 
 // A repeated credential header must read the SAME under the MCP guard as under OpenAPI route

package/src/runtime/core/modules/mcp.ts

@@ -82,7 +82,6 @@ import { resolveBindMode } from "../manifest.ts";
 import { json, makeRouter, type Route } from "../router.ts";
 import { API_BASE, readApiBinding } from "./api.ts";
 import { resolveAppPath } from "./datasource.ts";
-import { InstanceStateStore } from "./instance-state-store.ts";
 import { OpenUserTasksStore } from "./open-user-tasks-store.ts";
 
 /** The mount path of the MCP endpoint — a sibling of `/app/api` / `/app/agent`, mounted
@@ -785,17 +784,19 @@ function buildDebugTools(app: AppApi): DebugTool[] {
     },
     {
       name: `${DEBUG_PREFIX}instance_state`,
-      description: "Projection (urban_instance_state, ADR 0065): the canonical engine-lifecycle state for an instance.",
+      description:
+        "Engine truth: the live lifecycle state of a process instance (ACTIVE/COMPLETED/TERMINATED) via searchProcessInstances, plus `waitingOnHuman` from its open user tasks. `null` means the engine has no such instance (not merely 'not yet terminal').",
       inputSchema: {
         type: "object",
         properties: { processInstanceKey: OPTIONAL_STRING },
         required: ["processInstanceKey"],
       },
-      run: (args) => {
+      run: async (args) => {
         const key = requireString(args, "processInstanceKey");
-        const db = projectionDb();
-        if (!db) return Promise.resolve(null);
-        return Promise.resolve(new InstanceStateStore(db).getState(key) ?? null);
+        const [snapshot] = await app.engine.searchProcessInstances({ processInstanceKeys: [key] });
+        if (!snapshot) return null;
+        const openTasks = await app.engine.openUserTasks({ processInstanceKey: key });
+        return { processInstanceKey: key, state: snapshot.state, waitingOnHuman: openTasks.length > 0 };
       },
     },
     {

package/src/runtime/core/modules/pages.test.ts

@@ -55,6 +55,9 @@ function fakeEngine(): { engine: EngineClient; calls: FakeEngineCalls } {
     async searchVariables() { return []; },
     async searchJobs() { return []; },
     async getProcessDefinitionXml() { return null; },
+    async searchAgentInstances() { return []; },
+    async searchAgentInstanceHistory() { return []; },
+    async getAgentInstance() { return null; },
     async resolveIncident() {},
     async updateJobRetries() {},
     async setVariables() {},

package/src/runtime/core/modules/surfaces.test.ts

@@ -41,6 +41,9 @@ function ctxWith(surfaces: Record<string, unknown>): Parameters<typeof mountSurf
     searchVariables: async () => [],
     searchJobs: async () => [],
     getProcessDefinitionXml: async () => null,
+    searchAgentInstances: async () => [],
+    searchAgentInstanceHistory: async () => [],
+    getAgentInstance: async () => null,
     resolveIncident: async () => {},
     updateJobRetries: async () => {},
     setVariables: async () => {},
@@ -67,6 +70,9 @@ const fakeEngine: EngineClient = {
   searchVariables: async () => [],
   searchJobs: async () => [],
   getProcessDefinitionXml: async () => null,
+  searchAgentInstances: async () => [],
+  searchAgentInstanceHistory: async () => [],
+  getAgentInstance: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

package/src/runtime/core/modules/triggers.test.ts

@@ -42,6 +42,9 @@ class MiniEngine implements EngineClient {
   async searchVariables(): Promise<never[]> { return []; }
   async searchJobs(): Promise<never[]> { return []; }
   async getProcessDefinitionXml(): Promise<null> { return null; }
+  async searchAgentInstances(): Promise<never[]> { return []; }
+  async searchAgentInstanceHistory(): Promise<never[]> { return []; }
+  async getAgentInstance(): Promise<null> { return null; }
   async resolveIncident(): Promise<void> {}
   async updateJobRetries(): Promise<void> {}
   async setVariables(): Promise<void> {}

package/src/runtime/core/modules/workers.test.ts

@@ -39,6 +39,9 @@ class MiniEngine implements EngineClient {
   async searchVariables(): Promise<never[]> { return []; }
   async searchJobs(): Promise<never[]> { return []; }
   async getProcessDefinitionXml(): Promise<null> { return null; }
+  async searchAgentInstances(): Promise<never[]> { return []; }
+  async searchAgentInstanceHistory(): Promise<never[]> { return []; }
+  async getAgentInstance(): Promise<null> { return null; }
   async resolveIncident(): Promise<void> {}
   async updateJobRetries(): Promise<void> {}
   async setVariables(): Promise<void> {}

package/src/runtime/core/runtime.extensions.test.ts

@@ -53,6 +53,15 @@ class NoopEngine implements EngineClient {
   async getProcessDefinitionXml() {
     return null;
   }
+  async searchAgentInstances() {
+    return [];
+  }
+  async searchAgentInstanceHistory() {
+    return [];
+  }
+  async getAgentInstance() {
+    return null;
+  }
   async resolveIncident() {}
   async updateJobRetries() {}
   async setVariables() {}

package/src/runtime/core/runtime.test.ts

@@ -74,6 +74,15 @@ class FakeEngine implements EngineClient {
   async getProcessDefinitionXml() {
     return null;
   }
+  async searchAgentInstances() {
+    return [];
+  }
+  async searchAgentInstanceHistory() {
+    return [];
+  }
+  async getAgentInstance() {
+    return null;
+  }
   async resolveIncident() {}
   async updateJobRetries() {}
   async setVariables() {}