@kontextmind/kxm 0.7.52 → 0.7.54

package/plugins/kxm/dist/server.js

@@ -11504,20 +11504,11 @@ function openDatabase(file, description, spec) {
       database.exec(spec.schema);
       database.exec(`PRAGMA user_version = ${spec.version}`);
     } else if (version < spec.version) {
-      let currentVersion = version;
-      while (currentVersion < spec.version) {
-        const step = spec.migrations?.find((m) => m.fromVersion === currentVersion);
-        if (!step) {
-          throw databaseError(
-            "runtime_schema_outdated",
-            file,
-            `${description} schema version ${version} is older than ${spec.version}; no migration lane, backup and restore remain E6`
-          );
-        }
-        step.migrate(database);
-        currentVersion = step.toVersion;
-        database.exec(`PRAGMA user_version = ${currentVersion}`);
-      }
+      throw databaseError(
+        "runtime_schema_outdated",
+        file,
+        `${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 \u2014 upgrading old state in place is deliberately unsupported`
+      );
     }
     if (spec.tables) {
       verifyExpectedTables(database, file, description, spec.tables);
@@ -11683,100 +11674,10 @@ var HUB_STORE_SCHEMA_V3 = `
   ) STRICT;
   CREATE INDEX IF NOT EXISTS context_items_project ON context_items(project);
 `;
-var HUB_STORE_MIGRATIONS = Object.freeze([
-  {
-    fromVersion: 1,
-    toVersion: 2,
-    migrate: (db) => {
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS agents (
-          id TEXT PRIMARY KEY,
-          record TEXT NOT NULL
-        ) STRICT;
-        CREATE TABLE IF NOT EXISTS messages (
-          id TEXT PRIMARY KEY,
-          record TEXT NOT NULL
-        ) STRICT;
-        CREATE TABLE IF NOT EXISTS workflow_runs (
-          id TEXT PRIMARY KEY,
-          definition_id TEXT NOT NULL,
-          delivery_id TEXT NOT NULL,
-          record TEXT NOT NULL,
-          UNIQUE(definition_id, delivery_id)
-        ) STRICT;
-        CREATE TABLE IF NOT EXISTS workflow_journal (
-          id TEXT PRIMARY KEY,
-          run_id TEXT NOT NULL,
-          category TEXT NOT NULL,
-          area TEXT NOT NULL,
-          record TEXT NOT NULL
-        ) STRICT;
-        CREATE INDEX IF NOT EXISTS workflow_journal_run_id ON workflow_journal(run_id);
-      `);
-    }
-  },
-  {
-    fromVersion: 2,
-    toVersion: 3,
-    migrate: (db) => {
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS agents (
-          id TEXT PRIMARY KEY,
-          record TEXT NOT NULL
-        ) STRICT;
-        CREATE TABLE IF NOT EXISTS messages (
-          id TEXT PRIMARY KEY,
-          record TEXT NOT NULL
-        ) STRICT;
-        CREATE TABLE IF NOT EXISTS workflow_runs (
-          id TEXT PRIMARY KEY,
-          definition_id TEXT NOT NULL,
-          delivery_id TEXT NOT NULL,
-          record TEXT NOT NULL,
-          UNIQUE(definition_id, delivery_id)
-        ) STRICT;
-        CREATE TABLE IF NOT EXISTS workflow_journal (
-          id TEXT PRIMARY KEY,
-          run_id TEXT NOT NULL,
-          category TEXT NOT NULL,
-          area TEXT NOT NULL,
-          record TEXT NOT NULL
-        ) STRICT;
-        CREATE INDEX IF NOT EXISTS workflow_journal_run_id ON workflow_journal(run_id);
-        CREATE TABLE IF NOT EXISTS context_items (
-          id TEXT PRIMARY KEY,
-          project TEXT NOT NULL,
-          kind TEXT NOT NULL,
-          record TEXT NOT NULL
-        ) STRICT;
-        CREATE INDEX IF NOT EXISTS context_items_project ON context_items(project);
-        CREATE UNIQUE INDEX IF NOT EXISTS messages_from_idempotency
-        ON messages(
-          json_extract(record, '$.from'),
-          json_extract(record, '$.idempotencyKey')
-        ) WHERE json_extract(record, '$.idempotencyKey') IS NOT NULL;
-        CREATE INDEX IF NOT EXISTS messages_to_seq
-        ON messages(
-          json_extract(record, '$.to'),
-          COALESCE(json_extract(record, '$.seq'), 0)
-        );
-        CREATE TABLE IF NOT EXISTS consumer_cursors (
-          agent_id TEXT PRIMARY KEY,
-          cursor INTEGER NOT NULL
-        ) STRICT;
-        CREATE TABLE IF NOT EXISTS agent_sequences (
-          agent_id TEXT PRIMARY KEY,
-          next_seq INTEGER NOT NULL
-        ) STRICT;
-      `);
-    }
-  }
-]);
 var HUB_STORE_SCHEMA_SPEC = Object.freeze({
   schema: HUB_STORE_SCHEMA_V3,
   version: HUB_STORE_SCHEMA_VERSION,
-  tables: HUB_STORE_TABLES,
-  migrations: HUB_STORE_MIGRATIONS
+  tables: HUB_STORE_TABLES
 });
 var MessageMap = class extends Map {
   store;

package/plugins/kxm/package.json

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

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

@@ -14,7 +14,7 @@ authority, admit writers, or replace `.kxm/roster.yaml` trusted policy.
 
 The KXM Agent Skills suite is organized by functional areas:
 
-- **Project Setup**: Use `kxm-project-setup` for `init`, `migrate`, `trust`, `config`, `completion`
+- **Project Setup**: Use `kxm-project-setup` for `init`, `trust`, `config`, `completion`
 - **Harness & Auth**: Use `kxm-harness-auth` for `harness`, `auth`, `update`, `runtime`, `agent`
 - **Hub Operations**: Use `kxm-hub-ops` for `hub`, `backup`, `restore`
 - **Session Management**: Use `kxm-session` for `session`, `dash`, `studio`

package/plugins/kxm/skills/kxm-project-setup/SKILL.md

@@ -1,21 +1,19 @@
 ---
 name: kxm-project-setup
-description: Initialize, migrate, review permission changes, configure, and add shell completion for KXM projects.
+description: Initialize, review permission changes, configure, and add shell completion for KXM projects.
 ---
 
 # KXM Project Setup
 
 Use the current CLI. Inspect `kxm <command> --help` before mutations. Do not
-invent `force`, domain-trust, or extra migrate verbs.
+invent `force`, domain-trust, or legacy-migration verbs: this build converts
+nothing.
 
 ## Commands
 
 | Command | Purpose | Options / arguments |
 |---|---|---|
-| `kxm init` | Create, validate, or plan migration of a KXM project | `--json`, `--dry-run`, `--name`, `--project-id`, `--repository <id=absolute-path>` |
-| `kxm migrate plan` | Compute the legacy-to-KXM plan without writes | `--json` |
-| `kxm migrate apply` | Install a reviewed migration with a hash-linked receipt | `--decisions <file>`, `--project-id`, `--name` |
-| `kxm migrate verify` | Verify a migration receipt | `--json` |
+| `kxm init` | Create, validate, repair, or join a KXM project (a legacy tree is reported as `mode: "legacy"` and never converted) | `--json`, `--dry-run`, `--name`, `--project-id`, `--repository <id=absolute-path>` |
 | `kxm trust diff` | Structured permission diff against a Git revision | `--base <revision>` |
 | `kxm trust check` | Fail when the working tree expands permissions | `--base <revision>` |
 | `kxm config get <key>` | Get a configuration value | `--json` |
@@ -25,7 +23,6 @@ invent `force`, domain-trust, or extra migrate verbs.
 
 ```bash
 kxm init --dry-run --json
-kxm migrate plan --json
 kxm trust diff --base HEAD --json
 kxm config list --json
 kxm completion install

package/plugins/kxm/src/autocomplete.ts

@@ -2,7 +2,6 @@ export type SupportedShell = "bash" | "zsh" | "fish";
 
 const TOP_LEVEL_COMMANDS = [
   "init",
-  "migrate",
   "backup",
   "restore",
   "run",
@@ -36,7 +35,6 @@ const TOP_LEVEL_COMMANDS = [
 
 const SUBCOMMANDS: Record<string, string[]> = {
   runs: ["status", "cancel", "list"],
-  migrate: ["plan", "apply", "verify"],
   harness: ["list"],
   runtime: ["start", "status", "stop"],
   trust: ["diff", "check"],
@@ -132,7 +130,6 @@ _kxm() {
   local -a commands
   commands=(
     'init:Create or validate a KXM project'
-    'migrate:Plan, apply, and verify legacy configuration migration'
     'backup:Create a verified SQLite backup manifest'
     'restore:Restore SQLite stores from a backup manifest'
     'run:Create a KXM workflow run'

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

@@ -14,17 +14,10 @@ import { basename, dirname, join, resolve } from "node:path";
 import { DatabaseSync } from "./sqlite.ts";
 import { KxmConfigError, type KxmConfigIssue } from "./project-config.ts";
 
-export interface DatabaseMigrationStep {
-  fromVersion: number;
-  toVersion: number;
-  migrate: (database: DatabaseSync) => void;
-}
-
 export interface DatabaseSchemaSpec {
   schema: string;
   version: number;
   tables?: Readonly<Record<string, readonly string[]>>;
-  migrations?: readonly DatabaseMigrationStep[];
   timeoutMs?: number;
 }
 
@@ -179,20 +172,15 @@ export function openDatabase(file: string, description: string, spec: DatabaseSc
       database.exec(spec.schema);
       database.exec(`PRAGMA user_version = ${spec.version}`);
     } else if (version < spec.version) {
-      let currentVersion = version;
-      while (currentVersion < spec.version) {
-        const step = spec.migrations?.find((m) => m.fromVersion === currentVersion);
-        if (!step) {
-          throw databaseError(
-            "runtime_schema_outdated",
-            file,
-            `${description} schema version ${version} is older than ${spec.version}; no migration lane, backup and restore remain E6`,
-          );
-        }
-        step.migrate(database);
-        currentVersion = step.toVersion;
-        database.exec(`PRAGMA user_version = ${currentVersion}`);
-      }
+      // No migration lanes. This is a single-operator tool: an older database is
+      // re-initialised, not upgraded in place, and the code never carries two schema
+      // shapes at once. Silently accepting an older file would mean every query has to
+      // work against shapes it no longer tests.
+      throw databaseError(
+        "runtime_schema_outdated",
+        file,
+        `${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`,
+      );
     }
 
     if (spec.tables) {

package/plugins/kxm/src/external-effects.ts

@@ -16,6 +16,7 @@ import {
   lstatSync,
 } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { openDatabase } from "./database.ts";
 import { spawnSync } from "node:child_process";
 
 export const EXTERNAL_EFFECT_SCHEMA = "kxm.external-effect-receipt.v1" as const;
@@ -114,6 +115,33 @@ export function computeEffectKey(
   return `eff_${createHash("sha256").update(raw).digest("hex").slice(0, 16)}`;
 }
 
+const EXTERNAL_EFFECTS_SCHEMA_VERSION = 1;
+
+const EXTERNAL_EFFECTS_DDL = `
+CREATE TABLE IF NOT EXISTS external_effects (
+  effect_key TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  step_id TEXT NOT NULL,
+  attempt_id TEXT NOT NULL,
+  action_kind TEXT NOT NULL,
+  target_ref TEXT NOT NULL,
+  status TEXT NOT NULL,
+  payload_hash TEXT NOT NULL,
+  receipt_payload TEXT NOT NULL,
+  executed_at TEXT NOT NULL,
+  last_heartbeat_at TEXT,
+  completed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_ext_effects_run ON external_effects(run_id);
+`;
+
+const EXTERNAL_EFFECTS_SHAPE = {
+  external_effects: [
+    "effect_key", "run_id", "step_id", "attempt_id", "action_kind", "target_ref",
+    "status", "payload_hash", "receipt_payload", "executed_at", "last_heartbeat_at", "completed_at",
+  ],
+} as const;
+
 export class ExternalEffectsLedger {
   private db: DatabaseSync;
 
@@ -121,33 +149,15 @@ export class ExternalEffectsLedger {
     if (dbPath !== ":memory:") {
       mkdirSync(dirname(dbPath), { recursive: true });
     }
-    this.db = new DatabaseSync(dbPath);
-    this.initSchema();
-  }
-
-  private initSchema(): void {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS external_effects (
-        effect_key TEXT PRIMARY KEY,
-        run_id TEXT NOT NULL,
-        step_id TEXT NOT NULL,
-        attempt_id TEXT NOT NULL,
-        action_kind TEXT NOT NULL,
-        target_ref TEXT NOT NULL,
-        status TEXT NOT NULL,
-        payload_hash TEXT NOT NULL,
-        receipt_payload TEXT NOT NULL,
-        executed_at TEXT NOT NULL,
-        last_heartbeat_at TEXT,
-        completed_at TEXT
-      );
-      CREATE INDEX IF NOT EXISTS idx_ext_effects_run ON external_effects(run_id);
-    `);
-    try {
-      this.db.exec(`ALTER TABLE external_effects ADD COLUMN last_heartbeat_at TEXT;`);
-    } catch {
-      // Column already present in schema
-    }
+    // Goes through the shared opener, not a bare `new DatabaseSync`: that is what gives this
+    // store the same contract as every other one — path checks, WAL, the `user_version` gate
+    // that refuses an older stamp outright, and the column-shape check that turns a missing
+    // column into `runtime_schema_shape_invalid` here instead of a bare SQL error on first use.
+    this.db = openDatabase(dbPath, "external effects ledger", {
+      schema: EXTERNAL_EFFECTS_DDL,
+      version: EXTERNAL_EFFECTS_SCHEMA_VERSION,
+      tables: EXTERNAL_EFFECTS_SHAPE,
+    });
   }
 
   /**

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/intake.ts

@@ -102,20 +102,15 @@ export function kxmCeilingHash(authority: KxmCoordinatorAuthority): string {
 }
 
 /**
- * Does an already-stored coordinator express this ceiling?
+ * Does a stored coordinator already express the ceiling being requested?
  *
- * A row written before set normalisation existed carries a fingerprint that
- * `kxmCeilingHash` no longer reproduces, so comparing the stored hash alone is
- * not enough: recompute over the authority it kept. Every path that asks this
- * question — the initial slot lookup and **both** lost-write read-backs — must
- * go through here, or an upgrade makes the same row equivalent on lookup and a
- * `coordinator_write_lost` conflict on the race path.
- *
- * A legacy row is returned as stored, so its `ceilingHash` is historical: a
- * caller must not assume every persisted hash uses today's algorithm.
+ * Stored fingerprint only. Recomputing the fingerprint over the stored authority — the
+ * previous behaviour — existed to tolerate rows written before set canonicalisation, and
+ * that compatibility is gone with the single-operator decision: no migration lanes, no
+ * second schema or hash shape carried forward. A stale row is re-bound, not forgiven.
  */
 function ceilingsMatch(stored: KxmCoordinatorRecord, ceilingHash: string): boolean {
-  return stored.ceilingHash === ceilingHash || kxmCeilingHash(stored.authority) === ceilingHash;
+  return stored.ceilingHash === ceilingHash;
 }
 
 function normalizeAuthority(authority: KxmCoordinatorAuthority): KxmCoordinatorAuthority {

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.52";
+const VERSION = "0.7.54";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();
 let meshClient: HubClient | undefined;