@nanobpm/urban 0.92.0 → 0.92.1

package/dist/runtime/core/modules/mcp.js

@@ -41,7 +41,6 @@ import { resolveBindMode } from "../manifest.js";
 import { json, makeRouter } from "../router.js";
 import { API_BASE, readApiBinding } from "./api.js";
 import { resolveAppPath } from "./datasource.js";
-import { InstanceStateStore } from "./instance-state-store.js";
 import { OpenUserTasksStore } from "./open-user-tasks-store.js";
 /** The mount path of the MCP endpoint — a sibling of `/app/api` / `/app/agent`, mounted
  *  unconditionally so an MCP client always has a stable address to connect to. */
@@ -682,18 +681,19 @@ function buildDebugTools(app) {
         },
         {
             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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nanobpm/urban",
-	"version": "0.92.0",
+	"version": "0.92.1",
 	"description": "Urban: build and run code-first apps on Nano — runtime, derivation toolkit, and CLI in one. Author durable processes with @nanobpm/workflow (defineFlow), a typed datasource, forms, triggers and surfaces from a nano.app.json manifest, on Node or Deno.",
 	"license": "Apache-2.0",
 	"type": "module",

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";
@@ -769,13 +768,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 +789,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 +802,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 };
       },
     },
     {