@kontextmind/kxm 0.7.100 → 0.7.102

package/plugins/kxm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-plugin",
-  "version": "0.7.100",
+  "version": "0.7.102",
   "private": true,
   "type": "module",
   "engines": {

package/plugins/kxm/skills/kxm-workflow/SKILL.md

@@ -81,10 +81,10 @@ kxm workflow record run_12345 decision "Serialize the fixture setup" --stage-id
 does not read project `.kxm/workflows/*.yaml`; validate those with
 `kxm init --dry-run --json`.
 
-`kxm gate signal` on a KXM run ID (`run_` plus 32 hex digits) goes to the
-Runtime and passes `--recovery-action` through; on a hub webhook run it posts a
-signed callback that needs `KXM_WORKFLOW_ID` and the definition's signal
-secret. Reuse `--delivery-id` to retry one unchanged callback.
+`kxm gate signal` on a run this project's Runtime store holds goes to the
+Runtime and passes `--recovery-action` through; on a hub webhook run, including
+one with the same `run_` + 32-hex shape, it posts a signed callback that needs
+`KXM_WORKFLOW_ID` and the definition's signal secret. Reuse `--delivery-id` to retry one unchanged callback.
 
 ```bash
 kxm gate validate --file workflows.json --json

package/plugins/kxm/src/cli/roles.ts

@@ -19,6 +19,7 @@ import {
 } from "../role.ts";
 import { discoverKxmProjectRoot } from "../project-config.ts";
 import { ensureKxmSupervisor, kxmRuntimeRequest } from "../runtime-supervisor.ts";
+import { projectRuntimeOwnsRun } from "../runtime-store.ts";
 import { resumeWorkflowFromRuling, type WorkflowRun } from "../workflow.ts";
 import { print, printPlan, type CliIo, type Runtime } from "./types.ts";
 
@@ -547,9 +548,9 @@ export async function cmdRoleResume(
 
   const effectiveRuling = ruling?.trim() || "operator_ruling: waived and resumed";
 
-  // Check if it's a KXM run
+  // A run this project's Runtime owns; a hub workflow run of the same id shape falls through.
   const projectRoot = discoverKxmProjectRoot(runtime.cwd);
-  if (projectRoot && /^run_[a-f0-9]{32}$/i.test(runId)) {
+  if (projectRoot && projectRuntimeOwnsRun(projectRoot, runId, runtime.env)) {
     if (runtime.dryRun) {
       printPlan(
         runtime,

package/plugins/kxm/src/inbox.ts

@@ -1,10 +1,18 @@
+/** Announce an inbox request at most once per process. The id is claimed before the send, so a
+ * request read back from the hub and the same request arriving on the event stream cannot both
+ * announce it; a failed send releases the claim, so the request stays retryable. */
 export async function deliverInboxNotification(
   messageId: string,
   delivered: Set<string>,
   notify: () => Promise<void>,
 ): Promise<boolean> {
   if (delivered.has(messageId)) return false;
-  await notify();
   delivered.add(messageId);
+  try {
+    await notify();
+  } catch (error) {
+    delivered.delete(messageId);
+    throw error;
+  }
   return true;
 }

package/plugins/kxm/src/mcp-server.ts

@@ -11,7 +11,7 @@ import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 import { sessionTokenFixHint } from "./session-token-hint.ts";
 
-const VERSION = "0.7.100";
+const VERSION = "0.7.102";
 const CONFIGURE_PLUGIN = "/plugin configure kxm@kxm";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();
@@ -55,33 +55,24 @@ function sessionIdentity(): { projectDir: string; project: string; serverUrl: st
   };
 }
 
-async function onHubEvent(event: HubEvent): Promise<void> {
-  if (event.type === "cancelled" || event.type === "expired") {
-    inbox.delete(event.message.id);
-    notifiedInbox.delete(event.message.id);
-    return;
-  }
-  if (event.type !== "message") return;
-  const client = meshClient;
-  if (!client) return;
-  if (event.message.status === "queued") await client.acknowledge(event.message.id);
-  inbox.set(event.message.id, event.message);
+/** Tell the session about an inbox request on the channel, at most once per process. */
+async function announce(message: MessageRecord): Promise<void> {
   const meta: Record<string, string> = {
-    message_id: event.message.id,
-    from_agent: event.message.fromName,
-    delivery: event.message.delivery,
+    message_id: message.id,
+    from_agent: message.fromName,
+    delivery: message.delivery,
   };
-  if (event.message.correlationId) meta.correlation_id = event.message.correlationId;
-  await deliverInboxNotification(event.message.id, notifiedInbox, async () => {
+  if (message.correlationId) meta.correlation_id = message.correlationId;
+  await deliverInboxNotification(message.id, notifiedInbox, async () => {
     await mcp.notification({
       method: "notifications/claude/channel",
       params: {
         content: [
-          `Peer request from ${event.message.fromName}:`,
+          `Peer request from ${message.fromName}:`,
           "",
-          event.message.content,
+          message.content,
           "",
-          `When complete, call kxm_reply with messageId ${event.message.id}.`,
+          `When complete, call kxm_reply with messageId ${message.id}.`,
         ].join("\n"),
         meta,
       },
@@ -89,6 +80,36 @@ async function onHubEvent(event: HubEvent): Promise<void> {
   });
 }
 
+async function onHubEvent(client: HubClient, event: HubEvent): Promise<void> {
+  if (event.type === "cancelled" || event.type === "expired") {
+    inbox.delete(event.message.id);
+    notifiedInbox.delete(event.message.id);
+    return;
+  }
+  if (event.type !== "message") return;
+  if (event.message.status === "queued") await client.acknowledge(event.message.id);
+  inbox.set(event.message.id, event.message);
+  await announce(event.message);
+}
+
+/** A durable KXM_AGENT_NAME resumes its agent id, but the event stream replays only requests
+ * that agent has not acknowledged. One an earlier process acknowledged and never answered is
+ * still open on the hub, so it is read back here and announced like a pushed request: this
+ * session has not been told about it. The inbox is reconciled before anything is announced,
+ * so a request cancelled or expired while the list was in flight is dropped, not announced;
+ * its event may have gone to a stream that was not connected yet. Queued requests are left
+ * to the stream, which acknowledges them in order. */
+async function seedInbox(client: HubClient): Promise<void> {
+  for (const message of await client.listInbox()) {
+    if (message.status === "delivered" && !inbox.has(message.id)) inbox.set(message.id, message);
+  }
+  await reconcileInbox(client, inbox, notifiedInbox);
+  for (const messageId of [...inbox.keys()]) {
+    const message = inbox.get(messageId);
+    if (message) await announce(message);
+  }
+}
+
 async function startClient(project: string, serverUrl: string, name: string, authToken: string): Promise<HubClient> {
   const candidate = new HubClient({
     serverUrl,
@@ -99,7 +120,9 @@ async function startClient(project: string, serverUrl: string, name: string, aut
     authToken,
   });
   try {
-    await candidate.start(onHubEvent);
+    await candidate.start((event) => onHubEvent(candidate, event));
+    // A tool call waits for the seeded inbox: `starting` stays pending until this returns.
+    await seedInbox(candidate);
     meshClient = candidate;
     return candidate;
   } catch (error) {

package/plugins/kxm/src/runtime-store.ts

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { DatabaseSync } from "./sqlite.ts";
+import { DatabaseSync, openReadOnlyDatabase } from "./sqlite.ts";
 import { KxmConfigError, validateCoordinator, validateDriveReceipt, validateIntakeMessage, validateRunEvent, kxmCanonicalJson, type JsonValue, type KxmConfigIssue, type KxmConfigOptions } from "./project-config.ts";
 import { kxmUserStateRoot } from "./bindings.ts";
 import { deriveKxmSyncEvent, kxmSyncEventBytes, KxmSyncRedactor } from "./sync-transform.ts";
@@ -59,13 +59,13 @@ export function kxmProjectRunEventsPath(projectRoot: string, env: NodeJS.Process
 /**
  * Whether this project's Runtime event store holds `runId`. Hub workflow runs and Runtime
  * runs share the `run_<32 hex>` shape, so a command addressed by run id asks the owning
- * store instead of guessing from the id. Read-only; a project whose Runtime never ran
- * owns no runs.
+ * store instead of guessing from the id. Read-only and leaves no sidecars, so a dry run
+ * can ask; a project whose Runtime never ran owns no runs.
  */
 export function projectRuntimeOwnsRun(projectRoot: string, runId: string, env: NodeJS.ProcessEnv): boolean {
   const path = kxmProjectRunEventsPath(projectRoot, env);
   if (!existsSync(path)) return false;
-  const database = new DatabaseSync(path, { readOnly: true });
+  const database = openReadOnlyDatabase(path);
   try {
     database.exec("PRAGMA busy_timeout = 5000");
     return database.prepare("SELECT 1 FROM runs WHERE run_id = ?").get(runId) !== undefined;