@kontextmind/kxm 0.7.54 → 0.7.55

package/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
       "name": "kxm",
       "source": "./plugins/kxm",
       "description": "Durable workflows, peer agents, and kxm tui",
-      "version": "0.7.54",
+      "version": "0.7.55",
       "category": "development",
       "tags": ["kxm", "multi-agent", "workflows", "mcp"]
     }

package/CHANGELOG.md

@@ -35,6 +35,30 @@ All notable user-facing changes are documented here. The project follows [Semant
 
 ### Changed
 
+- **A Pi producer reply can no longer mint its own success.** `determineOutcome` scanned the
+  reply for any declared outcome *word* and, failing that, returned `passed`. So
+  `"the gate did not pass, so I would not call this passed"` settled the step as passed — the
+  word was all it took — and an empty or prose-only reply was passed by default. Only a declared
+  result counts now: a reply that is one JSON object, or prose carrying an explicit
+  `{"outcome": "…"}` block, and only when the step declares that outcome. Anything else is
+  `failed`; an undeclared value still lands in `outcome_unknown` and terminates as `failed`, so a
+  step without a `failed` transition cannot pass on a bad reply either. This matches the rule the
+  one-shot producer already enforced, and `docs/contracts/lifecycles.md` now states it where
+  `result_recorded` is defined. Three usage-capture fixtures that had been replying in prose now
+  declare their result, which is what they were always supposed to do; the new test in
+  `test/core/pi-producer.test.ts` covers prose, empty, out-of-vocabulary, and both accepted
+  structured shapes. Review of that first cut found two more ways to mint success, both now
+  closed: a result block was matched **anywhere** in the reply, so
+  `Example: {"outcome": "passed"}. Actual result: {"outcome": "failed"}` returned `passed`;
+  a declaration is now a standalone JSON object — the whole reply, or one object on its own
+  line, with the **last** such object winning so an illustration cannot outrank the answer, and
+  the whole reply settling `failed` when anything after that line still looks like an outcome
+  key, because at that point the producer cannot tell which declaration was meant.
+  And cancellation fell through to `allowedOutcomes[0]` when a step declared neither
+  `cancelled` nor `failed`, so aborting a `passed`-only step reported `passed`; a cancel now
+  reports `cancelled` unconditionally and the engine terminates it `failed` when the step
+  does not declare that outcome.
+
 - **`kxm migrate` is gone, and so is the state that only it could unlock.** Deleting the
   migration lanes left a converter with nothing to convert into: `plugins/kxm/src/migrate.ts`
   (1,848 lines), its 1,598-line suite, the `migrate plan|apply|verify` commands, the

package/docs/contracts/lifecycles.md

@@ -105,6 +105,22 @@ created → accepted → dispatched → executing → result_recorded → termin
 | `blocked_uncertain` | A dependent effect cannot be reconciled safely |
 | `terminal` | The logical assignment outcome is final and immutable: passed, failed, or cancelled |
 
+A producer reply becomes a terminal outcome **only** through a declared result: the reply is
+one JSON object, or it carries a `{"outcome": "…"}` object **on a line of its own**. With more
+than one such line the last one is the answer; if anything after it still looks like an outcome
+key — an inline `Actual result: {"outcome": "failed"}`, a pretty-printed object, a second
+mention — the reply is **ambiguous and settles `failed`**, because guessing which declaration
+was meant is the behaviour this rule removes. Ordinary trailing prose (a sign-off, a token
+count) does not disturb a declared result.
+
+Naming an outcome *word* anywhere in a reply is not a result — `"the gate did not pass, so I
+would not call this passed"` must not advance a step — and an empty or unstructured reply is
+never treated as success. A declared outcome outside the step's declared set is not accepted
+either:
+the assignment is recorded `outcome_unknown` and terminates as `failed`, which is also what
+happens when a step declares no `failed` transition. Producers do not guess on the model's
+behalf, and no fallback path mints `passed`.
+
 `assignmentId` remains stable. A retry moves the nonterminal assignment through
 `retry_pending` to `accepted`, creates a new `attemptId`, and never rewrites or
 exits the previous attempt's terminal state. The effective

package/docs/test-matrix.md

@@ -13,6 +13,7 @@ npm run verify
 
 | Feature | Automated evidence |
 |---|---|
+| Structured-result settlement only: outcome words in prose, empty replies, and outcomes outside the step's declared set all fail closed; a declared JSON object and a JSON result block inside prose both settle, and the engine records `outcome_unknown` and terminates `failed` | `test/core/pi-producer.test.ts`, `test/core/engine.test.ts` |
 | Health, readiness, metrics, request IDs, security headers | `test/core/hub-api.test.ts` |
 | Shared and per-project authentication, project isolation | `test/core/hub-api.test.ts` |
 | Registration, discovery, presence, stale detection, identity resumption | `test/core/hub-api.test.ts`, `test/core/hub.test.ts` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontextmind/kxm",
-  "version": "0.7.54",
+  "version": "0.7.55",
   "description": "KXM local-first multi-agent orchestration and operator dashboard",
   "type": "module",
   "author": "KontextMind",

package/plugins/kxm/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "kxm",
   "displayName": "KXM",
-  "version": "0.7.54",
+  "version": "0.7.55",
   "description": "Headless multi-agent orchestration, durable workflows, and a live operator dashboard for Pi and Claude Code",
   "author": {
     "name": "KontextMind",

package/plugins/kxm/dist/mcp-server.js

@@ -17121,7 +17121,7 @@ async function deliverInboxNotification(messageId, delivered, notify) {
 }
 
 // plugins/kxm/src/mcp-server.ts
-var VERSION = "0.7.54";
+var VERSION = "0.7.55";
 var inbox = /* @__PURE__ */ new Map();
 var notifiedInbox = /* @__PURE__ */ new Set();
 var meshClient;

package/plugins/kxm/dist/runtime.js

@@ -27913,20 +27913,37 @@ function extractText(content) {
   }
   return "";
 }
-function determineOutcome2(text, allowedOutcomes) {
-  const normalized = text.trim();
-  const jsonMatch = /"outcome"\s*:\s*"([^"]+)"/.exec(normalized);
-  if (jsonMatch && allowedOutcomes.includes(jsonMatch[1])) {
-    return jsonMatch[1];
-  }
-  for (const outcome of allowedOutcomes) {
-    const regex = new RegExp(`\\b${outcome}\\b`, "i");
-    if (regex.test(normalized)) {
-      return outcome;
-    }
+function asJsonObject2(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
   }
-  if (allowedOutcomes.includes("passed")) return "passed";
-  return allowedOutcomes[0] ?? "completed";
+}
+function outcomeField(value) {
+  const outcome = value.outcome;
+  return typeof outcome === "string" ? outcome : void 0;
+}
+function declaredOutcomeOf(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return void 0;
+  const whole = asJsonObject2(trimmed);
+  if (whole) return outcomeField(whole);
+  const lines = trimmed.split(/\r?\n/);
+  let declaration;
+  for (let index = 0; index < lines.length; index += 1) {
+    const outcome = outcomeField(asJsonObject2(lines[index].trim()) ?? {});
+    if (outcome !== void 0) declaration = { index, outcome };
+  }
+  if (!declaration) return void 0;
+  const tail = lines.slice(declaration.index + 1).join("\n");
+  if (/"outcome"\s*:/.test(tail)) return void 0;
+  return declaration.outcome;
+}
+function determineOutcome2(text, allowedOutcomes) {
+  const declared = declaredOutcomeOf(text);
+  return declared !== void 0 && allowedOutcomes.includes(declared) ? declared : "failed";
 }
 var PiSession = class {
   key;
@@ -28056,7 +28073,7 @@ var PiSession = class {
       const isAborted = active.aborted || active.signal?.aborted;
       let outcome;
       if (isAborted) {
-        outcome = active.allowedOutcomes.includes("cancelled") ? "cancelled" : active.allowedOutcomes.includes("failed") ? "failed" : active.allowedOutcomes[0];
+        outcome = "cancelled";
       } else {
         outcome = determineOutcome2(active.text, active.allowedOutcomes);
       }
@@ -28108,8 +28125,7 @@ var PiSession = class {
       throw new Error("pi_session_busy");
     }
     if (signal?.aborted) {
-      const outcome = allowedOutcomes.includes("cancelled") ? "cancelled" : allowedOutcomes.includes("failed") ? "failed" : allowedOutcomes[0];
-      return { outcome, text: "aborted", usage: {} };
+      return { outcome: "cancelled", text: "aborted", usage: {} };
     }
     this.status = "busy";
     return new Promise((resolve8, reject) => {

package/plugins/kxm/package.json

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

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

@@ -8,7 +8,7 @@ import { AGENT_COMMANDS_MAP, enforceToolPolicy, getMcpTools, reconcileInbox } fr
 import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 
-const VERSION = "0.7.54";
+const VERSION = "0.7.55";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();
 let meshClient: HubClient | undefined;

package/plugins/kxm/src/pi-producer.ts

@@ -82,20 +82,62 @@ function extractText(content: unknown): string {
   return "";
 }
 
-function determineOutcome(text: string, allowedOutcomes: readonly string[]): string {
-  const normalized = text.trim();
-  const jsonMatch = /"outcome"\s*:\s*"([^"]+)"/.exec(normalized);
-  if (jsonMatch && allowedOutcomes.includes(jsonMatch[1]!)) {
-    return jsonMatch[1]!;
+function asJsonObject(text: string): Record<string, unknown> | undefined {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : undefined;
+  } catch {
+    return undefined;
   }
-  for (const outcome of allowedOutcomes) {
-    const regex = new RegExp(`\\b${outcome}\\b`, "i");
-    if (regex.test(normalized)) {
-      return outcome;
-    }
+}
+
+function outcomeField(value: Record<string, unknown>): string | undefined {
+  const outcome = value.outcome;
+  return typeof outcome === "string" ? outcome : undefined;
+}
+
+/**
+ * The result a reply actually declares, or `undefined` when it declares none.
+ *
+ * Two shapes count: the whole reply is one JSON object, or a **standalone** result object on a
+ * line of its own — and when there is more than one of those, the **last** one wins, because
+ * that is where a reply puts its answer after showing an example. If anything in the tail after
+ * that declaration still looks like an outcome key, the reply is **ambiguous and settles
+ * `failed`**. What is deliberately not accepted: an outcome *word* anywhere in prose, and an
+ * object embedded mid-sentence, so
+ * `Example: {"outcome": "passed"}. Actual result: {"outcome": "failed"}` declares nothing at
+ * all and settles as `failed` rather than letting the illustration outrank the answer.
+ */
+function declaredOutcomeOf(text: string): string | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  const whole = asJsonObject(trimmed);
+  if (whole) return outcomeField(whole);
+  const lines = trimmed.split(/\r?\n/);
+  let declaration: { index: number; outcome: string } | undefined;
+  for (let index = 0; index < lines.length; index += 1) {
+    const outcome = outcomeField(asJsonObject(lines[index]!.trim()) ?? {});
+    if (outcome !== undefined) declaration = { index, outcome };
   }
-  if (allowedOutcomes.includes("passed")) return "passed";
-  return allowedOutcomes[0] ?? "completed";
+  if (!declaration) return undefined;
+  // Ambiguity after the declaration fails closed. Anything in the tail that still looks like
+  // an outcome key — an inline `Actual result: {"outcome": "failed"}` on the next line, a
+  // pretty-printed object, or a second mention — means we cannot tell which one the reply is
+  // reporting, and guessing is exactly the behaviour this function exists to remove. Trailing
+  // prose that says nothing about outcomes is fine, which is what lets a real reply put its
+  // usage or sign-off after the result block.
+  const tail = lines.slice(declaration.index + 1).join("\n");
+  if (/"outcome"\s*:/.test(tail)) return undefined;
+  return declaration.outcome;
+}
+
+function determineOutcome(text: string, allowedOutcomes: readonly string[]): string {
+  // Structured result only. What does **not** count: an outcome *word* anywhere in the text —
+  // "the tests did not pass" used to settle a step as `passed` — and an empty or unstructured
+  // reply, which used to default to success. Undeclared here means `failed`; if the step does
+  // not declare `failed` the engine records `outcome_unknown` and terminates as `failed` anyway.
+  const declared = declaredOutcomeOf(text);
+  return declared !== undefined && allowedOutcomes.includes(declared) ? declared : "failed";
 }
 
 export class PiSession {
@@ -255,9 +297,11 @@ export class PiSession {
       const isAborted = active.aborted || active.signal?.aborted;
       let outcome: string;
       if (isAborted) {
-        outcome = active.allowedOutcomes.includes("cancelled")
-          ? "cancelled"
-          : (active.allowedOutcomes.includes("failed") ? "failed" : active.allowedOutcomes[0]!);
+        // A cancel is a cancel. The old chain fell through to `allowedOutcomes[0]` when the
+        // step declared neither `cancelled` nor `failed`, so aborting a step whose only
+        // declared outcome was `passed` reported `passed`. Returning `cancelled` instead lets
+        // the engine record `outcome_unknown` and terminate `failed` — never a borrowed success.
+        outcome = "cancelled";
       } else {
         outcome = determineOutcome(active.text, active.allowedOutcomes);
       }
@@ -316,8 +360,8 @@ export class PiSession {
       throw new Error("pi_session_busy");
     }
     if (signal?.aborted) {
-      const outcome = allowedOutcomes.includes("cancelled") ? "cancelled" : (allowedOutcomes.includes("failed") ? "failed" : allowedOutcomes[0]!);
-      return { outcome, text: "aborted", usage: {} };
+      // Same rule as the in-flight abort: never fall back to the first declared outcome.
+      return { outcome: "cancelled", text: "aborted", usage: {} };
     }
 
     this.status = "busy";