@nanobpm/urban 0.88.1 → 0.90.0

package/src/runtime/core/host.ts

@@ -229,6 +229,22 @@ export type UserTaskState = "CREATED" | "COMPLETED" | "CANCELED" | "FAILED";
 export interface ProcessInstanceSnapshot {
   readonly processInstanceKey: string;
   readonly state: ProcessInstanceState;
+  /** The key of the deployed process definition this instance runs — the handle a caller feeds to
+   *  {@link EngineClient.getProcessDefinitionXml} to fetch the deployed BPMN (the instance →
+   *  `processDefinitionKey` → deployed XML path, no repo checkout). Absent when the engine omits it. */
+  readonly processDefinitionKey?: string;
+  /** The key of this instance's *immediate* parent process instance — the caller that instantiated
+   *  it as a native child (a `<bpmn:callActivity>`). `undefined` for a top-level (root) instance,
+   *  and absent when the engine omits it (same optional/engine-provided convention as
+   *  `processDefinitionKey`). Lets a reduced-capability read path map a native child back to the
+   *  subject that spawned it without a raw-REST channel. */
+  readonly parentProcessInstanceKey?: string;
+  /** The key of this instance's *root* process instance — the top-level ancestor of the
+   *  call-activity hierarchy this instance belongs to (equal to `processInstanceKey` for a
+   *  top-level instance). `undefined`/absent when the engine omits it (only present for hierarchies
+   *  created on an engine version that reports it). Lets a reduced-capability read path correlate a
+   *  deep native descendant straight back to its root subject. */
+  readonly rootProcessInstanceKey?: string;
 }
 
 /**
@@ -247,6 +263,24 @@ export interface UserTaskSummary {
   readonly formKey?: string;
   /** An external form reference (a form linked outside the deployment), if any. */
   readonly externalFormReference?: string;
+  /** The key of the process instance this task belongs to. Absent when the engine omits it (same
+   *  optional/engine-provided convention as `processDefinitionKey`). For a task owned by a native
+   *  child instance, this is the child's own key — the handle a reduced-capability read path feeds
+   *  to {@link EngineClient.searchProcessInstances} to resolve the child's parent/root linkage. */
+  readonly processInstanceKey?: string;
+  /** The key of the *immediate* parent process instance of this task's owning instance — the caller
+   *  that spawned it as a native child. Absent when the engine's user-task read model omits it (as
+   *  it does today: the engine surfaces the parent linkage on {@link ProcessInstanceSnapshot}, so a
+   *  caller resolves it via `processInstanceKey` → `searchProcessInstances`). Declared here for
+   *  parity with the process-instance snapshot and to flow through automatically if the read model
+   *  starts carrying it. */
+  readonly parentProcessInstanceKey?: string;
+  /** The key of the *root* process instance of this task's owning instance — the top-level ancestor
+   *  of the call-activity hierarchy the task lives in. Absent when the engine omits it. Lets a
+   *  reduced-capability read path (`pollUserTasks` and other reconcile/affordance surfaces)
+   *  correlate a native-child (e.g. human-escalation grandchild) task straight back to its root
+   *  subject through the typed seam, with no raw-REST fallback. */
+  readonly rootProcessInstanceKey?: string;
 }
 
 /**
@@ -259,6 +293,14 @@ export interface UserTaskFilter {
   processInstanceKey?: string;
   assignee?: string;
   candidateGroup?: string;
+  /** Select only tasks whose owning instance has this *immediate* parent process instance. Honored
+   *  server-side by the live gateway where the read model supports it; the in-process testkit
+   *  applies it client-side against the row's parent linkage (absent today on the user-task read
+   *  model, so it matches nothing until the engine surfaces it there). */
+  parentProcessInstanceKey?: string;
+  /** Select only tasks whose owning instance belongs to this *root* process-instance hierarchy — the
+   *  selector a reduced-capability path uses to fetch every open task under one root subject. */
+  rootProcessInstanceKey?: string;
 }
 
 /**
@@ -487,6 +529,76 @@ export interface FormSchema {
   readonly schema: Record<string, unknown>;
 }
 
+/**
+ * Selectors for a variable search: which process instance and/or scope to match, optionally
+ * narrowed to a single variable `name`. Used by {@link EngineClient.searchVariables}. An
+ * eventually consistent (zero-wait) read; an unset selector matches every variable in scope.
+ */
+export interface VariableFilter {
+  processInstanceKey?: string;
+  scopeKey?: string;
+  name?: string;
+}
+
+/**
+ * A single process variable as {@link EngineClient.searchVariables} reports it — the read
+ * counterpart to the write-only {@link EngineClient.setVariables}. Mirrors the engine's v2
+ * `/variables/search` row: the variable's own `variableKey`, its `name`, its serialized JSON
+ * `value` (a string — an object/array value arrives JSON-encoded, so a caller `JSON.parse`s it),
+ * the `scopeKey` it is directly defined in (a process-instance key for a process-level variable,
+ * an element-instance key for a local one) and the owning `processInstanceKey`. `isTruncated` is
+ * `true` when the engine clipped a large `value` for the read model — the caller then knows the
+ * `value` is a preview, not the whole payload. This is the only way to read a parked token's
+ * business payload (`prKey`, `round`, an escalation `question`/`answer`, `resolution`,
+ * `directive`); the ADR 0065 projections carry lifecycle/position, not the payload.
+ */
+export interface VariableSummary {
+  readonly variableKey: string;
+  readonly name: string;
+  readonly value: string;
+  readonly scopeKey: string;
+  readonly processInstanceKey: string;
+  readonly isTruncated: boolean;
+}
+
+/**
+ * Selectors for a job search: which process instance, lifecycle `state`, job `type`, `elementId`,
+ * and/or leasing `worker` to match. Used by {@link EngineClient.searchJobs}. `state` is kept a
+ * transport-agnostic bare string (the engine's job-state enum is broad and forward-looking — e.g.
+ * `CREATED`/`COMPLETED`/`FAILED`/`TIMED_OUT`), so a new engine state flows through without having
+ * to be enumerated here. An eventually consistent (zero-wait) read; an unset selector matches
+ * every job.
+ */
+export interface JobFilter {
+  processInstanceKey?: string;
+  state?: string;
+  type?: string;
+  elementId?: string;
+  worker?: string;
+}
+
+/**
+ * A single job as {@link EngineClient.searchJobs} reports it — mirrors the engine's v2
+ * `/jobs/search` row. Carries the `jobKey` a caller passes to
+ * {@link EngineClient.updateJobRetries} (the only source of a `jobKey` for a job NOT already
+ * behind a `jobNoRetries` incident, which {@link searchIncidents} surfaces), the job `type` and
+ * lifecycle `state` (a bare string — see {@link JobFilter}), the owning `processInstanceKey`, and
+ * the best-effort diagnostics `worker`/`retries`/`elementId`/`deadline`. The `worker` field is the
+ * "is it actually stuck" signal: a `CREATED` job WITH a `worker` set has been leased by an agent,
+ * while one with NONE set is merely queued — so `worker` is omitted (absent) when unset. `retries`,
+ * `elementId`, and `deadline` are likewise present when the engine reports them, omitted otherwise.
+ */
+export interface JobSummary {
+  readonly jobKey: string;
+  readonly type: string;
+  readonly state: string;
+  readonly processInstanceKey: string;
+  readonly worker?: string;
+  readonly retries?: number;
+  readonly elementId?: string;
+  readonly deadline?: 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.
@@ -562,6 +674,12 @@ export interface EngineClient {
   searchProcessInstances(filter?: {
     processInstanceKeys?: string[];
     state?: ProcessInstanceState;
+    /** Select only instances whose *immediate* parent is this process instance — the reduced-path
+     *  query for "the native children spawned by this subject". */
+    parentProcessInstanceKey?: string;
+    /** Select only instances belonging to this *root* process-instance hierarchy — "every instance
+     *  under this root subject", the deep-descendant correlation query. */
+    rootProcessInstanceKey?: string;
   }): Promise<ProcessInstanceSnapshot[]>;
   /**
    * Search element instances ("tokens") by process instance, element, and/or lifecycle state
@@ -616,6 +734,40 @@ export interface EngineClient {
    * they answer "how far has this instance progressed", this answers "why is it stuck".
    */
   searchIncidents(filter?: IncidentFilter): Promise<IncidentSummary[]>;
+  /**
+   * Search process variables by owning process instance and/or scope, optionally narrowed to a
+   * single `name` (`POST /v2/variables/search`). The read counterpart to the write-only
+   * {@link setVariables}: it is the only way to see a parked token's business payload (`prKey`,
+   * `round`, an escalation `question`/`answer`, `resolution`, `directive`) — the ADR 0065
+   * projections carry lifecycle/position, not the payload. An eventually consistent (zero-wait)
+   * read; each {@link VariableSummary} carries the variable's serialized JSON `value` (a string)
+   * and an `isTruncated` flag set when the engine clipped a large value for the read model.
+   */
+  searchVariables(filter?: VariableFilter): Promise<VariableSummary[]>;
+  /**
+   * Search jobs by owning process instance, lifecycle `state`, job `type`, `elementId`, and/or
+   * leasing `worker` (`POST /v2/jobs/search`). This is the "is it actually stuck" read: a
+   * `CREATED` job WITH a `worker` set has been leased by an agent, while one with NONE set is
+   * merely queued. It is also the on-tool source of a `jobKey` for {@link updateJobRetries} when
+   * the job is NOT behind an incident — {@link searchIncidents} only surfaces a `jobKey` for a
+   * job that already faulted (a `jobNoRetries` incident), so retrying an un-incidented job would
+   * otherwise be impossible without a direct engine-API call. An eventually consistent (zero-wait)
+   * read; each {@link JobSummary} carries the `jobKey` plus best-effort `worker`/`retries`/
+   * `elementId`/`deadline` diagnostics.
+   */
+  searchJobs(filter?: JobFilter): Promise<JobSummary[]>;
+  /**
+   * Fetch the deployed BPMN XML of a process definition by its `processDefinitionKey`
+   * (`GET /v2/process-definitions/{processDefinitionKey}/xml`), or `null` when the key is blank,
+   * unknown (a 404), or the definition carries no XML. This is the *deployed* model — the routing
+   * source of truth, including its FEEL gateway conditions — so an agent can reason about WHY an
+   * instance routed where it did without checking out `resources/processes/*.bpmn` from the app
+   * repo. An instance already carries its `processDefinitionKey` (via {@link searchProcessInstances}),
+   * so the path is instance → `processDefinitionKey` → deployed XML. A read is treated as absence
+   * (`null`) rather than propagating (mirroring {@link getForm}/{@link getElementInstance}), so a
+   * caller distinguishes "have it" from "don't" without a try/catch. A zero-wait read.
+   */
+  getProcessDefinitionXml(processDefinitionKey: string): Promise<string | 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
@@ -680,6 +832,9 @@ export const ENGINE_CLIENT_METHODS = [
   "searchElementInstanceWaitStates",
   "getElementInstance",
   "searchIncidents",
+  "searchVariables",
+  "searchJobs",
+  "getProcessDefinitionXml",
   "resolveIncident",
   "updateJobRetries",
   "setVariables",

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

@@ -37,6 +37,9 @@ const engine: EngineClient = {
   searchElementInstanceWaitStates: async () => [],
   getElementInstance: async () => null,
   searchIncidents: async () => [],
+  searchVariables: async () => [],
+  searchJobs: async () => [],
+  getProcessDefinitionXml: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

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

@@ -22,6 +22,9 @@ const fakeEngine: EngineClient = {
   searchElementInstanceWaitStates: async () => [],
   getElementInstance: async () => null,
   searchIncidents: async () => [],
+  searchVariables: async () => [],
+  searchJobs: async () => [],
+  getProcessDefinitionXml: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

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

@@ -35,6 +35,9 @@ const engine: EngineClient = {
   searchElementInstanceWaitStates: async () => [],
   getElementInstance: async () => null,
   searchIncidents: async () => [],
+  searchVariables: async () => [],
+  searchJobs: async () => [],
+  getProcessDefinitionXml: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

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

@@ -89,6 +89,9 @@ function cancelEngine(opts: {
     searchElementInstanceWaitStates: notUsed("searchElementInstanceWaitStates"),
     getElementInstance: notUsed("getElementInstance"),
     searchIncidents: notUsed("searchIncidents"),
+    searchVariables: notUsed("searchVariables"),
+    searchJobs: notUsed("searchJobs"),
+    getProcessDefinitionXml: notUsed("getProcessDefinitionXml"),
     resolveIncident: notUsed("resolveIncident"),
     updateJobRetries: notUsed("updateJobRetries"),
     setVariables: notUsed("setVariables"),

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

@@ -25,6 +25,9 @@ class MiniEngine implements EngineClient {
   async searchElementInstanceWaitStates(): Promise<[]> { return []; }
   async getElementInstance(): Promise<null> { return null; }
   async searchIncidents(): Promise<never[]> { return []; }
+  async searchVariables(): Promise<never[]> { return []; }
+  async searchJobs(): Promise<never[]> { return []; }
+  async getProcessDefinitionXml(): 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

@@ -24,6 +24,9 @@ const noEngine: EngineClient = {
   searchElementInstanceWaitStates: async () => [],
   getElementInstance: async () => null,
   searchIncidents: async () => [],
+  searchVariables: async () => [],
+  searchJobs: async () => [],
+  getProcessDefinitionXml: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

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

@@ -94,6 +94,9 @@ function fakeEngine(
     searchElementInstanceWaitStates: notUsed("searchElementInstanceWaitStates"),
     getElementInstance: notUsed("getElementInstance"),
     searchIncidents: notUsed("searchIncidents"),
+    searchVariables: notUsed("searchVariables"),
+    searchJobs: notUsed("searchJobs"),
+    getProcessDefinitionXml: notUsed("getProcessDefinitionXml"),
     resolveIncident: notUsed("resolveIncident"),
     updateJobRetries: notUsed("updateJobRetries"),
     setVariables: notUsed("setVariables"),

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

@@ -91,6 +91,9 @@ function fakeEngine(overrides: Partial<EngineClient> = {}): EngineClient {
     searchElementInstanceWaitStates: async () => [],
     getElementInstance: async () => null,
     searchIncidents: async () => [],
+    searchVariables: async () => [],
+    searchJobs: async () => [],
+    getProcessDefinitionXml: async () => null,
     resolveIncident: async () => {},
     updateJobRetries: async () => {},
     setVariables: async () => {},
@@ -565,6 +568,9 @@ test("the framework debug tools appear and return engine truth", async () => {
   assert.ok(names.includes("urban_debug_search_user_tasks"));
   assert.ok(names.includes("urban_debug_instance_state"));
   assert.ok(names.includes("urban_debug_open_user_tasks"));
+  assert.ok(names.includes("urban_debug_search_variables"));
+  assert.ok(names.includes("urban_debug_search_jobs"));
+  assert.ok(names.includes("urban_debug_get_process_definition_xml"));
 
   const call = await rpc(router, session, "tools/call", {
     name: "urban_debug_search_process_instances",
@@ -574,6 +580,97 @@ test("the framework debug tools appear and return engine truth", async () => {
   assert.deepEqual(JSON.parse(text), [snapshot]);
 });
 
+test("urban_debug_search_variables / search_jobs / get_process_definition_xml are read tools returning engine truth", async () => {
+  const variable = {
+    variableKey: "v-1",
+    name: "prKey",
+    value: '"owner/repo#7"',
+    scopeKey: "pi-1",
+    processInstanceKey: "pi-1",
+    isTruncated: false,
+  };
+  const job = {
+    jobKey: "j-1",
+    type: "senior:pr-review",
+    state: "CREATED",
+    processInstanceKey: "pi-1",
+    retries: 3,
+    elementId: "review",
+  };
+  const seenVarFilters: unknown[] = [];
+  const seenJobFilters: unknown[] = [];
+  const seenXmlKeys: string[] = [];
+  const engine = fakeEngine({
+    searchVariables: async (filter) => {
+      seenVarFilters.push(filter);
+      return [variable];
+    },
+    searchJobs: async (filter) => {
+      seenJobFilters.push(filter);
+      return [job];
+    },
+    getProcessDefinitionXml: async (key) => {
+      seenXmlKeys.push(key);
+      return key === "pd-1" ? "<bpmn:definitions/>" : null;
+    },
+  });
+  const { router } = buildHarness({ engine });
+  const session = await connect(router);
+
+  // All three tools are read tools — they serve on loopback with no credential.
+  const vars = await rpc(router, session, "tools/call", {
+    name: "urban_debug_search_variables",
+    arguments: { processInstanceKey: "pi-1", name: "prKey" },
+  });
+  assert.notEqual(vars.result?.isError, true, "search_variables is a read tool (no credential needed)");
+  assert.deepEqual(JSON.parse(toolContentText(vars.result)), [variable]);
+  assert.deepEqual(seenVarFilters, [{ processInstanceKey: "pi-1", name: "prKey" }]);
+
+  const jobs = await rpc(router, session, "tools/call", {
+    name: "urban_debug_search_jobs",
+    arguments: { processInstanceKey: "pi-1", state: "CREATED" },
+  });
+  assert.notEqual(jobs.result?.isError, true, "search_jobs is a read tool (no credential needed)");
+  assert.deepEqual(JSON.parse(toolContentText(jobs.result)), [job]);
+  assert.deepEqual(seenJobFilters, [{ processInstanceKey: "pi-1", state: "CREATED" }]);
+
+  const xml = await rpc(router, session, "tools/call", {
+    name: "urban_debug_get_process_definition_xml",
+    arguments: { processDefinitionKey: "pd-1" },
+  });
+  assert.notEqual(xml.result?.isError, true, "get_process_definition_xml is a read tool");
+  // The deployed XML is a raw string, surfaced verbatim (not JSON-wrapped).
+  assert.equal(toolContentText(xml.result), "<bpmn:definitions/>");
+  assert.deepEqual(seenXmlKeys, ["pd-1"]);
+
+  // An unknown key returns typed-absent (null) rather than erroring.
+  const absent = await rpc(router, session, "tools/call", {
+    name: "urban_debug_get_process_definition_xml",
+    arguments: { processDefinitionKey: "nope" },
+  });
+  assert.equal(toolContentText(absent.result), "null");
+});
+
+test("the three new debug read tools expose self-contained ($ref-free) input schemas", async () => {
+  const { router } = buildHarness({ engine: fakeEngine() });
+  const session = await connect(router);
+  const list = await rpc(router, session, "tools/list", {});
+  const tools = list.result?.tools;
+  assert.ok(Array.isArray(tools));
+  const names = tools.map((t) => Reflect.get(t, "name"));
+  for (const name of [
+    "urban_debug_search_variables",
+    "urban_debug_search_jobs",
+    "urban_debug_get_process_definition_xml",
+  ]) {
+    assert.ok(names.includes(name), `${name} must appear in tools/list`);
+    const tool: unknown = tools[names.indexOf(name)];
+    const schema: unknown = Reflect.get(tool ?? {}, "inputSchema");
+    assert.equal(Reflect.get(schema ?? {}, "type"), "object", `${name} schema is an object`);
+    assert.ok(!JSON.stringify(schema).includes("$ref"), `${name} schema must be $ref-free`);
+  }
+});
+
 test("an app operationId in the reserved urban_debug_ namespace can't shadow a framework tool", async () => {
   // A `urban_debug_*` operationId is a legal safe path segment, so an app could declare one. Because
   // `CallTool` resolves framework debug tools before app ops, an unreserved namespace would let such

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

@@ -69,10 +69,12 @@ import type {
   HttpRequest,
   HttpResponse,
   IncidentFilter,
+  JobFilter,
   ProcessInstanceState,
   SqliteDb,
   UserTaskFilter,
   UserTaskState,
+  VariableFilter,
   WaitStateType,
 } from "../host.ts";
 import { presentFormIdentifier } from "../host.ts";
@@ -640,6 +642,70 @@ function buildDebugTools(app: AppApi): DebugTool[] {
         return app.engine.searchIncidents(filter);
       },
     },
+    {
+      name: `${DEBUG_PREFIX}search_variables`,
+      description:
+        "Engine truth: search process variables by process instance and/or scope, optionally by name — the read counterpart to set_variables. Reads only, eventually consistent. This is the only way to see a parked token's business payload (prKey, round, an escalation question/answer, resolution, directive); the projections carry lifecycle/position, not the payload. Each result carries the variableKey/name/serialized-JSON value/scopeKey/processInstanceKey/isTruncated.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          processInstanceKey: OPTIONAL_STRING,
+          scopeKey: OPTIONAL_STRING,
+          name: OPTIONAL_STRING,
+        },
+      },
+      run: (args) => {
+        const filter: VariableFilter = {};
+        const pik = readPresentString(args, "processInstanceKey");
+        if (pik) filter.processInstanceKey = pik;
+        const scopeKey = readPresentString(args, "scopeKey");
+        if (scopeKey) filter.scopeKey = scopeKey;
+        const name = readPresentString(args, "name");
+        if (name) filter.name = name;
+        return app.engine.searchVariables(filter);
+      },
+    },
+    {
+      name: `${DEBUG_PREFIX}search_jobs`,
+      description:
+        "Engine truth: search jobs by process instance, state, and/or type/elementId/worker. Reads only, eventually consistent. The 'is it actually stuck?' test: a CREATED job WITH a worker set has been leased by an agent, one with NONE set is merely queued. This is also the on-tool source of a jobKey for retry_job (the only other source is a jobNoRetries incident via search_incidents). Each result carries jobKey/type/state/processInstanceKey and the best-effort worker/retries/elementId/deadline.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          processInstanceKey: OPTIONAL_STRING,
+          state: OPTIONAL_STRING,
+          type: OPTIONAL_STRING,
+          elementId: OPTIONAL_STRING,
+          worker: OPTIONAL_STRING,
+        },
+      },
+      run: (args) => {
+        const filter: JobFilter = {};
+        const pik = readPresentString(args, "processInstanceKey");
+        if (pik) filter.processInstanceKey = pik;
+        const state = readPresentString(args, "state");
+        if (state) filter.state = state;
+        const type = readPresentString(args, "type");
+        if (type) filter.type = type;
+        const elementId = readPresentString(args, "elementId");
+        if (elementId) filter.elementId = elementId;
+        const worker = readPresentString(args, "worker");
+        if (worker) filter.worker = worker;
+        return app.engine.searchJobs(filter);
+      },
+    },
+    {
+      name: `${DEBUG_PREFIX}get_process_definition_xml`,
+      description:
+        "Engine truth: return the deployed BPMN XML of a process definition by key (the routing source of truth, with its FEEL gateway conditions) — reason about WHY an instance routed where it did without a repo checkout. Reads only; null when the key is unknown. An instance carries its processDefinitionKey via search_process_instances, so the path is instance → processDefinitionKey → deployed XML; pair with get_element_instance to locate the parked element.",
+      inputSchema: {
+        type: "object",
+        properties: { processDefinitionKey: OPTIONAL_STRING },
+        required: ["processDefinitionKey"],
+      },
+      run: (args) =>
+        app.engine.getProcessDefinitionXml(requireString(args, "processDefinitionKey")),
+    },
     {
       name: `${DEBUG_PREFIX}cancel_instance`,
       description: "MUTATING: cancel a running process instance. Requires the shared-secret guard.",

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

@@ -52,6 +52,9 @@ function fakeEngine(): { engine: EngineClient; calls: FakeEngineCalls } {
     async searchElementInstanceWaitStates() { return []; },
     async getElementInstance() { return null; },
     async searchIncidents() { return []; },
+    async searchVariables() { return []; },
+    async searchJobs() { return []; },
+    async getProcessDefinitionXml() { return null; },
     async resolveIncident() {},
     async updateJobRetries() {},
     async setVariables() {},

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

@@ -38,6 +38,9 @@ function ctxWith(surfaces: Record<string, unknown>): Parameters<typeof mountSurf
     searchElementInstanceWaitStates: async () => [],
     getElementInstance: async () => null,
     searchIncidents: async () => [],
+    searchVariables: async () => [],
+    searchJobs: async () => [],
+    getProcessDefinitionXml: async () => null,
     resolveIncident: async () => {},
     updateJobRetries: async () => {},
     setVariables: async () => {},
@@ -61,6 +64,9 @@ const fakeEngine: EngineClient = {
   searchElementInstanceWaitStates: async () => [],
   getElementInstance: async () => null,
   searchIncidents: async () => [],
+  searchVariables: async () => [],
+  searchJobs: async () => [],
+  getProcessDefinitionXml: async () => null,
   resolveIncident: async () => {},
   updateJobRetries: async () => {},
   setVariables: async () => {},

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

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

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

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

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

@@ -44,6 +44,15 @@ class NoopEngine implements EngineClient {
   async searchIncidents() {
     return [];
   }
+  async searchVariables() {
+    return [];
+  }
+  async searchJobs() {
+    return [];
+  }
+  async getProcessDefinitionXml() {
+    return null;
+  }
   async resolveIncident() {}
   async updateJobRetries() {}
   async setVariables() {}

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

@@ -65,6 +65,15 @@ class FakeEngine implements EngineClient {
   async searchIncidents() {
     return [];
   }
+  async searchVariables() {
+    return [];
+  }
+  async searchJobs() {
+    return [];
+  }
+  async getProcessDefinitionXml() {
+    return null;
+  }
   async resolveIncident() {}
   async updateJobRetries() {}
   async setVariables() {}