@kontextmind/kxm 0.7.53 → 0.7.55

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

@@ -12,7 +12,6 @@ import {
   type KxmInitializationPlan,
 } from "../project-config.ts";
 import { initializeKxmProject } from "../init.ts";
-import { applyKxmMigration, planKxmMigration, verifyKxmMigration } from "../migrate.ts";
 import { diffKxmProjectAgainstRevision, formatKxmPermissionDiff } from "../permission.ts";
 import { readKxmLocalBindings, kxmUserStateRoot } from "../bindings.ts";
 import { loadKxmProject } from "../project-config.ts";
@@ -151,8 +150,8 @@ export async function cmdKxmInit(
     if (runtime.dryRun) {
       return finishInit(0, `init plan: ${initialized.plan.mode}`);
     }
-    const next = initialized.plan.mode === "migrate"
-      ? "legacy state requires reviewed migration; conversion is not available in this implementation slice"
+    const next = initialized.plan.mode === "legacy"
+      ? "legacy state is not migrated by this build: initialise a fresh project directory and copy the YAML definitions you want to keep"
       : initialized.repairPlan?.issues.length
         ? "managed-template repair is blocked by conflicts or authority changes; local files were preserved"
         : "partial or provenance-free KXM state requires explicit repair; no files were overwritten";
@@ -176,136 +175,6 @@ export async function cmdKxmInit(
   }
 }
 
-export async function cmdKxmMigratePlan(runtime: Runtime): Promise<number> {
-  if (runtime.workspaceFlag !== undefined) {
-    print(runtime.io, runtime.json, {
-      ok: false,
-      command: "migrate plan",
-      error: "workspace_option_unsupported",
-    }, "kxm migrate discovers the authoritative Git root from the current directory; --workspace is not supported");
-    return 2;
-  }
-  try {
-    const result = planKxmMigration(runtime.cwd, {});
-    const ambiguities = (result.plan.ambiguities as Array<{ key: string; message: string }> | undefined) ?? [];
-    const unmapped = (result.plan.unmapped as unknown[] | undefined) ?? [];
-    const payload = {
-      ok: result.plan.canApply === true,
-      command: "migrate plan",
-      plan: result.plan,
-      plannedOnly: result.plan.canApply !== true,
-    };
-    if (result.plan.canApply === true) {
-      print(runtime.io, runtime.json, payload, `migration plan: ${ambiguities.length} ambiguities, ${unmapped.length} preserved fields; ready to apply`);
-      return 0;
-    }
-    print(
-      runtime.io,
-      runtime.json,
-      payload,
-      `migration plan requires ${ambiguities.length} reviewed decision(s):\n${ambiguities.map((candidate) => `  - ${candidate.key}: ${candidate.message}`).join("\n")}`,
-    );
-    return 1;
-  } catch (error) {
-    if (error instanceof KxmConfigError) {
-      print(runtime.io, runtime.json, { ok: false, command: "migrate plan", error: "migration_plan_failed", issues: error.issues }, `migration plan failed: ${error.message}`);
-      return 1;
-    }
-    print(runtime.io, runtime.json, { ok: false, command: "migrate plan", error: "migration_plan_io_failed" }, "migration plan failed because a local filesystem operation did not complete");
-    return 1;
-  }
-}
-
-export async function cmdKxmMigrateApply(runtime: Runtime, options: { decisions?: string | undefined; projectId?: string | undefined; name?: string | undefined }): Promise<number> {
-  if (runtime.workspaceFlag !== undefined) {
-    print(runtime.io, runtime.json, {
-      ok: false,
-      command: "migrate apply",
-      error: "workspace_option_unsupported",
-    }, "kxm migrate discovers the authoritative Git root from the current directory; --workspace is not supported");
-    return 2;
-  }
-  try {
-    const result = applyKxmMigration(runtime.cwd, {
-      ...(options.decisions?.trim() ? { decisionsFile: options.decisions.trim() } : {}),
-      ...(options.projectId?.trim() ? { projectId: options.projectId.trim() } : {}),
-      ...(options.name?.trim() ? { projectName: options.name.trim() } : {}),
-      localStateRoot: kxmUserStateRoot({ env: runtime.env }),
-      dryRun: runtime.dryRun,
-    });
-    const payload = {
-      ok: result.action !== "planned" || (runtime.dryRun === true && result.plan?.canApply === true),
-      command: "migrate apply",
-      action: result.action,
-      files: result.files,
-      ...(result.configRevision ? { configRevision: result.configRevision } : {}),
-      ...(result.receiptPath ? { receiptPath: result.receiptPath } : {}),
-      plannedOnly: result.action === "planned",
-    };
-    if (result.action === "applied") {
-      print(runtime.io, runtime.json, payload, `migration applied: ${result.files.length} resources installed, receipt at ${result.receiptPath ?? ""}`);
-      return 0;
-    }
-    if (result.action === "already-migrated") {
-      print(runtime.io, runtime.json, payload, "migration receipt already exists; nothing to apply");
-      return 0;
-    }
-    if (runtime.dryRun && result.plan?.canApply === true) {
-      print(runtime.io, runtime.json, payload, `migration dry run: ${result.files.length} resources would be installed`);
-      return 0;
-    }
-    const ambiguities = (result.plan?.ambiguities as Array<{ key: string; message: string }> | undefined) ?? [];
-    print(
-      runtime.io,
-      runtime.json,
-      { ...payload, plan: result.plan },
-      `migration blocked by ${ambiguities.length} unresolved decision(s); review 'kxm migrate plan' and pass --decisions:\n${ambiguities.map((candidate) => `  - ${candidate.key}: ${candidate.message}`).join("\n")}`,
-    );
-    return 1;
-  } catch (error) {
-    if (error instanceof KxmConfigError) {
-      print(runtime.io, runtime.json, { ok: false, command: "migrate apply", error: "migration_apply_failed", issues: error.issues }, `migration apply failed: ${error.message}`);
-      return 1;
-    }
-    print(runtime.io, runtime.json, { ok: false, command: "migrate apply", error: "migration_apply_io_failed" }, "migration apply failed because a local filesystem operation did not complete");
-    return 1;
-  }
-}
-
-export async function cmdKxmMigrateVerify(runtime: Runtime): Promise<number> {
-  if (runtime.workspaceFlag !== undefined) {
-    print(runtime.io, runtime.json, {
-      ok: false,
-      command: "migrate verify",
-      error: "workspace_option_unsupported",
-    }, "kxm migrate discovers the authoritative Git root from the current directory; --workspace is not supported");
-    return 2;
-  }
-  let result: ReturnType<typeof verifyKxmMigration>;
-  try {
-    result = verifyKxmMigration(runtime.cwd, {});
-  } catch (error) {
-    if (error instanceof KxmConfigError) {
-      print(runtime.io, runtime.json, { ok: false, command: "migrate verify", error: "migration_verify_failed", issues: error.issues }, `migration verification failed: ${error.message}`);
-      return 1;
-    }
-    print(runtime.io, runtime.json, { ok: false, command: "migrate verify", error: "migration_verify_io_failed" }, "migration verification failed because a local filesystem operation did not complete");
-    return 1;
-  }
-  const payload = {
-    ok: result.ok,
-    command: "migrate verify",
-    ...(result.configRevision ? { configRevision: result.configRevision } : {}),
-    issues: result.issues,
-  };
-  if (result.ok) {
-    print(runtime.io, runtime.json, payload, `migration receipt verified: legacy sources unchanged, target bundle matches ${result.configRevision ?? ""}`);
-    return 0;
-  }
-  print(runtime.io, runtime.json, payload, `migration verification failed:\n${result.issues.map((issue) => `  - ${issue.file}: ${issue.code}: ${issue.message}`).join("\n")}`);
-  return 1;
-}
-
 export async function cmdBackup(runtime: Runtime, options: { out?: string | undefined }): Promise<number> {
   try {
     const { manifest, outDir } = createBackup({

package/plugins/kxm/src/cli.ts

@@ -7,7 +7,7 @@
  * - Role & workflow governance (`kxm role`, `kxm workflow`, `kxm gate`, `kxm signal`)
  * - Task & goal management (`kxm goal`, `kxm task`, `kxm suggest`, `kxm studio`)
  * - Knowledge, skills, and memory (`kxm context`, `kxm skills`, `kxm memory`)
- * - KXM runtime & initialization (`kxm init`, `kxm migrate`, `kxm trust`, `kxm run`, `kxm harness`)
+ * - KXM runtime & initialization (`kxm init`, `kxm trust`, `kxm run`, `kxm harness`)
  * - Hub, workers, and dashboard (`kxm hub`, `kxm worker`, `kxm dash`, `kxm session`, `kxm auth`)
  * - System, update, and configuration (`kxm update`, `kxm config`, `kxm completion`, `kxm improve`)
  */
@@ -98,10 +98,7 @@ import {
 
 import {
   cmdKxmInit,
-  cmdKxmMigratePlan,
-  cmdKxmMigrateApply,
-  cmdKxmMigrateVerify,
-  cmdBackup,
+cmdBackup,
   cmdRestore,
   cmdKxmTrust,
   cmdKxmRun,
@@ -334,7 +331,7 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
     .helpCommand("help", "Show help");
   addGlobalOptions(program);
 
-  program.command("init").description("Create, validate, or plan migration of a KXM project")
+  program.command("init").description("Create, validate, repair, or join a KXM project")
     .option("--json", "Print machine-readable JSON")
     .option("--dry-run", "Plan without making changes")
     .option("--name <name>", "Project display name for a new project")
@@ -347,24 +344,6 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
       });
     });
 
-  const migrate = addGlobalOptions(program.command("migrate").description("Plan, apply, and verify legacy JSON configuration migration"));
-  migrate.helpCommand("help", "Show migrate help");
-  addGlobalOptions(migrate.command("plan").description("Compute the deterministic legacy-to-KXM migration plan without writes"))
-    .action(async function migratePlanAction(this: Command) {
-      result.code = await cmdKxmMigratePlan(runtimeFrom(ctx, this));
-    });
-  addGlobalOptions(migrate.command("apply").description("Install a reviewed migration with a hash-linked receipt"))
-    .option("--decisions <file>", "Reviewed kxm.migration-decision.v1 YAML file")
-    .option("--project-id <id>", "Stable project ID for controlled provisioning")
-    .option("--name <name>", "Project display name")
-    .action(async function migrateApplyAction(this: Command, options: { decisions?: string; projectId?: string; name?: string }) {
-      result.code = await cmdKxmMigrateApply(runtimeFrom(ctx, this), options);
-    });
-  addGlobalOptions(migrate.command("verify").description("Verify a migration receipt against current sources and target bundle"))
-    .action(async function migrateVerifyAction(this: Command) {
-      result.code = await cmdKxmMigrateVerify(runtimeFrom(ctx, this));
-    });
-
   addGlobalOptions(program.command("backup").description("Create a verified SQLite backup of all stores with a hashed manifest"))
     .option("--out <dir>", "Directory to write backup and manifest")
     .action(async function backupAction(this: Command, options: { out?: string }) {

package/plugins/kxm/src/database.ts

@@ -179,7 +179,7 @@ export function openDatabase(file: string, description: string, spec: DatabaseSc
       throw databaseError(
         "runtime_schema_outdated",
         file,
-        `${description} is schema version ${version}; this build requires ${spec.version}. Delete the state file (or re-run \`kxm init\`) to start fresh — upgrading old state in place is deliberately unsupported`,
+        `${description} is schema version ${version}; this build requires ${spec.version}. Delete the state file to start fresh and let its owning process recreate it (\`kxm hub start\` for hub state, the Runtime for registry/event stores); \`kxm init\` is project-only and rebuilds no database — upgrading old state in place is deliberately unsupported`,
       );
     }
 

package/plugins/kxm/src/init.ts

@@ -207,9 +207,18 @@ function initializeKxmProjectAtGitRoot(
   const loaderOptions = configOptions(options, repositoryBindings);
   const transactionOptions = repairOptions(options, repositoryBindings);
 
+  const plan = planKxmInitialization(start, loaderOptions);
+  if (plan.mode === "legacy") {
+    // Classified **before** any transaction or lock work. A legacy tree used to reach the
+    // recovery branch first, so an interrupted create/repair journal made ordinary init
+    // acquire the project mutation lock, clean or resume the transaction, and write files
+    // while reporting `mode: "legacy"`. Nothing is resumed, cleaned, or written here: the
+    // pending journal stays exactly as it is until the legacy inputs are dealt with.
+    return { action: "planned", plan, ...(plan.projectRoot ? { projectRoot: plan.projectRoot } : {}), files: [] };
+  }
+
   if (hasKxmInitTransaction(gitRoot)) {
     const operation = inspectKxmInitTransaction(gitRoot, options.schemasDir);
-    const plan = planKxmInitialization(start, loaderOptions);
     if (!operation) {
       if (options.dryRun) return { action: "planned", plan, projectRoot: gitRoot, resumePending: true, files: [] };
       if (!mutationLock) throw new Error("project mutation lock is required to clean an empty transaction");
@@ -267,11 +276,6 @@ function initializeKxmProjectAtGitRoot(
     }
   }
 
-  const plan = planKxmInitialization(start, loaderOptions);
-  if (plan.mode === "migrate") {
-    return { action: "planned", plan, ...(plan.projectRoot ? { projectRoot: plan.projectRoot } : {}), files: [] };
-  }
-
   if (plan.mode === "repair") {
     const projectRoot = plan.projectRoot ?? gitRoot;
     let templateRepair: KxmTemplateRepairPlan | undefined;

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.53";
+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";