@kontextmind/kxm 0.7.177 → 0.7.179

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

@@ -23948,6 +23948,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   const userConfigFile = join(userDir, "config.yaml");
   const repoDir = repoConfigDirectory(repoRoot);
   const repoConfigFile = join(repoDir, "config.yaml");
+  const includeProject = options.layers !== "user";
   let userRaw = {};
   let userLoadedPath;
   if (existsSync(userConfigFile)) {
@@ -23961,7 +23962,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   }
   let repoRaw = {};
   let repoLoadedPath;
-  if (existsSync(repoConfigFile)) {
+  if (includeProject && existsSync(repoConfigFile)) {
     try {
       const text = readFileSync(repoConfigFile, "utf8");
       repoRaw = (0, import_yaml.parse)(text) ?? {};
@@ -25461,7 +25462,7 @@ function sessionTokenFixHint(policy) {
 }
 
 // plugins/kxm/src/mcp-server.ts
-var VERSION = "0.7.177";
+var VERSION = "0.7.179";
 var CONFIGURE_PLUGIN = "/plugin configure kxm@kxm";
 var inbox = /* @__PURE__ */ new Map();
 var notifiedInbox = /* @__PURE__ */ new Set();

package/plugins/kxm/dist/runtime-supervisor.js

@@ -25121,6 +25121,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   const userConfigFile = join11(userDir, "config.yaml");
   const repoDir = repoConfigDirectory(repoRoot);
   const repoConfigFile = join11(repoDir, "config.yaml");
+  const includeProject = options.layers !== "user";
   let userRaw = {};
   let userLoadedPath;
   if (existsSync10(userConfigFile)) {
@@ -25134,7 +25135,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   }
   let repoRaw = {};
   let repoLoadedPath;
-  if (existsSync10(repoConfigFile)) {
+  if (includeProject && existsSync10(repoConfigFile)) {
     try {
       const text = readFileSync8(repoConfigFile, "utf8");
       repoRaw = (0, import_yaml5.parse)(text) ?? {};

package/plugins/kxm/dist/runtime.js

@@ -25865,6 +25865,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   const userConfigFile = join11(userDir, "config.yaml");
   const repoDir = repoConfigDirectory(repoRoot);
   const repoConfigFile = join11(repoDir, "config.yaml");
+  const includeProject = options.layers !== "user";
   let userRaw = {};
   let userLoadedPath;
   if (existsSync10(userConfigFile)) {
@@ -25878,7 +25879,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   }
   let repoRaw = {};
   let repoLoadedPath;
-  if (existsSync10(repoConfigFile)) {
+  if (includeProject && existsSync10(repoConfigFile)) {
     try {
       const text = readFileSync8(repoConfigFile, "utf8");
       repoRaw = (0, import_yaml5.parse)(text) ?? {};

package/plugins/kxm/dist/server.js

@@ -23447,6 +23447,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   const userConfigFile = join7(userDir, "config.yaml");
   const repoDir = repoConfigDirectory(repoRoot);
   const repoConfigFile = join7(repoDir, "config.yaml");
+  const includeProject = options.layers !== "user";
   let userRaw = {};
   let userLoadedPath;
   if (existsSync7(userConfigFile)) {
@@ -23460,7 +23461,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   }
   let repoRaw = {};
   let repoLoadedPath;
-  if (existsSync7(repoConfigFile)) {
+  if (includeProject && existsSync7(repoConfigFile)) {
     try {
       const text2 = readFileSync5(repoConfigFile, "utf8");
       repoRaw = (0, import_yaml6.parse)(text2) ?? {};

package/plugins/kxm/package.json

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

package/plugins/kxm/src/autocomplete.ts

@@ -53,7 +53,7 @@ const SUBCOMMANDS: Record<string, string[]> = {
   memory: ["brief", "note", "sync"],
   routing: ["report", "benchmark"],
   hub: ["view", "start", "stop", "bind", "unbind"],
-  config: ["get", "set", "list"],
+  config: ["get", "set", "edit", "list"],
   goal: ["create", "list", "get"],
   task: ["create", "list", "get", "run", "sync"],
   studio: ["layout", "serve"],
@@ -179,7 +179,7 @@ _kxm() {
           _arguments '1:shell:(bash zsh fish)'
           ;;
         config)
-          _arguments '1:action:(get set list)'
+          _arguments '1:action:(get set edit list)'
           ;;
         runs)
           _arguments '1:subcommand:(status cancel list)'
@@ -224,7 +224,7 @@ complete -c kxm -n "__fish_seen_subcommand_from completion" -a "bash zsh fish"
 complete -c kxm -n "__fish_seen_subcommand_from dash" -l screen -a "agents tasks workflows plans inbox procs spend"
 
 # Config subcommand
-complete -c kxm -n "__fish_seen_subcommand_from config" -a "get set list"
+complete -c kxm -n "__fish_seen_subcommand_from config" -a "get set edit list"
 
 # Runs subcommand
 complete -c kxm -n "__fish_seen_subcommand_from runs" -a "status cancel list"

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

@@ -1,7 +1,10 @@
 import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { parse as parseYaml } from "yaml";
 import { findKxmRepoRoot } from "../repo-root.ts";
 import { probeHarnesses } from "../harness.ts";
-import { print, type Runtime } from "./types.ts";
+import { print, type CliSpawnResult, type Runtime } from "./types.ts";
 
 export type PluginHarnessId = "pi" | "omp" | "claude";
 
@@ -12,6 +15,7 @@ export interface PluginInstallOptions {
   claude?: boolean | undefined;
   omp?: boolean | undefined;
   pi?: boolean | undefined;
+  statusBand?: boolean | undefined;
 }
 
 export interface PluginInstallHarnessResult {
@@ -23,6 +27,149 @@ export interface PluginInstallHarnessResult {
   error?: string | undefined;
 }
 
+const OMP_STATUS_SETTINGS = [
+  { key: "statusLine.leftSegments", configKey: "leftSegments", value: ["model", "mode", "git", "pr", "subagents"] },
+  { key: "statusLine.rightSegments", configKey: "rightSegments", value: ["usage", "cost", "context_pct"] },
+  { key: "statusLine.preset", configKey: "preset", value: "custom" },
+] as const;
+
+function spawnHarness(runtime: Runtime, command: string, args: readonly string[]): CliSpawnResult {
+  return runtime.io.spawnSync
+    ? runtime.io.spawnSync(command, args)
+    : spawnSync(command, args, { encoding: "utf8", windowsHide: true, env: runtime.env });
+}
+
+function spawnFailed(run: CliSpawnResult): boolean {
+  return Boolean(run.error) || run.status !== 0;
+}
+
+function spawnFailureDetail(run: CliSpawnResult, fallback: string): string {
+  return (run.stderr || run.stdout || run.error?.message || fallback).trim();
+}
+
+interface OmpStatusBandFailure {
+  args: readonly string[];
+  run: CliSpawnResult;
+  rollbackAttempted: boolean;
+  rollbackFailed: boolean;
+}
+
+interface OmpGlobalSettingSnapshot {
+  present: boolean;
+  value?: unknown;
+}
+
+function ompConfigValueArg(value: unknown): string {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+
+function readOmpGlobalStatusSettings(
+  runtime: Runtime,
+  command: string,
+): { previous: Record<string, OmpGlobalSettingSnapshot> } | OmpStatusBandFailure {
+  const args = ["config", "path"];
+  const run = spawnHarness(runtime, command, args);
+  if (spawnFailed(run)) return { args, run, rollbackAttempted: false, rollbackFailed: false };
+
+  const agentDir = run.stdout.trim();
+  if (!agentDir || !isAbsolute(agentDir) || !existsSync(agentDir)) {
+    return {
+      args,
+      run: { status: 1, stdout: run.stdout, stderr: "omp config path did not return an existing absolute directory" },
+      rollbackAttempted: false,
+      rollbackFailed: false,
+    };
+  }
+
+  const configPath = ["config.yml", "config.yaml"].map((name) => join(agentDir, name)).find(existsSync);
+  let document: unknown = {};
+  try {
+    if (configPath) document = parseYaml(readFileSync(configPath, "utf8"));
+  } catch {
+    return {
+      args,
+      run: { status: 1, stdout: run.stdout, stderr: `could not read OMP global config at ${configPath}` },
+      rollbackAttempted: false,
+      rollbackFailed: false,
+    };
+  }
+
+  const root = document && typeof document === "object" && !Array.isArray(document) ? document : {};
+  const rawStatusLine = "statusLine" in root ? root.statusLine : undefined;
+  const statusLine = rawStatusLine && typeof rawStatusLine === "object" && !Array.isArray(rawStatusLine)
+    ? rawStatusLine
+    : {};
+  const previous: Record<string, OmpGlobalSettingSnapshot> = {};
+  for (const setting of OMP_STATUS_SETTINGS) {
+    const value = statusLine[setting.configKey as keyof typeof statusLine];
+    previous[setting.key] = Object.hasOwn(statusLine, setting.configKey) && value !== null && value !== undefined
+      ? { present: true, value }
+      : { present: false };
+  }
+  return { previous };
+}
+
+function rollbackOmpStatusBand(
+  runtime: Runtime,
+  command: string,
+  settings: readonly (typeof OMP_STATUS_SETTINGS)[number][],
+  previous: Readonly<Record<string, OmpGlobalSettingSnapshot>>,
+): boolean {
+  let failed = false;
+  for (const setting of [...settings].reverse()) {
+    const snapshot = previous[setting.key];
+    const args = snapshot?.present
+      ? ["config", "set", setting.key, ompConfigValueArg(snapshot.value), "--json"]
+      : ["config", "reset", setting.key, "--json"];
+    if (spawnFailed(spawnHarness(runtime, command, args))) failed = true;
+  }
+  return failed;
+}
+
+function configureOmpStatusBand(runtime: Runtime, command: string): OmpStatusBandFailure | undefined {
+  const snapshot = readOmpGlobalStatusSettings(runtime, command);
+  if ("run" in snapshot) return snapshot;
+
+  const written: (typeof OMP_STATUS_SETTINGS)[number][] = [];
+  for (const setting of OMP_STATUS_SETTINGS) {
+    const args = ["config", "set", setting.key, ompConfigValueArg(setting.value), "--json"];
+    written.push(setting);
+    const run = spawnHarness(runtime, command, args);
+    if (spawnFailed(run)) {
+      return {
+        args,
+        run,
+        rollbackAttempted: true,
+        rollbackFailed: rollbackOmpStatusBand(runtime, command, written, snapshot.previous),
+      };
+    }
+  }
+
+  for (const setting of OMP_STATUS_SETTINGS) {
+    const args = ["config", "get", setting.key, "--json"];
+    const run = spawnHarness(runtime, command, args);
+    let actual: unknown;
+    try {
+      const parsed: unknown = JSON.parse(run.stdout);
+      actual = parsed && typeof parsed === "object" && "value" in parsed ? parsed.value : undefined;
+    } catch {
+      actual = undefined;
+    }
+    if (spawnFailed(run) || JSON.stringify(actual) !== JSON.stringify(setting.value)) {
+      const mismatch = spawnFailed(run)
+        ? run
+        : { status: 1, stdout: run.stdout, stderr: `effective ${setting.key} is shadowed or did not persist` };
+      return {
+        args,
+        run: mismatch,
+        rollbackAttempted: true,
+        rollbackFailed: rollbackOmpStatusBand(runtime, command, written, snapshot.previous),
+      };
+    }
+  }
+  return undefined;
+}
+
 export async function cmdPluginInstall(
   runtime: Runtime,
   options: PluginInstallOptions,
@@ -41,6 +188,17 @@ export async function cmdPluginInstall(
     ? requestedHarnesses
     : PLUGIN_SUPPORTED_HARNESSES;
 
+  if (options.statusBand && isExplicit && !options.omp) {
+    const detail = "--status-band requires OMP to be among the selected harnesses";
+    print(
+      runtime.io,
+      runtime.json,
+      { ok: false, command: "plugin install", error: "omp_status_band_requires_omp", results: [] },
+      detail,
+    );
+    return 1;
+  }
+
   const results: PluginInstallHarnessResult[] = [];
 
   for (const harnessId of targetHarnesses) {
@@ -48,7 +206,7 @@ export async function cmdPluginInstall(
     const detected = Boolean(status?.detected && status?.command);
 
     if (!detected) {
-      if (isExplicit) {
+      if (isExplicit || (options.statusBand && harnessId === "omp")) {
         results.push({
           harness: harnessId,
           status: "failed",
@@ -72,17 +230,15 @@ export async function cmdPluginInstall(
           detail: `would install kxm plugin into pi: ${command} ${args.join(" ")}`,
         });
       } else {
-        const run = runtime.io.spawnSync
-          ? runtime.io.spawnSync(command, args)
-          : spawnSync(command, args, { encoding: "utf8", windowsHide: true, env: runtime.env });
-        if (run.error || (run.status !== 0 && run.status !== null)) {
+        const run = spawnHarness(runtime, command, args);
+        if (spawnFailed(run)) {
           results.push({
             harness: "pi",
             status: "failed",
             command,
             args,
             error: run.error?.message || "install_failed",
-            detail: (run.stderr || run.stdout || "pi install exited with error").trim(),
+            detail: spawnFailureDetail(run, "pi install exited with error"),
           });
         } else {
           results.push({
@@ -102,29 +258,43 @@ export async function cmdPluginInstall(
           status: "would",
           command,
           args,
-          detail: `would install kxm plugin into omp: ${command} ${args.join(" ")}`,
+          detail: options.statusBand
+            ? `would install kxm plugin into omp and configure the focused subscription status band: ${command} ${args.join(" ")}`
+            : `would install kxm plugin into omp: ${command} ${args.join(" ")}`,
         });
       } else {
-        const run = runtime.io.spawnSync
-          ? runtime.io.spawnSync(command, args)
-          : spawnSync(command, args, { encoding: "utf8", windowsHide: true, env: runtime.env });
-        if (run.error || (run.status !== 0 && run.status !== null)) {
+        const run = spawnHarness(runtime, command, args);
+        if (spawnFailed(run)) {
           results.push({
             harness: "omp",
             status: "failed",
             command,
             args,
             error: run.error?.message || "install_failed",
-            detail: (run.stderr || run.stdout || "omp plugin install exited with error").trim(),
+            detail: spawnFailureDetail(run, "omp plugin install exited with error"),
           });
         } else {
-          results.push({
-            harness: "omp",
-            status: "passed",
-            command,
-            args,
-            detail: "installed kxm plugin into omp",
-          });
+          const configFailure = options.statusBand ? configureOmpStatusBand(runtime, command) : undefined;
+          if (configFailure) {
+            results.push({
+              harness: "omp",
+              status: "failed",
+              command,
+              args: configFailure.args,
+              error: "status_band_config_failed",
+              detail: `installed kxm plugin into omp, but ${configFailure.args.slice(0, 3).join(" ")} failed: ${spawnFailureDetail(configFailure.run, "omp status band configuration exited with error")}${configFailure.rollbackAttempted ? (configFailure.rollbackFailed ? "; previous settings could not be fully restored" : "; previous settings restored") : ""}`,
+            });
+          } else {
+            results.push({
+              harness: "omp",
+              status: "passed",
+              command,
+              args,
+              detail: options.statusBand
+                ? "installed kxm plugin into omp and configured the focused subscription status band; restart omp"
+                : "installed kxm plugin into omp",
+            });
+          }
         }
       }
     } else if (harnessId === "claude") {
@@ -144,17 +314,15 @@ export async function cmdPluginInstall(
         } else {
           spawnSync(command, marketplaceArgs, { encoding: "utf8", windowsHide: true, env: runtime.env });
         }
-        const run = runtime.io.spawnSync
-          ? runtime.io.spawnSync(command, installArgs)
-          : spawnSync(command, installArgs, { encoding: "utf8", windowsHide: true, env: runtime.env });
-        if (run.error || (run.status !== 0 && run.status !== null)) {
+        const run = spawnHarness(runtime, command, installArgs);
+        if (spawnFailed(run)) {
           results.push({
             harness: "claude",
             status: "failed",
             command,
             args: installArgs,
             error: run.error?.message || "install_failed",
-            detail: (run.stderr || run.stdout || "claude plugin install exited with error").trim(),
+            detail: spawnFailureDetail(run, "claude install exited with error"),
           });
         } else {
           results.push({

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

@@ -48,7 +48,9 @@ import {
   setKxmConfigValue,
   getKxmConfigValue,
   formatKxmConfig,
+  userConfigDirForEnv,
 } from "../config.ts";
+import { runKxmConfigEditor } from "../config-editor.ts";
 import { generateShellCompletion, type SupportedShell } from "../autocomplete.ts";
 import {
   completionRcTarget,
@@ -736,6 +738,41 @@ export async function cmdConfigSet(
   }
 }
 
+export async function cmdConfigEdit(
+  runtime: Runtime,
+  options: { scope?: string },
+  isTty = Boolean(process.stdin.isTTY && process.stdout.isTTY),
+): Promise<number> {
+  const scope = options.scope;
+  if (scope !== "project" && scope !== "user") {
+    const detail = "config edit requires --scope project or --scope user";
+    print(runtime.io, runtime.json, { ok: false, command: "config edit", error: "config_edit_unsupported", detail }, detail);
+    return 2;
+  }
+  if (runtime.json) {
+    const detail = "config edit does not print machine-readable output";
+    print(runtime.io, runtime.json, { ok: false, command: "config edit", error: "config_edit_unsupported", detail }, detail);
+    return 2;
+  }
+  try {
+    const userConfigDir = userConfigDirForEnv(runtime.env);
+    return await runKxmConfigEditor({
+      target: {
+        cwd: runtime.cwd,
+        scope,
+        ...(userConfigDir === undefined ? {} : { userConfigDir }),
+      },
+      stdout: (text) => runtime.io.stdout(text),
+      isTty,
+      dryRun: runtime.dryRun,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    runtime.io.stderr(`config edit failed: ${message}\n`);
+    return 1;
+  }
+}
+
 export async function cmdConfigList(runtime: Runtime): Promise<number> {
   try {
     const config = loadKxmConfig(runtime.cwd);

package/plugins/kxm/src/cli.ts

@@ -165,6 +165,7 @@ import {
   cmdImprove,
   cmdConfigGet,
   cmdConfigSet,
+  cmdConfigEdit,
   cmdConfigList,
   cmdCompletion,
   cmdCompletionInstall,
@@ -228,7 +229,7 @@ const DRY_RUN_COMMANDS: ReadonlySet<string> = new Set([
   "routing report", "routing benchmark",
   "ssh info", "ssh run", "ssh file", "ssh close",
   "hub view", "hub start", "hub stop", "hub bind", "hub unbind",
-  "config get", "config set", "config list",
+  "config get", "config set", "config edit", "config list",
   "goal create", "goal list",
   "task create", "task list", "task get", "task run", "task sync",
   "studio layout", "studio serve",
@@ -772,7 +773,8 @@ function createProgram(ctx: CliContext, result: { code: number }, argv: readonly
     .option("--claude", "Install plugin for Claude Code")
     .option("--omp", "Install plugin for Oh My Pi (OMP)")
     .option("--pi", "Install plugin for Pi")
-    .action(async function pluginInstallAction(this: Command, options: { all?: boolean; claude?: boolean; omp?: boolean; pi?: boolean }) {
+    .option("--status-band", "Configure OMP's focused status band with live subscription usage")
+    .action(async function pluginInstallAction(this: Command, options: { all?: boolean; claude?: boolean; omp?: boolean; pi?: boolean; statusBand?: boolean }) {
       result.code = await cmdPluginInstall(runtimeFrom(ctx, this), options);
     });
 
@@ -1430,6 +1432,11 @@ function createProgram(ctx: CliContext, result: { code: number }, argv: readonly
     .action(async function configSetAction(this: Command, key: string, value: string, options: { scope: string }) {
       result.code = await cmdConfigSet(runtimeFrom(ctx, this), key, value, options);
     });
+  addGlobalOptions(configCmd.command("edit").description("Edit supported non-secret settings in the terminal panel"))
+    .option("--scope <scope>", "Write scope: project or user")
+    .action(async function configEditAction(this: Command, options: { scope?: string }) {
+      result.code = await cmdConfigEdit(runtimeFrom(ctx, this), options);
+    });
   addGlobalOptions(configCmd.command("list", { isDefault: true }).description("List resolved configuration values"))
     .action(async function configListAction(this: Command) {
       result.code = await cmdConfigList(runtimeFrom(ctx, this));