@kontextmind/kxm 0.7.177 → 0.7.178

package/plugins/kxm/dist/cli.js

@@ -8880,7 +8880,7 @@ var require_public_api = __commonJS({
       }
       return doc;
     }
-    function parse12(src, reviver, options) {
+    function parse13(src, reviver, options) {
       let _reviver = void 0;
       if (typeof reviver === "function") {
         _reviver = reviver;
@@ -8921,7 +8921,7 @@ var require_public_api = __commonJS({
         return value.toString(options);
       return new Document.Document(value, _replacer, options).toString(options);
     }
-    exports.parse = parse12;
+    exports.parse = parse13;
     exports.parseAllDocuments = parseAllDocuments;
     exports.parseDocument = parseDocument3;
     exports.stringify = stringify12;
@@ -9184,6 +9184,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   const userConfigFile = join3(userDir, "config.yaml");
   const repoDir = repoConfigDirectory(repoRoot);
   const repoConfigFile = join3(repoDir, "config.yaml");
+  const includeProject = options.layers !== "user";
   let userRaw = {};
   let userLoadedPath;
   if (existsSync3(userConfigFile)) {
@@ -9197,7 +9198,7 @@ function loadKxmConfig(repoRoot = process.cwd(), options = {}) {
   }
   let repoRaw = {};
   let repoLoadedPath;
-  if (existsSync3(repoConfigFile)) {
+  if (includeProject && existsSync3(repoConfigFile)) {
     try {
       const text = readFileSync2(repoConfigFile, "utf8");
       repoRaw = (0, import_yaml.parse)(text) ?? {};
@@ -14043,7 +14044,7 @@ var require_fast_uri = __commonJS({
         normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse12(serialize(uri, options), options);
+        parse13(serialize(uri, options), options);
       }
       return uri;
     }
@@ -14083,8 +14084,8 @@ var require_fast_uri = __commonJS({
     function resolveComponent(base, relative8, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse12(serialize(base, options), options);
-        relative8 = parse12(serialize(relative8, options), options);
+        base = parse13(serialize(base, options), options);
+        relative8 = parse13(serialize(relative8, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative8.scheme) {
@@ -14376,7 +14377,7 @@ var require_fast_uri = __commonJS({
       }
       return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
     }
-    function parse12(uri, opts) {
+    function parse13(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
     }
     function normalizeString(uri, opts) {
@@ -14413,7 +14414,7 @@ var require_fast_uri = __commonJS({
       resolveComponent,
       equal,
       serialize,
-      parse: parse12
+      parse: parse13
     };
     module.exports = fastUri;
     module.exports.default = fastUri;
@@ -19547,7 +19548,7 @@ function resolveDispatchStatus(entry, detected, authenticated, issues) {
     return { status: "no", supported: false, reason: "not_authenticated" };
   }
   if (authenticated === null) {
-    const authIssue = issues.find((issue4) => issue4 === "auth_context_required" || issue4 === "auth_unknown" || issue4 === "auth_unparsed" || issue4.startsWith("auth_"));
+    const authIssue = issues.find((issue5) => issue5 === "auth_context_required" || issue5 === "auth_unknown" || issue5 === "auth_unparsed" || issue5.startsWith("auth_"));
     return { status: "no", supported: false, reason: authIssue ?? issues[0] ?? "auth_unknown" };
   }
   return { status: "yes", supported: true };
@@ -21473,7 +21474,7 @@ var init_project_config = __esm({
       issues;
       constructor(issues) {
         const sorted = sortIssues3(issues);
-        super(sorted.map((issue4) => `${issue4.file}: ${issue4.code}: ${issue4.message}`).join("\n"));
+        super(sorted.map((issue5) => `${issue5.file}: ${issue5.code}: ${issue5.message}`).join("\n"));
         this.name = "KxmConfigError";
         this.issues = sorted;
       }
@@ -22356,8 +22357,8 @@ import {
 } from "node:fs";
 import { basename as basename3, dirname as dirname9, isAbsolute as isAbsolute5, join as join12, relative as relative3, resolve as resolve10, sep as sep3 } from "node:path";
 function databaseError(code, file, message) {
-  const issue4 = { phase: "semantic", code, file, message };
-  return new KxmConfigError([issue4]);
+  const issue5 = { phase: "semantic", code, file, message };
+  return new KxmConfigError([issue5]);
 }
 function checkedParent(path4, description) {
   const parent = dirname9(path4);
@@ -25451,8 +25452,8 @@ function sortIssues4(issues) {
     return compareCodeUnits5(left.code, right.code);
   });
 }
-function pushIssue(sink, issue4) {
-  sink.issues.push({ workflowId: sink.workflowId, ...issue4 });
+function pushIssue(sink, issue5) {
+  sink.issues.push({ workflowId: sink.workflowId, ...issue5 });
 }
 var KXM_COMPILED_WORKFLOW_SCHEMA, WORKFLOW_SCHEMA, STEP_ID_PATTERN, SUPPORTED_STEP_KINDS, TERMINAL_STATUSES, JOIN_STRATEGIES, EVIDENCE_KINDS, REPOSITORY_ACCESS, DISTINCT_BY, BANNED_RUNTIME_HINT, KxmEngineCompileError;
 var init_engine_compile = __esm({
@@ -25472,7 +25473,7 @@ var init_engine_compile = __esm({
       issues;
       constructor(issues) {
         const sorted = sortIssues4(issues);
-        super(sorted.map((issue4) => `${issue4.workflowId}: ${issue4.code}: ${issue4.message}`).join("\n"));
+        super(sorted.map((issue5) => `${issue5.workflowId}: ${issue5.code}: ${issue5.message}`).join("\n"));
         this.name = "KxmEngineCompileError";
         this.issues = sorted;
       }
@@ -31226,7 +31227,7 @@ async function cmdKxmInit(runtime, options, postHooks) {
       return finishInit(0, `init plan: ${initialized.plan.mode}`);
     }
     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";
-    return finishInit(1, [next, ...initialized.plan.issues.map((issue4) => `${issue4.file}: ${issue4.code}: ${issue4.message}`)].join("\n"));
+    return finishInit(1, [next, ...initialized.plan.issues.map((issue5) => `${issue5.file}: ${issue5.code}: ${issue5.message}`)].join("\n"));
   } catch (error) {
     if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, {
@@ -40186,7 +40187,7 @@ async function cmdContextWikiLint(runtime, project) {
   const compiled = response.body;
   const issues = compiled.lint;
   print(runtime.io, runtime.json, { ok: issues.length === 0, command: "context wiki-lint", project, issues, audit: compiled.audit }, issues.length === 0 ? "wiki lint clean" : `wiki lint found ${issues.length} issue(s)`);
-  return issues.every((issue4) => issue4.severity !== "error") ? 0 : 1;
+  return issues.every((issue5) => issue5.severity !== "error") ? 0 : 1;
 }
 function skillStateFromFlag(value) {
   if (value === "candidate" || value === "promoted" || value === "quarantined" || value === "rejected") return value;
@@ -44327,6 +44328,66 @@ var LEGACY_CTRL_SEQUENCES = {
   home: ["\x1B[7^"],
   end: ["\x1B[8^"]
 };
+var LEGACY_SEQUENCE_KEY_IDS = {
+  "\x1BOA": "up",
+  "\x1BOB": "down",
+  "\x1BOC": "right",
+  "\x1BOD": "left",
+  "\x1BOH": "home",
+  "\x1BOF": "end",
+  "\x1B[E": "clear",
+  "\x1BOE": "clear",
+  "\x1BOe": "ctrl+clear",
+  "\x1B[e": "shift+clear",
+  "\x1B[2~": "insert",
+  "\x1B[2$": "shift+insert",
+  "\x1B[2^": "ctrl+insert",
+  "\x1B[3$": "shift+delete",
+  "\x1B[3^": "ctrl+delete",
+  "\x1B[[5~": "pageUp",
+  "\x1B[[6~": "pageDown",
+  "\x1B[a": "shift+up",
+  "\x1B[b": "shift+down",
+  "\x1B[c": "shift+right",
+  "\x1B[d": "shift+left",
+  "\x1BOa": "ctrl+up",
+  "\x1BOb": "ctrl+down",
+  "\x1BOc": "ctrl+right",
+  "\x1BOd": "ctrl+left",
+  "\x1B[5$": "shift+pageUp",
+  "\x1B[6$": "shift+pageDown",
+  "\x1B[7$": "shift+home",
+  "\x1B[8$": "shift+end",
+  "\x1B[5^": "ctrl+pageUp",
+  "\x1B[6^": "ctrl+pageDown",
+  "\x1B[7^": "ctrl+home",
+  "\x1B[8^": "ctrl+end",
+  "\x1BOP": "f1",
+  "\x1BOQ": "f2",
+  "\x1BOR": "f3",
+  "\x1BOS": "f4",
+  "\x1B[11~": "f1",
+  "\x1B[12~": "f2",
+  "\x1B[13~": "f3",
+  "\x1B[14~": "f4",
+  "\x1B[[A": "f1",
+  "\x1B[[B": "f2",
+  "\x1B[[C": "f3",
+  "\x1B[[D": "f4",
+  "\x1B[[E": "f5",
+  "\x1B[15~": "f5",
+  "\x1B[17~": "f6",
+  "\x1B[18~": "f7",
+  "\x1B[19~": "f8",
+  "\x1B[20~": "f9",
+  "\x1B[21~": "f10",
+  "\x1B[23~": "f11",
+  "\x1B[24~": "f12",
+  "\x1Bb": "alt+left",
+  "\x1Bf": "alt+right",
+  "\x1Bp": "alt+up",
+  "\x1Bn": "alt+down"
+};
 var matchesLegacySequence = (data, sequences) => sequences.includes(data);
 var matchesLegacyModifierSequence = (data, key, modifier) => {
   if (modifier === MODIFIERS.shift) {
@@ -44472,6 +44533,22 @@ function matchesPrintableModifyOtherKeys(data, expectedKeycode, expectedModifier
     return false;
   return normalizeShiftedLetterIdentityCodepoint(parsed.codepoint, parsed.modifier) === normalizeShiftedLetterIdentityCodepoint(expectedKeycode, expectedModifier);
 }
+function formatKeyNameWithModifiers(keyName, modifier) {
+  const mods = [];
+  const effectiveMod = modifier & ~LOCK_MASK;
+  const supportedModifierMask = MODIFIERS.shift | MODIFIERS.ctrl | MODIFIERS.alt | MODIFIERS.super;
+  if ((effectiveMod & ~supportedModifierMask) !== 0)
+    return void 0;
+  if (effectiveMod & MODIFIERS.shift)
+    mods.push("shift");
+  if (effectiveMod & MODIFIERS.ctrl)
+    mods.push("ctrl");
+  if (effectiveMod & MODIFIERS.alt)
+    mods.push("alt");
+  if (effectiveMod & MODIFIERS.super)
+    mods.push("super");
+  return mods.length > 0 ? `${mods.join("+")}+${keyName}` : keyName;
+}
 function parseKeyId(keyId) {
   const parts = keyId.toLowerCase().split("+");
   const key = parts[parts.length - 1];
@@ -44728,6 +44805,149 @@ function matchesKey(data, keyId) {
   }
   return false;
 }
+function formatParsedKey(codepoint, modifier, baseLayoutKey) {
+  const normalizedCodepoint = normalizeKittyFunctionalCodepoint(codepoint);
+  const identityCodepoint = normalizeShiftedLetterIdentityCodepoint(normalizedCodepoint, modifier);
+  const isLatinLetter = identityCodepoint >= 97 && identityCodepoint <= 122;
+  const isDigit = identityCodepoint >= 48 && identityCodepoint <= 57;
+  const isKnownSymbol = SYMBOL_KEYS.has(String.fromCharCode(identityCodepoint));
+  const effectiveCodepoint = isLatinLetter || isDigit || isKnownSymbol ? identityCodepoint : baseLayoutKey ?? identityCodepoint;
+  let keyName;
+  if (effectiveCodepoint === CODEPOINTS.escape)
+    keyName = "escape";
+  else if (effectiveCodepoint === CODEPOINTS.tab)
+    keyName = "tab";
+  else if (effectiveCodepoint === CODEPOINTS.enter || effectiveCodepoint === CODEPOINTS.kpEnter)
+    keyName = "enter";
+  else if (effectiveCodepoint === CODEPOINTS.space)
+    keyName = "space";
+  else if (effectiveCodepoint === CODEPOINTS.backspace)
+    keyName = "backspace";
+  else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.delete)
+    keyName = "delete";
+  else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.insert)
+    keyName = "insert";
+  else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.home)
+    keyName = "home";
+  else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.end)
+    keyName = "end";
+  else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.pageUp)
+    keyName = "pageUp";
+  else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.pageDown)
+    keyName = "pageDown";
+  else if (effectiveCodepoint === ARROW_CODEPOINTS.up)
+    keyName = "up";
+  else if (effectiveCodepoint === ARROW_CODEPOINTS.down)
+    keyName = "down";
+  else if (effectiveCodepoint === ARROW_CODEPOINTS.left)
+    keyName = "left";
+  else if (effectiveCodepoint === ARROW_CODEPOINTS.right)
+    keyName = "right";
+  else if (effectiveCodepoint >= 48 && effectiveCodepoint <= 57)
+    keyName = String.fromCharCode(effectiveCodepoint);
+  else if (effectiveCodepoint >= 97 && effectiveCodepoint <= 122)
+    keyName = String.fromCharCode(effectiveCodepoint);
+  else if (SYMBOL_KEYS.has(String.fromCharCode(effectiveCodepoint)))
+    keyName = String.fromCharCode(effectiveCodepoint);
+  if (!keyName)
+    return void 0;
+  return formatKeyNameWithModifiers(keyName, modifier);
+}
+function parseKey(data) {
+  const kitty = parseKittySequence(data);
+  if (kitty) {
+    return formatParsedKey(kitty.codepoint, kitty.modifier, kitty.baseLayoutKey);
+  }
+  const modifyOtherKeys = parseModifyOtherKeysSequence(data);
+  if (modifyOtherKeys) {
+    return formatParsedKey(modifyOtherKeys.codepoint, modifyOtherKeys.modifier);
+  }
+  if (_kittyProtocolActive) {
+    if (data === "\x1B\r" || data === "\n")
+      return "shift+enter";
+  }
+  const legacySequenceKeyId = LEGACY_SEQUENCE_KEY_IDS[data];
+  if (legacySequenceKeyId)
+    return legacySequenceKeyId;
+  if (data === "\x1B")
+    return "escape";
+  if (data === "")
+    return "ctrl+\\";
+  if (data === "")
+    return "ctrl+]";
+  if (data === "")
+    return "ctrl+-";
+  if (data === "\x1B\x1B")
+    return "ctrl+alt+[";
+  if (data === "\x1B")
+    return "ctrl+alt+\\";
+  if (data === "\x1B")
+    return "ctrl+alt+]";
+  if (data === "\x1B")
+    return "ctrl+alt+-";
+  if (data === "	")
+    return "tab";
+  if (data === "\r" || !_kittyProtocolActive && data === "\n" || data === "\x1BOM")
+    return "enter";
+  if (data === "\0")
+    return "ctrl+space";
+  if (data === " ")
+    return "space";
+  if (data === "\x7F")
+    return "backspace";
+  if (data === "\b")
+    return isWindowsTerminalSession() ? "ctrl+backspace" : "backspace";
+  if (data === "\x1B[Z")
+    return "shift+tab";
+  if (!_kittyProtocolActive && data === "\x1B\r")
+    return "alt+enter";
+  if (!_kittyProtocolActive && data === "\x1B ")
+    return "alt+space";
+  if (data === "\x1B\x7F" || data === "\x1B\b")
+    return "alt+backspace";
+  if (!_kittyProtocolActive && data === "\x1BB")
+    return "alt+left";
+  if (!_kittyProtocolActive && data === "\x1BF")
+    return "alt+right";
+  if (!_kittyProtocolActive && data.length === 2 && data[0] === "\x1B") {
+    const code = data.charCodeAt(1);
+    if (code >= 1 && code <= 26) {
+      return `ctrl+alt+${String.fromCharCode(code + 96)}`;
+    }
+    const key = String.fromCharCode(code);
+    if (code >= 97 && code <= 122 || code >= 48 && code <= 57 || SYMBOL_KEYS.has(key)) {
+      return `alt+${key}`;
+    }
+  }
+  if (data === "\x1B[A")
+    return "up";
+  if (data === "\x1B[B")
+    return "down";
+  if (data === "\x1B[C")
+    return "right";
+  if (data === "\x1B[D")
+    return "left";
+  if (data === "\x1B[H" || data === "\x1BOH")
+    return "home";
+  if (data === "\x1B[F" || data === "\x1BOF")
+    return "end";
+  if (data === "\x1B[3~")
+    return "delete";
+  if (data === "\x1B[5~")
+    return "pageUp";
+  if (data === "\x1B[6~")
+    return "pageDown";
+  if (data.length === 1) {
+    const code = data.charCodeAt(0);
+    if (code >= 1 && code <= 26) {
+      return `ctrl+${String.fromCharCode(code + 96)}`;
+    }
+    if (code >= 32 && code <= 126) {
+      return data;
+    }
+  }
+  return void 0;
+}
 var KITTY_CSI_U_REGEX = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u$/;
 var KITTY_PRINTABLE_ALLOWED_MODIFIERS = MODIFIERS.shift | LOCK_MASK;
 function decodeKittyPrintable(data) {
@@ -50259,6 +50479,13 @@ import { join as join46, resolve as resolve27, dirname as dirname20 } from "node
 import { spawnSync as spawnSync12 } from "node:child_process";
 
 // packages/core/tui/src/types/surface.ts
+var KXM_TUI_FIELD_KINDS = ["text", "enum", "choice", "info"];
+var KXM_TUI_STATUSES = ["ready", "available", "blocked"];
+var KXM_TUI_STEP_STATES = ["pending", "satisfied", "running", "done", "failed"];
+var KXM_TUI_NOTICE_LEVELS = ["info", "error"];
+var KXM_TUI_SET_ACTION = "set";
+var KXM_TUI_CLEAR_ACTION = "clear";
+var KXM_TUI_ABORT_ACTION = "abort";
 var KXM_TUI_LIMITS = Object.freeze({
   sourceMax: 128,
   idMax: 128,
@@ -50280,8 +50507,231 @@ var KXM_TUI_LIMITS = Object.freeze({
   sectionsMax: 32,
   orderMax: 1e3
 });
+var ID_PATTERN = /^[a-z0-9][a-z0-9._:-]*$/;
+var SOURCE_PATTERN = /^[A-Za-z0-9@][A-Za-z0-9@/._:-]*$/;
+var KEY_PATH_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9_.[\]-]*$/;
+var ACTION_KEY_PATTERN = /^[A-Za-z0-9]$/;
+function issue4(path4, code, message) {
+  return { path: path4, code, message };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function boundedText(issues, path4, value, max, required2) {
+  if (value === void 0) {
+    if (required2) issues.push(issue4(path4, "required", `${path4} is required`));
+    return;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    issues.push(issue4(path4, "invalid_string", `${path4} must be a non-empty string`));
+    return;
+  }
+  if (value.length > max) {
+    issues.push(issue4(path4, "too_long", `${path4} exceeds ${max} characters`));
+    return;
+  }
+  if (/[\u0000-\u0008\u000a-\u001f\u007f]/u.test(value)) {
+    issues.push(issue4(path4, "control_character", `${path4} must not contain control characters`));
+  }
+}
+function optionalEnum(issues, path4, value, allowed) {
+  if (value === void 0) return;
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    issues.push(issue4(path4, "invalid_choice", `${path4} must be one of ${allowed.join(", ")}`));
+  }
+}
+function ratioField(issues, path4, value) {
+  if (value === void 0) return;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    issues.push(issue4(path4, "invalid_ratio", `${path4} must be a finite number between 0 and 1`));
+  }
+}
+function validateChoice(issues, path4, raw) {
+  if (!isPlainObject(raw)) {
+    issues.push(issue4(path4, "invalid_object", `${path4} must be an object`));
+    return;
+  }
+  boundedText(issues, `${path4}.id`, raw.id, KXM_TUI_LIMITS.choiceIdMax, true);
+  if (typeof raw.id === "string" && /[\s]/u.test(raw.id)) {
+    issues.push(issue4(`${path4}.id`, "invalid_choice_id", `${path4}.id must not contain whitespace`));
+  }
+  boundedText(issues, `${path4}.label`, raw.label, KXM_TUI_LIMITS.choiceLabelMax, true);
+  boundedText(issues, `${path4}.detail`, raw.detail, KXM_TUI_LIMITS.shortDetailMax, false);
+  boundedText(issues, `${path4}.group`, raw.group, KXM_TUI_LIMITS.shortDetailMax, false);
+  boundedText(issues, `${path4}.statusText`, raw.statusText, KXM_TUI_LIMITS.shortDetailMax, false);
+  boundedText(issues, `${path4}.action`, raw.action, KXM_TUI_LIMITS.idMax, false);
+  optionalEnum(issues, `${path4}.status`, raw.status, KXM_TUI_STATUSES);
+}
+function validateAction(issues, path4, raw) {
+  if (!isPlainObject(raw)) {
+    issues.push(issue4(path4, "invalid_object", `${path4} must be an object`));
+    return;
+  }
+  if (typeof raw.key !== "string" || !ACTION_KEY_PATTERN.test(raw.key)) {
+    issues.push(issue4(`${path4}.key`, "invalid_action_key", `${path4}.key must be a single alphanumeric key`));
+  }
+  boundedText(issues, `${path4}.label`, raw.label, KXM_TUI_LIMITS.shortDetailMax, true);
+  boundedText(issues, `${path4}.action`, raw.action, KXM_TUI_LIMITS.idMax, true);
+}
+function validateStep(issues, path4, raw) {
+  if (!isPlainObject(raw)) {
+    issues.push(issue4(path4, "invalid_object", `${path4} must be an object`));
+    return;
+  }
+  boundedText(issues, `${path4}.label`, raw.label, KXM_TUI_LIMITS.shortDetailMax, true);
+  boundedText(issues, `${path4}.detail`, raw.detail, KXM_TUI_LIMITS.stepDetailMax, false);
+  optionalEnum(issues, `${path4}.state`, raw.state, KXM_TUI_STEP_STATES);
+  if (raw.state === void 0) issues.push(issue4(`${path4}.state`, "required", `${path4}.state is required`));
+}
+function validateField(issues, path4, raw) {
+  if (!isPlainObject(raw)) {
+    issues.push(issue4(path4, "invalid_object", `${path4} must be an object`));
+    return;
+  }
+  boundedText(issues, `${path4}.id`, raw.id, KXM_TUI_LIMITS.idMax, true);
+  if (typeof raw.id === "string" && !ID_PATTERN.test(raw.id)) {
+    issues.push(issue4(`${path4}.id`, "invalid_id", `${path4}.id must match ${ID_PATTERN}`));
+  }
+  boundedText(issues, `${path4}.label`, raw.label, KXM_TUI_LIMITS.labelMax, true);
+  if (raw.kind === void 0) {
+    issues.push(issue4(`${path4}.kind`, "required", `${path4}.kind is required`));
+  } else {
+    optionalEnum(issues, `${path4}.kind`, raw.kind, KXM_TUI_FIELD_KINDS);
+  }
+  boundedText(issues, `${path4}.value`, raw.value, KXM_TUI_LIMITS.valueMax, false);
+  boundedText(issues, `${path4}.placeholder`, raw.placeholder, KXM_TUI_LIMITS.shortDetailMax, false);
+  boundedText(issues, `${path4}.detail`, raw.detail, KXM_TUI_LIMITS.detailMax, false);
+  boundedText(issues, `${path4}.statusText`, raw.statusText, KXM_TUI_LIMITS.statusTextMax, false);
+  if (raw.updatedAt !== void 0) {
+    boundedText(issues, `${path4}.updatedAt`, raw.updatedAt, 64, false);
+    if (typeof raw.updatedAt === "string" && !Number.isFinite(Date.parse(raw.updatedAt))) {
+      issues.push(issue4(`${path4}.updatedAt`, "invalid_timestamp", `${path4}.updatedAt must be an ISO timestamp`));
+    }
+  }
+  optionalEnum(issues, `${path4}.status`, raw.status, KXM_TUI_STATUSES);
+  if (raw.keyPath !== void 0) {
+    boundedText(issues, `${path4}.keyPath`, raw.keyPath, KXM_TUI_LIMITS.keyPathMax, false);
+    if (typeof raw.keyPath === "string" && !KEY_PATH_PATTERN.test(raw.keyPath)) {
+      issues.push(issue4(`${path4}.keyPath`, "invalid_key_path", `${path4}.keyPath must be a dotted config key`));
+    }
+  }
+  for (const listKey of ["busy", "awaitingInput"]) {
+    if (raw[listKey] !== void 0 && typeof raw[listKey] !== "boolean") {
+      issues.push(issue4(`${path4}.${listKey}`, "invalid_boolean", `${path4}.${listKey} must be a boolean`));
+    }
+  }
+  if (raw.progress !== void 0) {
+    if (!isPlainObject(raw.progress)) {
+      issues.push(issue4(`${path4}.progress`, "invalid_object", `${path4}.progress must be an object`));
+    } else {
+      boundedText(issues, `${path4}.progress.label`, raw.progress.label, KXM_TUI_LIMITS.shortDetailMax, true);
+      ratioField(issues, `${path4}.progress.ratio`, raw.progress.ratio);
+    }
+  }
+  for (const [listKey, max, check] of [
+    ["choices", KXM_TUI_LIMITS.choicesMax, validateChoice],
+    ["actions", KXM_TUI_LIMITS.actionsMax, validateAction],
+    ["steps", KXM_TUI_LIMITS.stepsMax, validateStep]
+  ]) {
+    const list = raw[listKey];
+    if (list === void 0) continue;
+    if (!Array.isArray(list) || list.length > max) {
+      issues.push(issue4(`${path4}.${listKey}`, "invalid_list", `${path4}.${listKey} must be an array of at most ${max}`));
+      continue;
+    }
+    list.forEach((entry, index) => check(issues, `${path4}.${listKey}[${index}]`, entry));
+  }
+  const output = raw.output;
+  if (output !== void 0) {
+    if (!Array.isArray(output) || output.length > KXM_TUI_LIMITS.outputMaxLines) {
+      issues.push(issue4(`${path4}.output`, "invalid_list", `${path4}.output must be an array of at most ${KXM_TUI_LIMITS.outputMaxLines} lines`));
+    } else {
+      output.forEach((line, index) => {
+        if (typeof line !== "string") issues.push(issue4(`${path4}.output[${index}]`, "invalid_string", "output lines must be strings"));
+        else if (line.length > KXM_TUI_LIMITS.outputLineMax) issues.push(issue4(`${path4}.output[${index}]`, "too_long", "output line is too long"));
+      });
+    }
+  }
+}
+function validateSection(issues, path4, raw) {
+  if (!isPlainObject(raw)) {
+    issues.push(issue4(path4, "invalid_object", `${path4} must be an object`));
+    return;
+  }
+  boundedText(issues, `${path4}.id`, raw.id, KXM_TUI_LIMITS.idMax, true);
+  if (typeof raw.id === "string" && !ID_PATTERN.test(raw.id)) {
+    issues.push(issue4(`${path4}.id`, "invalid_id", `${path4}.id must match ${ID_PATTERN}`));
+  }
+  boundedText(issues, `${path4}.title`, raw.title, KXM_TUI_LIMITS.labelMax, true);
+  boundedText(issues, `${path4}.detail`, raw.detail, KXM_TUI_LIMITS.shortDetailMax, false);
+  boundedText(issues, `${path4}.notice`, raw.notice, KXM_TUI_LIMITS.detailMax, false);
+  optionalEnum(issues, `${path4}.noticeLevel`, raw.noticeLevel, KXM_TUI_NOTICE_LEVELS);
+  if (typeof raw.order !== "number" || !Number.isInteger(raw.order) || raw.order < 0 || raw.order > KXM_TUI_LIMITS.orderMax) {
+    issues.push(issue4(`${path4}.order`, "invalid_order", `${path4}.order must be an integer between 0 and ${KXM_TUI_LIMITS.orderMax}`));
+  }
+  if (!Array.isArray(raw.fields) || raw.fields.length > KXM_TUI_LIMITS.fieldsMax) {
+    issues.push(issue4(`${path4}.fields`, "invalid_list", `${path4}.fields must be an array of at most ${KXM_TUI_LIMITS.fieldsMax}`));
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  raw.fields.forEach((field, index) => {
+    const fieldPath = `${path4}.fields[${index}]`;
+    validateField(issues, fieldPath, field);
+    if (isPlainObject(field) && typeof field.id === "string") {
+      if (seen.has(field.id)) issues.push(issue4(`${fieldPath}.id`, "duplicate_id", `${field.id} is published twice in ${path4}`));
+      seen.add(field.id);
+    }
+  });
+}
+function validateKxmTuiSurface(sections) {
+  if (!Array.isArray(sections)) return [issue4("sections", "invalid_list", "sections must be an array")];
+  if (sections.length > KXM_TUI_LIMITS.sectionsMax) {
+    return [issue4("sections", "too_many", `sections must number at most ${KXM_TUI_LIMITS.sectionsMax}`)];
+  }
+  const issues = [];
+  const seenSources = /* @__PURE__ */ new Map();
+  sections.forEach((section, index) => {
+    const path4 = `sections[${index}]`;
+    validateSection(issues, path4, section);
+    if (!isPlainObject(section)) return;
+    boundedText(issues, `${path4}.source`, section.source, KXM_TUI_LIMITS.sourceMax, true);
+    if (typeof section.source === "string" && !SOURCE_PATTERN.test(section.source)) {
+      issues.push(issue4(`${path4}.source`, "invalid_source", `${path4}.source must be an addressable owner id`));
+    }
+    if (typeof section.source === "string" && typeof section.id === "string") {
+      const ids = seenSources.get(section.source) ?? /* @__PURE__ */ new Set();
+      seenSources.set(section.source, ids);
+      if (ids.has(section.id)) issues.push(issue4(`${path4}.id`, "duplicate_section", `${section.source}/${section.id} is published twice`));
+      ids.add(section.id);
+    }
+  });
+  return issues;
+}
+function isSelectableField(field) {
+  return field !== void 0 && field.kind !== "info";
+}
+function groupedKxmTuiChoices(field) {
+  const choices = field.choices ?? [];
+  if (choices.length === 0) return [];
+  if (choices.every((choice) => choice.group === void 0)) return [{ group: "", choices }];
+  const groups = [];
+  const index = /* @__PURE__ */ new Map();
+  for (const choice of choices) {
+    const group = choice.group ?? "";
+    let bucket = index.get(group);
+    if (!bucket) {
+      bucket = [];
+      index.set(group, bucket);
+      groups.push({ group, choices: bucket });
+    }
+    bucket.push(choice);
+  }
+  return groups;
+}
 
 // packages/core/tui/src/tui/keys.ts
+var KXM_TUI_INPUT_MAX_LENGTH = 4096;
+var CONTROL_BYTES = /[\u0000-\u0008\u000a-\u001f\u007f\u0080-\u009f]/u;
 var NAMED_KEYS = Object.freeze({
   up: "up",
   down: "down",
@@ -50299,8 +50749,109 @@ var NAMED_KEYS = Object.freeze({
   backspace: "backspace",
   delete: "delete"
 });
+var CONTROL_BYTES_GLOBAL = /[\u0000-\u0008\u000a-\u001f\u007f\u0080-\u009f]/gu;
+function normalizeInputText(value) {
+  return value.replace(CONTROL_BYTES_GLOBAL, " ").replace(/ {2,}/gu, " ").trim().slice(0, KXM_TUI_INPUT_MAX_LENGTH);
+}
+function decodeKxmTuiInput(data) {
+  if (typeof data !== "string" || data.length === 0) return { kind: "ignored" };
+  const named = parseKey(data);
+  if (named === "ctrl+c") return { kind: "ctrlC" };
+  if (named) {
+    const kind = NAMED_KEYS[named.toLowerCase()];
+    if (kind) return { kind };
+    if (named === "space") return { kind: "text", text: " " };
+    if (Array.from(named).length === 1 && !CONTROL_BYTES.test(named)) {
+      return { kind: "text", text: named };
+    }
+    return { kind: "ignored" };
+  }
+  const kitty = decodeKittyPrintable(data);
+  if (kitty) {
+    const text = normalizeInputText(kitty);
+    return text ? { kind: "text", text } : { kind: "ignored" };
+  }
+  if (data.startsWith("\x1B")) return { kind: "ignored" };
+  const pasted = normalizeInputText(data);
+  return pasted ? { kind: "text", text: pasted } : { kind: "ignored" };
+}
+function deleteBackward(text) {
+  const units = Array.from(text);
+  units.pop();
+  return units.join("");
+}
+function insertAt(text, caret, insert, maxLength = KXM_TUI_INPUT_MAX_LENGTH) {
+  const units = Array.from(text);
+  const at2 = Math.max(0, Math.min(caret, units.length));
+  const added = Array.from(insert);
+  const merged = [...units.slice(0, at2), ...added, ...units.slice(at2)].join("");
+  const next = merged.length > maxLength ? merged.slice(0, maxLength) : merged;
+  return { text: next, caret: Math.min(next.length, at2 + added.length) };
+}
 
 // packages/core/tui/src/tui/layout.ts
+var KXM_TUI_ELLIPSIS = "\u2026";
+function fitText(text, width) {
+  if (width <= 0) return "";
+  if (visibleWidth(text) <= width) return text;
+  if (!text.includes("\x1B")) {
+    let out = "";
+    for (const unit of Array.from(text)) {
+      if (visibleWidth(out) + visibleWidth(unit) > width - KXM_TUI_ELLIPSIS.length) break;
+      out += unit;
+    }
+    return out + KXM_TUI_ELLIPSIS;
+  }
+  return truncateToWidth(text, width, KXM_TUI_ELLIPSIS);
+}
+function alignRight(left, right, width) {
+  if (width <= 0) return "";
+  const detail = fitText(right, Math.max(0, width - 2));
+  const detailWidth = visibleWidth(detail);
+  const leftWidth = Math.max(1, width - detailWidth - 1);
+  const fitted = fitText(left, leftWidth);
+  const filler = Math.max(1, width - visibleWidth(fitted) - detailWidth);
+  return `${fitted}${" ".repeat(filler)}${detail}`;
+}
+function padRight(text, width) {
+  const missing = width - visibleWidth(text);
+  return missing > 0 ? text + " ".repeat(missing) : text;
+}
+function wrapPlain(text, width) {
+  if (width <= 0) return [];
+  const lines = [];
+  let current = "";
+  for (const word of text.split(/\s+/u).filter(Boolean)) {
+    if (!current.length) current = word;
+    else if (visibleWidth(current) + 1 + visibleWidth(word) <= width) current = `${current} ${word}`;
+    else {
+      lines.push(current);
+      current = word;
+    }
+  }
+  if (current.length) lines.push(current);
+  return lines.length ? lines : [];
+}
+function formatAge(iso, nowMs) {
+  if (!iso) return "\u2014";
+  const at2 = Date.parse(iso);
+  if (!Number.isFinite(at2)) return "\u2014";
+  const seconds = Math.floor((nowMs - at2) / 1e3);
+  if (seconds < 0) return "\u2014";
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
+  const days = Math.floor(hours / 24);
+  return `${days}d${String(hours % 24).padStart(2, "0")}h`;
+}
+function progressBar(ratio, width = 10) {
+  const cells = Math.max(1, width);
+  if (ratio === void 0 || !Number.isFinite(ratio)) return "\u2591".repeat(cells);
+  const filled = Math.round(Math.max(0, Math.min(1, ratio)) * cells);
+  return "\u2588".repeat(filled) + "\u2591".repeat(Math.max(0, cells - filled));
+}
 var KXM_TUI_MARKS = Object.freeze({
   pending: "\u25CB",
   active: "\u25B6",
@@ -50365,9 +50916,368 @@ function createKxmTuiAnsiTheme(color) {
     panelBg: (text) => `\x1B[48;5;236m${text}\x1B[0m`
   };
 }
+function createDefaultKxmTuiTheme(env = process.env) {
+  return createKxmTuiAnsiTheme(!(env.NO_COLOR || env.KXM_TUI_NO_COLOR));
+}
+
+// packages/core/tui/src/tui/panel.ts
+var PANE_KEYS = /* @__PURE__ */ new Set(["j", "k", "h", "l"]);
+function initialKxmTuiPanelState(sections) {
+  return {
+    pane: "sections",
+    mode: "browse",
+    sectionIndex: 0,
+    fieldIndex: firstSelectableFieldIndex(sections[0]?.fields ?? []),
+    choiceIndex: 0,
+    draft: "",
+    caret: 0,
+    filter: "",
+    filtering: false,
+    help: false,
+    pending: []
+  };
+}
+function pendingKey(invocation) {
+  return `${invocation.source}\0${invocation.sectionId}\0${invocation.fieldId}`;
+}
+function firstSelectableFieldIndex(fields) {
+  const index = fields.findIndex(isSelectableField);
+  return index < 0 ? 0 : index;
+}
+function visibleChoices(field, filter) {
+  const choices = field?.choices ?? [];
+  const needle = filter.trim().toLowerCase();
+  if (!needle) return [...choices];
+  return choices.filter(
+    (choice) => `${choice.group ?? ""} ${choice.label} ${choice.id} ${choice.detail ?? ""}`.toLowerCase().includes(needle)
+  );
+}
+function currentSection(sections, state) {
+  return sections[state.sectionIndex];
+}
+function currentField(sections, state) {
+  return currentSection(sections, state)?.fields[state.fieldIndex];
+}
+function reconcileKxmTuiPanelState(state, sections) {
+  const sectionIndex = Math.min(state.sectionIndex, Math.max(0, sections.length - 1));
+  const fields = sections[sectionIndex]?.fields ?? [];
+  let fieldIndex = Math.min(state.fieldIndex, Math.max(0, fields.length - 1));
+  if (!isSelectableField(fields[fieldIndex])) fieldIndex = firstSelectableFieldIndex(fields);
+  const field = fields[fieldIndex];
+  const keepsEdit = state.mode === "edit" && (field?.statusText !== void 0 || field?.awaitingInput === true);
+  return {
+    ...state,
+    sectionIndex,
+    fieldIndex,
+    mode: keepsEdit ? "edit" : "browse",
+    choiceIndex: 0,
+    pending: []
+  };
+}
+function reduceKxmTuiInput(state, sections, input) {
+  return reduceDecoded(state, sections, decodeKxmTuiInput(input));
+}
+function invokeEffect(state, section, field, action, value) {
+  const invocation = {
+    source: section.source,
+    sectionId: section.id,
+    fieldId: field.id,
+    action,
+    ...value === void 0 ? {} : { value }
+  };
+  const key = pendingKey(invocation);
+  return {
+    state: { ...state, pending: state.pending.includes(key) ? state.pending : [...state.pending, key] },
+    effects: [{ type: "invoke", invocation }]
+  };
+}
+function moveSection(state, sections, delta) {
+  if (sections.length === 0) return state;
+  const next = Math.max(0, Math.min(state.sectionIndex + delta, sections.length - 1));
+  if (next === state.sectionIndex) return state;
+  return {
+    ...state,
+    sectionIndex: next,
+    fieldIndex: firstSelectableFieldIndex(sections[next]?.fields ?? []),
+    mode: "browse",
+    choiceIndex: 0,
+    draft: "",
+    caret: 0,
+    filter: "",
+    filtering: false
+  };
+}
+function moveField(state, fields, delta) {
+  const step = delta < 0 ? -1 : 1;
+  let next = state.fieldIndex + step;
+  while (next >= 0 && next < fields.length && !isSelectableField(fields[next])) next += step;
+  if (next < 0 || next >= fields.length) return state;
+  return {
+    ...state,
+    fieldIndex: next,
+    mode: "browse",
+    choiceIndex: 0,
+    draft: "",
+    caret: 0,
+    filter: "",
+    filtering: false
+  };
+}
+function moveChoice(state, count, delta) {
+  if (count === 0) return state;
+  return { ...state, choiceIndex: Math.max(0, Math.min(state.choiceIndex + delta, count - 1)) };
+}
+function choiceAt(field, state) {
+  const choices = visibleChoices(field, state.filter);
+  return choices[Math.max(0, Math.min(state.choiceIndex, choices.length - 1))];
+}
+function enterField(state, section, field) {
+  if (!field) return { state, effects: [] };
+  if (field.kind === "choice") {
+    if ((field.choices?.length ?? 0) === 0) {
+      return { state, effects: [{ type: "notice", message: `${field.label} has nothing to offer yet` }] };
+    }
+    return { state: { ...state, mode: "choices", choiceIndex: 0 }, effects: [] };
+  }
+  if (field.kind === "enum") {
+    const choices = field.choices ?? [];
+    if (choices.length === 0) {
+      return { state, effects: [{ type: "notice", message: `${field.label} has no values published` }] };
+    }
+    const current = choices.findIndex((choice) => choice.id === field.value);
+    const next = choices[(current + 1) % choices.length];
+    if (next.status === "blocked") {
+      return { state, effects: [{ type: "notice", message: next.statusText ?? `${next.label} is unavailable` }] };
+    }
+    return invokeEffect(state, section, field, next.action ?? KXM_TUI_SET_ACTION, next.id);
+  }
+  if (field.kind !== "text") return { state, effects: [] };
+  return { state: { ...state, mode: "edit", draft: field.value ?? "", caret: (field.value ?? "").length }, effects: [] };
+}
+function reduceDecoded(state, sections, decoded) {
+  const section = sections[state.sectionIndex];
+  const field = currentField(sections, state);
+  if (decoded.kind === "ctrlC") {
+    if (field?.busy && section) {
+      return invokeEffect(state, section, field, KXM_TUI_ABORT_ACTION);
+    }
+    return { state, effects: [{ type: "quit" }] };
+  }
+  if (!section) return { state, effects: [{ type: "quit" }] };
+  if (state.mode === "edit") return reduceEdit(state, section, field, decoded);
+  if (state.mode === "choices") return reduceChoices(state, section, field, decoded);
+  return reduceBrowse(state, sections, section, field, decoded);
+}
+function caretSource(text, caret) {
+  return Array.from(text).slice(0, caret).join("").length;
+}
+function reduceEdit(state, section, field, decoded) {
+  if (!field) return { state: { ...state, mode: "browse" }, effects: [] };
+  switch (decoded.kind) {
+    case "escape":
+      return { state: { ...state, mode: "browse", draft: "", caret: 0 }, effects: [] };
+    case "enter": {
+      const value = normalizeInputText(state.draft).trim();
+      if (!value) return { state: { ...state, mode: "browse", draft: "", caret: 0 }, effects: [] };
+      const step = invokeEffect(state, section, field, KXM_TUI_SET_ACTION, value);
+      return { state: { ...step.state, mode: "browse", draft: "", caret: 0 }, effects: step.effects };
+    }
+    case "backspace": {
+      if (state.caret === 0) return { state, effects: [] };
+      const cut = caretSource(state.draft, state.caret);
+      const before = deleteBackward(state.draft.slice(0, cut));
+      const draft = `${before}${state.draft.slice(cut)}`;
+      return { state: { ...state, draft, caret: Array.from(before).length }, effects: [] };
+    }
+    case "delete": {
+      const units = Array.from(state.draft);
+      const text = [...units.slice(0, state.caret), ...units.slice(state.caret + 1)].join("");
+      return { state: { ...state, draft: text }, effects: [] };
+    }
+    case "left":
+      return { state: { ...state, caret: Math.max(0, state.caret - 1) }, effects: [] };
+    case "right":
+      return { state: { ...state, caret: Math.min(Array.from(state.draft).length, state.caret + 1) }, effects: [] };
+    case "home":
+      return { state: { ...state, caret: 0 }, effects: [] };
+    case "end":
+      return { state: { ...state, caret: Array.from(state.draft).length }, effects: [] };
+    case "text": {
+      const text = decoded.text ?? "";
+      if (!text) return { state, effects: [] };
+      const inserted = insertAt(state.draft, state.caret, text);
+      return { state: { ...state, draft: inserted.text, caret: inserted.caret }, effects: [] };
+    }
+    default:
+      return { state, effects: [] };
+  }
+}
+function reduceChoices(state, section, field, decoded) {
+  if (!field) return { state: { ...state, mode: "browse" }, effects: [] };
+  const choices = visibleChoices(field, state.filter);
+  switch (decoded.kind) {
+    case "escape":
+      return { state: { ...state, mode: "browse", filter: "", filtering: false, choiceIndex: 0 }, effects: [] };
+    case "up":
+      return { state: moveChoice(state, choices.length, -1), effects: [] };
+    case "down":
+      return { state: moveChoice(state, choices.length, 1), effects: [] };
+    case "pageUp":
+      return { state: moveChoice(state, choices.length, -8), effects: [] };
+    case "pageDown":
+      return { state: moveChoice(state, choices.length, 8), effects: [] };
+    case "enter": {
+      const choice = choiceAt(field, state);
+      if (!choice) return { state, effects: [] };
+      if (choice.status === "blocked") {
+        return { state, effects: [{ type: "notice", message: choice.statusText ?? `${choice.label} is unavailable` }] };
+      }
+      const clearing = (choice.action ?? KXM_TUI_SET_ACTION) === KXM_TUI_CLEAR_ACTION;
+      const step = invokeEffect(
+        state,
+        section,
+        field,
+        choice.action ?? KXM_TUI_SET_ACTION,
+        clearing ? void 0 : choice.id
+      );
+      return { state: { ...step.state, mode: "browse", filter: "", filtering: false }, effects: step.effects };
+    }
+    case "backspace": {
+      if (state.filter.length === 0) return { state: { ...state, filtering: false }, effects: [] };
+      return { state: { ...state, filter: deleteBackward(state.filter), choiceIndex: 0 }, effects: [] };
+    }
+    case "text": {
+      const text = normalizeInputText(decoded.text ?? "");
+      if (!text) return { state, effects: [] };
+      return { state: { ...state, filtering: true, filter: `${state.filter}${text}`, choiceIndex: 0 }, effects: [] };
+    }
+    default:
+      return { state, effects: [] };
+  }
+}
+function reduceBrowse(state, sections, section, field, decoded) {
+  if (state.help && (decoded.kind === "escape" || decoded.kind === "enter")) {
+    return { state: { ...state, help: false }, effects: [] };
+  }
+  if (state.help) return { state, effects: [] };
+  if (decoded.kind === "text") {
+    const key = decoded.text ?? "";
+    if (key === "q") return { state, effects: [{ type: "quit" }] };
+    if (key === "h" || key === "?") return { state: { ...state, help: true }, effects: [] };
+    const action = field?.actions?.find((candidate) => candidate.key === key);
+    if (action && field) return invokeEffect(state, section, field, action.action);
+    if ((key === "x" || key === "d") && field && field.value !== void 0 && field.kind !== "info") {
+      return invokeEffect(state, section, field, KXM_TUI_CLEAR_ACTION);
+    }
+    if (PANE_KEYS.has(key)) {
+      if (key === "h") return { state: { ...state, pane: "sections" }, effects: [] };
+      if (key === "l") return { state: { ...state, pane: "fields" }, effects: [] };
+      const delta = key === "k" ? -1 : 1;
+      return {
+        state: state.pane === "fields" ? moveField(state, section.fields, delta) : moveSection(state, sections, delta),
+        effects: []
+      };
+    }
+    return { state, effects: [] };
+  }
+  switch (decoded.kind) {
+    case "escape":
+      return state.pane === "fields" ? { state: { ...state, pane: "sections", mode: "browse" }, effects: [] } : { state, effects: [{ type: "quit" }] };
+    case "tab":
+      return { state: { ...state, pane: state.pane === "fields" ? "sections" : "fields" }, effects: [] };
+    case "right":
+      return { state: { ...state, pane: "fields" }, effects: [] };
+    case "left":
+      return { state: { ...state, pane: "sections" }, effects: [] };
+    case "up":
+      return { state: state.pane === "fields" ? moveField(state, section.fields, -1) : moveSection(state, sections, -1), effects: [] };
+    case "down":
+      return { state: state.pane === "fields" ? moveField(state, section.fields, 1) : moveSection(state, sections, 1), effects: [] };
+    case "pageUp":
+      return { state: moveSection(state, sections, -1), effects: [] };
+    case "pageDown":
+      return { state: moveSection(state, sections, 1), effects: [] };
+    case "enter":
+      return state.pane === "fields" ? enterField(state, section, field) : { state: { ...state, pane: "fields" }, effects: [] };
+    default:
+      return { state, effects: [] };
+  }
+}
 
 // packages/core/tui/src/tui/render.ts
 var SECTION_PANE_RATIO = 1 / 3;
+var MIN_PANE_WIDTH = 16;
+var PROGRESS_WIDTH = 20;
+var OUTPUT_TAIL = 6;
+var SPLIT_MIN_WIDTH = 76;
+function statusMark(status, theme, fallback) {
+  switch (status) {
+    case "ready":
+      return theme.fg("success", KXM_TUI_MARKS.ready);
+    case "available":
+      return theme.fg("accent", KXM_TUI_MARKS.available);
+    case "blocked":
+      return theme.fg("error", KXM_TUI_MARKS.blocked);
+    default:
+      return theme.dim(fallback);
+  }
+}
+function cursorMark(active, theme) {
+  return active ? theme.cursor(KXM_TUI_MARKS.cursor) : KXM_TUI_MARKS.blankCursor;
+}
+function paneSplit(width) {
+  const third = Math.max(MIN_PANE_WIDTH, Math.floor(width * SECTION_PANE_RATIO));
+  const sections = Math.min(third, Math.max(MIN_PANE_WIDTH, Math.floor(width / 2)));
+  return { sections, fields: Math.max(MIN_PANE_WIDTH, width - sections - 1) };
+}
+function fieldIsPending(state, section, field) {
+  return state.pending.includes(pendingKey({ source: section.source, sectionId: section.id, fieldId: field.id }));
+}
+function sectionRow(section, focused, pane, theme, width) {
+  const cursor2 = cursorMark(focused && pane === "sections", theme);
+  const flag2 = section.notice ? theme.fg(section.noticeLevel === "error" ? "error" : "warning", "!") : " ";
+  const count = section.fields.length;
+  const unset = section.fields.filter((field) => field.kind !== "info" && field.value === void 0).length;
+  const right = unset > 0 ? `${unset} unset / ${count}` : `${count} field${count === 1 ? "" : "s"}`;
+  return fitText(alignRight(`${cursor2} ${flag2} ${section.title}`, right, width), width);
+}
+function choiceSuffix(choice) {
+  const parts = [];
+  if (choice.detail) parts.push(choice.detail);
+  if (choice.statusText) parts.push(choice.statusText);
+  return parts.join(" \xB7 ");
+}
+function choiceRows(field, state, theme, width) {
+  const shown = visibleChoices(field, state.filter);
+  const lines = [];
+  if (state.filtering) {
+    lines.push(fitText(`   ${theme.dim(`filter: ${state.filter || "(type to filter \xB7 esc clears)"}`)}`, width));
+  }
+  if (shown.length === 0) {
+    lines.push(fitText(`   ${theme.dim("no match")}`, width));
+    return lines;
+  }
+  let position = -1;
+  for (const group of groupedKxmTuiChoices(field)) {
+    const filtered = shown.filter((choice) => (choice.group ?? "") === group.group);
+    if (filtered.length === 0) continue;
+    if (group.group) lines.push(fitText(`   ${theme.key(group.group.toUpperCase())}`, width));
+    for (const choice of filtered) {
+      position += 1;
+      lines.push(
+        fitText(
+          alignRight(
+            `${cursorMark(position === state.choiceIndex, theme)} ${statusMark(choice.status, theme, KXM_TUI_MARKS.pending)} ${choice.label}`,
+            choiceSuffix(choice),
+            width
+          ),
+          width
+        )
+      );
+    }
+  }
+  return lines;
+}
 var STEP_MARKS = {
   pending: "\xB7",
   satisfied: KXM_TUI_MARKS.passed,
@@ -50375,12 +51285,494 @@ var STEP_MARKS = {
   done: KXM_TUI_MARKS.passed,
   failed: KXM_TUI_MARKS.failed
 };
+function stepColor(state, theme) {
+  switch (state) {
+    case "running":
+      return (text) => theme.fg("accent", text);
+    case "done":
+      return (text) => theme.fg("success", text);
+    case "failed":
+      return (text) => theme.fg("error", text);
+    default:
+      return theme.dim;
+  }
+}
+function stepRows(steps, theme, width) {
+  return steps.map((step) => {
+    const paint = stepColor(step.state, theme);
+    return fitText(alignRight(`   ${paint(STEP_MARKS[step.state])} ${step.label}`, step.detail ?? "", width), width);
+  });
+}
+function progressRow(field, theme, width) {
+  const progress = field.progress;
+  if (!progress) return "";
+  const ratio = progress.ratio;
+  const right = ratio === void 0 ? "working" : `${Math.round(ratio * 100)}%`;
+  return fitText(alignRight(`   ${progress.label}`, `${progressBar(ratio, PROGRESS_WIDTH)} ${right}`, width), width);
+}
+function focusedFieldDetail(field, state, theme, width) {
+  const lines = [];
+  if (field.keyPath) lines.push(fitText(`   ${theme.dim(`key: ${field.keyPath}`)}`, width));
+  for (const line of wrapPlain(field.detail ?? "", width - 3)) {
+    if (line) lines.push(fitText(`   ${theme.dim(line)}`, width));
+  }
+  for (const line of wrapPlain(field.statusText ?? "", width - 3)) {
+    if (line) lines.push(fitText(`   ${theme.fg("error", line)}`, width));
+  }
+  const progress = progressRow(field, theme, width);
+  if (progress) lines.push(progress);
+  if (field.steps?.length) lines.push(...stepRows(field.steps, theme, width));
+  if (field.output?.length) {
+    lines.push(...field.output.slice(-OUTPUT_TAIL).map((line) => fitText(`   ${theme.dim(line)}`, width)));
+  }
+  if (field.actions?.length) {
+    lines.push(fitText(`   ${theme.key(field.actions.map((action) => `${action.key} ${action.label}`).join(" \xB7 "))}`, width));
+  }
+  if (state.mode === "choices") lines.push(...choiceRows(field, state, theme, width));
+  if (state.mode === "edit" || field.awaitingInput) {
+    const draft = state.mode === "edit" ? `${state.draft.slice(0, state.caret)}|${state.draft.slice(state.caret)}` : "|";
+    lines.push(fitText(`   ${theme.dim("\u203A")} ${draft}`, width));
+  }
+  return lines;
+}
+function fieldRows(section, state, theme, width, nowMs) {
+  const lines = [];
+  section.fields.forEach((field, index) => {
+    const focused = state.pane === "fields" && state.fieldIndex === index;
+    if (field.kind === "info") {
+      lines.push(fitText(`   ${theme.dim(field.label)}  ${theme.dim(field.value ?? field.placeholder ?? "")}`, width));
+      return;
+    }
+    const pending = fieldIsPending(state, section, field);
+    const mark = statusMark(field.status, theme, pending ? "\u25CC" : KXM_TUI_MARKS.pending);
+    const value = pending && field.value === void 0 ? theme.dim("saving\u2026") : field.value;
+    const shown = value ?? theme.dim(field.placeholder ?? "not set");
+    const age2 = field.updatedAt ? theme.dim(` (${formatAge(field.updatedAt, nowMs)})`) : "";
+    lines.push(fitText(`${cursorMark(focused, theme)} ${mark} ${alignRight(field.label, `${shown}${age2}`, width - 4)}`, width));
+    if (focused) lines.push(...focusedFieldDetail(field, state, theme, width));
+  });
+  return lines;
+}
+function noticeRows(section, theme, width) {
+  if (!section?.notice) return [];
+  const token = section.noticeLevel === "error" ? "error" : "warning";
+  return wrapPlain(section.notice, width - 2).map((line) => fitText(theme.fg(token, line), width));
+}
+function singlePaneLines(sections, state, theme, width, nowMs) {
+  const section = sections[state.sectionIndex];
+  if (state.pane === "fields" && section) {
+    return [
+      fitText(theme.headerBg(alignRight(` ${section.title}`, section.source, width)), width),
+      ...noticeRows(section, theme, width),
+      ...fieldRows(section, state, theme, width, nowMs)
+    ];
+  }
+  return [
+    fitText(theme.headerBg(alignRight(" SECTIONS", `${sections.length}`, width)), width),
+    ...sections.map((candidate, index) => sectionRow(candidate, index === state.sectionIndex, state.pane, theme, width))
+  ];
+}
+function twoPaneLines(sections, state, theme, width, nowMs) {
+  const split = paneSplit(width);
+  const left = [fitText(theme.key(" SECTIONS"), split.sections)];
+  sections.forEach(
+    (candidate, index) => left.push(sectionRow(candidate, index === state.sectionIndex, state.pane, theme, split.sections))
+  );
+  const right = [];
+  const section = sections[state.sectionIndex];
+  if (section) {
+    right.push(fitText(alignRight(` ${section.title}`, section.source, split.fields), split.fields));
+    if (section.detail) right.push(fitText(` ${theme.dim(section.detail)}`, split.fields));
+    right.push(...noticeRows(section, theme, split.fields));
+    right.push(...fieldRows(section, state, theme, split.fields, nowMs));
+  } else {
+    right.push(fitText(theme.dim("no surface is published"), split.fields));
+  }
+  const rows = [];
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    rows.push(fitText(`${padRight(left[index] ?? "", split.sections)} ${right[index] ?? ""}`, width));
+  }
+  return rows;
+}
+function renderKxmTuiPanel(sections, state, theme, options, width = 120) {
+  const nowMs = options.nowMs ?? Date.now();
+  const title = `${theme.cursor(options.title)}${options.breadcrumb ? `  ${theme.dim(options.breadcrumb)}` : ""}`;
+  const header = [fitText(title, width)];
+  if (state.help) {
+    const help = (options.helpLines ?? ["no help published"]).flatMap((line) => wrapPlain(line, Math.max(1, width - 2)));
+    return [...header, ...help.map((line) => fitText(line, width)), fitText(theme.dim("esc close help"), width)];
+  }
+  const body = width < SPLIT_MIN_WIDTH ? singlePaneLines(sections, state, theme, width, nowMs) : twoPaneLines(sections, state, theme, width, nowMs);
+  const footer = options.footer ? [fitText(theme.dim(options.footer), width)] : [];
+  return [...header, ...body, ...footer];
+}
 
 // packages/core/tui/src/tui/panelComponent.ts
 var KXM_TUI_PANEL_HELP = Object.freeze([
   "\u2191\u2193 move \xB7 \u2190\u2192 or Tab panes \xB7 PgUp/PgDn section \xB7 enter edit or open list",
   "type to filter a list \xB7 x clears a value \xB7 esc backs out \xB7 q quit \xB7 h help"
 ]);
+function rowsComponent() {
+  const stack = new VStack([], { gap: 0 });
+  const scroll = new ScrollView(stack, { primary: true, overscroll: "contain", scrollbar: "auto" });
+  const fill = (rows) => {
+    stack.clear();
+    for (const row of rows) stack.addChild(new TruncatedText(row, 0, 0));
+  };
+  return { stack, scroll, fill };
+}
+var KxmTuiPanelComponent = class {
+  root = new VStack([], { gap: 0 });
+  options;
+  body = rowsComponent();
+  sections;
+  state;
+  notice;
+  unsubscribe;
+  constructor(options) {
+    this.options = options;
+    this.sections = options.registry.getSections();
+    this.state = initialKxmTuiPanelState(this.sections);
+    this.unsubscribe = options.registry.subscribe(() => this.refresh());
+    this.rebuild();
+  }
+  getState() {
+    return this.state;
+  }
+  getSections() {
+    return this.sections;
+  }
+  /** Point the cursor at a field, e.g. after opening a named section. */
+  focus(sectionId, fieldId) {
+    const sectionIndex = this.sections.findIndex((section) => section.id === sectionId);
+    if (sectionIndex < 0) return;
+    const fields = this.sections[sectionIndex]?.fields ?? [];
+    const fieldIndex = fieldId ? Math.max(0, fields.findIndex((field) => field.id === fieldId)) : this.state.fieldIndex;
+    this.state = { ...this.state, pane: "fields", sectionIndex, fieldIndex };
+    this.rebuild();
+    this.options.requestRender();
+  }
+  setStatus(message) {
+    this.notice = message;
+    this.rebuild();
+    this.options.requestRender();
+  }
+  refresh() {
+    const next = this.options.registry.getSections();
+    this.sections = next;
+    this.state = reconcileKxmTuiPanelState(this.state, next);
+    this.rebuild();
+    this.options.requestRender();
+  }
+  handleInput(data) {
+    if (matchesKey(data, Key.pageUp) || matchesKey(data, Key.ctrl("u"))) {
+      this.body.scroll.scrollBy(-(this.viewport() - 2));
+      this.options.requestRender();
+      return;
+    }
+    if (matchesKey(data, Key.pageDown) || matchesKey(data, Key.ctrl("d"))) {
+      this.body.scroll.scrollBy(this.viewport() - 2);
+      this.options.requestRender();
+      return;
+    }
+    const step = reduceKxmTuiInput(this.state, this.sections, data);
+    this.state = step.state;
+    for (const effect of step.effects) this.run(effect);
+    this.rebuild();
+    this.options.requestRender();
+  }
+  viewport() {
+    const height = this.body.scroll.viewportHeight;
+    return height > 3 ? height : 10;
+  }
+  run(effect) {
+    if (effect.type === "quit") {
+      this.options.onQuit();
+      return;
+    }
+    if (effect.type === "notice") {
+      this.notice = effect.message;
+      return;
+    }
+    this.notice = void 0;
+    void this.options.registry.invoke(effect.invocation).then((result) => {
+      if (!result.ok) this.setStatus(result.message ?? "the owner refused that change");
+      else if (this.notice === void 0) this.setStatus(void 0);
+    });
+  }
+  footer() {
+    const status = this.notice ?? this.options.statusText?.();
+    const base = "\u2191\u2193 \xB7 \u2190\u2192 panes \xB7 enter edit \xB7 x clear \xB7 esc back \xB7 h help \xB7 q quit";
+    return status ? `${base}  ${status}` : base;
+  }
+  rebuild() {
+    const theme = this.options.theme;
+    const width = this.options.getWidth?.() ?? 120;
+    const title = new Box(1, 0, theme.headerBg);
+    title.addChild(new HStack([
+      { component: new Text(theme.cursor(this.options.title), 0, 0), basis: 12, shrink: 1, minSize: 6 },
+      {
+        component: new Text(
+          this.options.breadcrumb ? theme.dim(fitText(this.options.breadcrumb, Math.max(4, width - 16))) : "",
+          0,
+          0
+        ),
+        grow: 1,
+        shrink: 1,
+        minSize: 8
+      }
+    ], { gap: 2 }));
+    this.body.fill(
+      renderKxmTuiPanel(this.sections, this.state, theme, {
+        title: this.options.title,
+        ...this.options.breadcrumb ? { breadcrumb: this.options.breadcrumb } : {},
+        helpLines: this.options.helpLines ?? KXM_TUI_PANEL_HELP,
+        footer: this.footer()
+      }, width)
+    );
+    const panel = new Box(0, 0, theme.panelBg);
+    panel.addChild(this.body.scroll);
+    this.root.clear();
+    this.root.addChild(title, { basis: "auto", shrink: 0 });
+    this.root.addChild(panel, { basis: "auto", grow: 1, shrink: 1, minSize: 1 });
+  }
+  handleMouse(event) {
+    return this.root.handleMouse?.(event);
+  }
+  invalidate() {
+    this.root.invalidate();
+  }
+  render(width) {
+    return this.root.render(width);
+  }
+  dispose() {
+    this.unsubscribe();
+    this.unsubscribe = () => void 0;
+  }
+};
+
+// packages/core/tui/src/services/registry.ts
+function describe(error) {
+  if (error instanceof Error && error.message) return error.message.split(/\r?\n/u)[0].slice(0, KXM_TUI_LIMITS.detailMax);
+  return String(error).split(/\r?\n/u)[0].slice(0, KXM_TUI_LIMITS.detailMax);
+}
+function normalizeSource(source) {
+  if (!/^[A-Za-z0-9@][A-Za-z0-9@/._:-]*$/u.test(source) || source.length > KXM_TUI_LIMITS.sourceMax) {
+    throw new Error(`invalid kxm tui surface source: ${source.slice(0, 64)}`);
+  }
+  return source;
+}
+function createKxmTuiRegistry(options = {}) {
+  const contributions = /* @__PURE__ */ new Map();
+  const notices = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const published = /* @__PURE__ */ new Map();
+  const issues = /* @__PURE__ */ new Map();
+  let generation = 0;
+  let disposed = false;
+  let epoch = 0;
+  const report2 = (error, context) => {
+    if (options.onInternalError) options.onInternalError(error, context);
+  };
+  const emit = (event) => {
+    for (const listener of Array.from(listeners)) {
+      try {
+        listener(event);
+      } catch (error) {
+        report2(error, "listener");
+      }
+    }
+  };
+  function readOwner(source, force) {
+    if (!force) {
+      const cached = published.get(source);
+      if (cached) return cached;
+    }
+    const contribution = contributions.get(source);
+    if (!contribution) {
+      published.set(source, []);
+      return [];
+    }
+    let sections;
+    try {
+      const raw = contribution.listSections();
+      const ownerIssues = validateKxmTuiSurface(raw);
+      if (ownerIssues.length > 0) {
+        issues.set(source, ownerIssues);
+        sections = raw.filter((section) => Boolean(section) && typeof section === "object").map((section) => ({
+          ...section,
+          notice: section.notice ?? `published surface was refused: ${ownerIssues[0].code} at ${ownerIssues[0].path}`,
+          noticeLevel: "error"
+        }));
+      } else {
+        issues.delete(source);
+        sections = raw;
+      }
+    } catch (error) {
+      issues.set(source, [{ path: source, code: "list_sections_failed", message: describe(error) }]);
+      report2(error, `listSections:${source}`);
+      sections = [{ source, id: "error", title: source, order: 900, notice: describe(error), noticeLevel: "error", fields: [] }];
+    }
+    const pending = notices.get(source);
+    const withNotice = pending !== void 0 && sections.length > 0 ? sections.map((section, index) => index === 0 ? { ...section, notice: pending, noticeLevel: "error" } : section) : sections;
+    published.set(source, withNotice);
+    return withNotice;
+  }
+  function merged() {
+    const all = [];
+    for (const source of contributions.keys()) all.push(...readOwner(source, false));
+    return all.slice().sort((a, b2) => a.order - b2.order || a.source.localeCompare(b2.source) || a.title.localeCompare(b2.title));
+  }
+  return {
+    register(contribution) {
+      if (disposed) throw new Error("kxm tui registry is disposed");
+      const source = normalizeSource(contribution.source);
+      notices.delete(source);
+      published.delete(source);
+      issues.delete(source);
+      contributions.set(source, { ...contribution, source });
+      emit({ reason: "publish", source });
+    },
+    unregister(source) {
+      contributions.delete(source);
+      published.delete(source);
+      issues.delete(source);
+      notices.delete(source);
+      emit({ reason: "publish", source });
+    },
+    getSections() {
+      return merged();
+    },
+    getIssues() {
+      return [...issues.values()].flat();
+    },
+    async invoke(invocation) {
+      if (disposed) return { ok: false, message: "kxm tui registry is disposed" };
+      const contribution = contributions.get(invocation.source);
+      if (!contribution) {
+        emit({ reason: "refused", source: invocation.source, message: "unknown owner" });
+        return { ok: false, message: `${invocation.source} does not own a surface here` };
+      }
+      const handler = contribution.handlers[invocation.action];
+      if (!handler) {
+        const message = `${invocation.source} does not accept "${invocation.action}"`;
+        emit({ reason: "refused", source: invocation.source, message });
+        return { ok: false, message };
+      }
+      const currentEpoch = epoch;
+      try {
+        await handler({
+          sectionId: invocation.sectionId,
+          fieldId: invocation.fieldId,
+          action: invocation.action,
+          ...invocation.value === void 0 ? {} : { value: invocation.value }
+        });
+      } catch (error) {
+        const failure = contribution.describeError?.(error, invocation.action) ?? describe(error);
+        notices.set(invocation.source, failure);
+        emit({ reason: "failed", source: invocation.source, message: failure });
+        readOwner(invocation.source, true);
+        generation += 1;
+        return { ok: false, message: failure };
+      }
+      if (currentEpoch !== epoch) {
+        readOwner(invocation.source, true);
+        return { ok: false, message: "stale write result was discarded" };
+      }
+      notices.delete(invocation.source);
+      readOwner(invocation.source, true);
+      generation += 1;
+      emit({ reason: "publish", source: invocation.source });
+      return { ok: true };
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getGeneration() {
+      return generation;
+    },
+    hasSource(source) {
+      return contributions.has(source);
+    },
+    listSources() {
+      return [...contributions.keys()];
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      epoch += 1;
+      listeners.clear();
+      contributions.clear();
+      published.clear();
+      issues.clear();
+      notices.clear();
+    }
+  };
+}
+
+// packages/core/tui/src/adapters/terminal.ts
+function renderKxmTuiPanelFrame(input) {
+  const theme = input.theme ?? createPlainKxmTuiTheme();
+  const lines = renderKxmTuiPanel(
+    input.registry.getSections(),
+    initialKxmTuiPanelState(input.registry.getSections()),
+    theme,
+    { title: input.title, footer: input.footer ?? "non-interactive frame", nowMs: input.nowMs ?? Date.now() },
+    input.width ?? 100
+  );
+  return `${lines.map((line) => stripTerminalSequences(line)).join("\n")}
+`;
+}
+async function runKxmTuiPanel(input) {
+  const theme = input.theme ?? createDefaultKxmTuiTheme();
+  const tty = input.isTty ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (!tty) {
+    input.stdout(renderKxmTuiPanelFrame({
+      registry: input.registry,
+      title: input.title,
+      theme,
+      ...input.now === void 0 ? {} : { nowMs: input.now() },
+      ...input.breadcrumb ? { footer: input.breadcrumb } : {}
+    }));
+    return 0;
+  }
+  const terminal = input.terminal ?? new ProcessTerminal();
+  const tui = new TuiAltScreen(terminal, false, void 0, { mouse: true });
+  let timer;
+  let stopped = false;
+  let finished = () => void 0;
+  const done = new Promise((resolve35) => {
+    finished = resolve35;
+  });
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    if (timer) clearInterval(timer);
+    input.abort?.removeEventListener("abort", stop);
+    panel.dispose();
+    tui.stop();
+    finished();
+  };
+  const panel = new KxmTuiPanelComponent({
+    registry: input.registry,
+    theme,
+    title: input.title,
+    ...input.breadcrumb ? { breadcrumb: input.breadcrumb } : {},
+    ...input.helpLines ? { helpLines: input.helpLines } : {},
+    requestRender: () => tui.requestRender(),
+    onQuit: stop,
+    getWidth: () => terminal.columns
+  });
+  input.abort?.addEventListener("abort", stop, { once: true });
+  tui.setLayoutRoot(panel.root);
+  tui.setFocus(panel);
+  tui.start();
+  timer = setInterval(() => panel.refresh(), input.pollMs ?? 2e3);
+  timer.unref?.();
+  await done;
+  return stopped && input.abort?.aborted ? 130 : 0;
+}
 
 // plugins/kxm/src/external-effects.ts
 init_database();
@@ -53056,7 +54448,7 @@ init_routing();
 init_prices();
 import { spawnSync as spawnSync15 } from "node:child_process";
 import { createHash as createHash19 } from "node:crypto";
-import { existsSync as existsSync48, mkdtempSync as mkdtempSync3, readFileSync as readFileSync42, rmSync as rmSync13 } from "node:fs";
+import { existsSync as existsSync49, mkdtempSync as mkdtempSync3, readFileSync as readFileSync43, rmSync as rmSync13 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { basename as basename11, extname as extname3, join as join57, resolve as resolve33 } from "node:path";
 import { createInterface as createInterface3 } from "node:readline";
@@ -54301,6 +55693,304 @@ function executeSshRun(params) {
 // plugins/kxm/src/cli/system.ts
 init_config();
 
+// plugins/kxm/src/config-editor.ts
+var import_yaml21 = __toESM(require_dist(), 1);
+import { existsSync as existsSync46, readFileSync as readFileSync41 } from "node:fs";
+init_config();
+var KXM_CONFIG_EDITOR_SOURCE = "kxm/config";
+var INTEGER_TEXT = /^(0|[1-9][0-9]*)$/;
+var DECIMAL_TEXT = /^(0|[1-9][0-9]*)(\.[0-9]{1,6})?$/;
+var TEXT_VALUE = /^[A-Za-z0-9@][A-Za-z0-9@._:/-]{0,127}$/;
+var SCREEN_CHOICES = ["agents", "tasks", "workflows", "plans", "inbox", "procs", "spend"];
+var SECTIONS = [
+  {
+    id: "user",
+    title: "User",
+    order: 10,
+    fields: [
+      { id: "user-theme", label: "Theme", keyPath: "user.theme", spec: { kind: "enum", choices: ["dark", "light", "minimal"] } },
+      { id: "user-token-budget", label: "Token budget", keyPath: "user.tokenBudget", spec: { kind: "number", integer: true, min: 1, max: 2e6 } }
+    ]
+  },
+  {
+    id: "defaults",
+    title: "Defaults",
+    order: 20,
+    fields: [
+      { id: "defaults-workflow", label: "Workflow", keyPath: "defaults.workflow", spec: { kind: "text" } },
+      { id: "defaults-harness", label: "Harness", keyPath: "defaults.harness", spec: { kind: "text" } }
+    ]
+  },
+  {
+    id: "dash",
+    title: "Dashboard",
+    order: 30,
+    fields: [
+      { id: "dash-screen", label: "Default screen", keyPath: "dash.defaultScreen", spec: { kind: "enum", choices: SCREEN_CHOICES } },
+      { id: "dash-refresh", label: "Refresh interval", keyPath: "dash.refreshIntervalMs", spec: { kind: "number", integer: true, min: 250, max: 36e5 } },
+      { id: "dash-auto-open", label: "Auto-open", keyPath: "dash.autoOpen", spec: { kind: "enum", choices: ["true", "false"] } }
+    ]
+  },
+  {
+    id: "sync",
+    title: "Sync",
+    order: 40,
+    fields: [
+      { id: "sync-tracker", label: "Default tracker", keyPath: "sync.defaultTracker", spec: { kind: "enum", choices: ["github", "jira", "none"] } }
+    ]
+  },
+  {
+    id: "hub",
+    title: "Hub",
+    order: 50,
+    fields: [
+      {
+        id: "hub-auto-start",
+        label: "Auto-start",
+        keyPath: "hub.autoStart",
+        spec: { kind: "enum", choices: ["background", "off"] },
+        note: "Hub URLs and key references stay out of this panel."
+      }
+    ]
+  },
+  {
+    id: "improvement",
+    title: "Improvement",
+    order: 60,
+    fields: [
+      { id: "improvement-policy", label: "Promotion policy", keyPath: "improvement.promotionPolicy", spec: { kind: "enum", choices: ["manual_pr", "critic_quorum", "auto_threshold"] } },
+      { id: "improvement-half-life", label: "Telemetry half-life", keyPath: "improvement.telemetryHalfLifeDays", spec: { kind: "number", integer: false, min: 1e-6, max: 3650 } },
+      { id: "improvement-min-runs", label: "Minimum runs", keyPath: "improvement.autoThreshold.minRuns", spec: { kind: "number", integer: true, min: 1, max: 1e6 } },
+      { id: "improvement-min-pass-rate", label: "Minimum pass rate", keyPath: "improvement.autoThreshold.minPassRate", spec: { kind: "number", integer: false, min: 0, max: 1 } },
+      { id: "improvement-min-cost-savings", label: "Minimum cost savings", keyPath: "improvement.autoThreshold.minCostSavings", spec: { kind: "number", integer: false, min: 0, max: 1e6 } }
+    ]
+  },
+  {
+    id: "routing",
+    title: "Routing",
+    order: 70,
+    fields: [
+      {
+        id: "routing-shadow",
+        label: "Shadow execution",
+        keyPath: "routing.shadowExecution.enabled",
+        spec: { kind: "enum", choices: ["true", "false"] },
+        note: "Strategy, fallback, and context limits stay in role and route files."
+      },
+      { id: "routing-sample-rate", label: "Sample rate", keyPath: "routing.shadowExecution.sampleRate", spec: { kind: "number", integer: false, min: 0, max: 1 } },
+      { id: "routing-breaker-mode", label: "Breaker mode", keyPath: "routing.circuitBreaker.mode", spec: { kind: "enum", choices: ["soft_demotion", "quarantine"] } },
+      { id: "routing-failure-threshold", label: "Failure threshold", keyPath: "routing.circuitBreaker.failureThreshold", spec: { kind: "number", integer: true, min: 1, max: 1e4 } },
+      { id: "routing-window-seconds", label: "Window seconds", keyPath: "routing.circuitBreaker.windowSeconds", spec: { kind: "number", integer: true, min: 1, max: 31536e3 } },
+      { id: "routing-cooldown-seconds", label: "Cooldown seconds", keyPath: "routing.circuitBreaker.cooldownSeconds", spec: { kind: "number", integer: true, min: 0, max: 31536e3 } },
+      { id: "routing-penalty", label: "Penalty multiplier", keyPath: "routing.circuitBreaker.penaltyMultiplier", spec: { kind: "number", integer: false, min: 1e-6, max: 1e3 } }
+    ]
+  },
+  {
+    id: "telemetry",
+    title: "Telemetry",
+    order: 80,
+    fields: [
+      { id: "telemetry-federated", label: "Federated", keyPath: "telemetry.federated", spec: { kind: "enum", choices: ["true", "false"] } },
+      { id: "telemetry-anonymize", label: "Anonymize", keyPath: "telemetry.anonymize", spec: { kind: "enum", choices: ["true", "false"] } }
+    ]
+  }
+];
+var KxmConfigEditorError = class extends Error {
+  code = "config_edit_refused";
+  constructor(message) {
+    super(message);
+    this.name = "KxmConfigEditorError";
+  }
+};
+function createKxmConfigEditorContribution(target) {
+  return {
+    source: KXM_CONFIG_EDITOR_SOURCE,
+    republishAfterWrite: true,
+    listSections: () => listConfigEditorSections(target),
+    handlers: {
+      [KXM_TUI_SET_ACTION]: (input) => {
+        writeConfigEditorValue(target, input.sectionId, input.fieldId, input.value);
+      },
+      [KXM_TUI_CLEAR_ACTION]: (input) => {
+        clearConfigEditorValue(target, input.sectionId, input.fieldId);
+      }
+    },
+    describeError: (error) => error instanceof Error && error.message ? error.message : "config edit failed"
+  };
+}
+function scopeFile(target) {
+  return kxmConfigFileForScope(target.cwd, target.scope, target.userConfigDir);
+}
+function scopePhrase(scope) {
+  return scope === "project" ? "the project file .kxm/config.yaml" : "the user file config.yaml";
+}
+function listConfigEditorSections(target) {
+  const config = loadKxmConfig(target.cwd, {
+    ...target.userConfigDir === void 0 ? {} : { userConfigDir: target.userConfigDir },
+    layers: target.scope === "user" ? "user" : "all"
+  });
+  const owned = readScopeDocument(scopeFile(target));
+  const where = scopePhrase(target.scope);
+  return SECTIONS.map((section) => {
+    const fields = section.fields.map((field) => publishField(field, config, owned, where));
+    const diagnosis = fields.find((field) => field.statusText)?.statusText;
+    return {
+      source: KXM_CONFIG_EDITOR_SOURCE,
+      id: section.id,
+      title: section.title,
+      order: section.order,
+      detail: `kxm.config.v1 \xB7 ${target.scope} scope. Re-read from disk after each write.`,
+      ...diagnosis === void 0 ? {} : { notice: diagnosis, noticeLevel: "error" },
+      fields
+    };
+  });
+}
+function publishField(field, config, owned, where) {
+  const effective = getKxmConfigValue(config, field.keyPath);
+  const stored = ownValue(owned, field.keyPath);
+  const shown = displayScalar(effective);
+  const inherited = !stored.present;
+  const diagnosis = storedDiagnosis(field, stored, effective);
+  const detail = [
+    `Writes ${where}.`,
+    inherited ? "Inherited." : "Set in this scope.",
+    "Clear removes only this override.",
+    field.note ?? "",
+    diagnosis ?? ""
+  ].filter((part) => part.length > 0).join(" ");
+  const choices = field.spec.kind === "enum" ? field.spec.choices.map((choice) => ({ id: choice, label: choice })) : void 0;
+  return {
+    id: field.id,
+    label: field.label,
+    kind: field.spec.kind === "enum" ? "enum" : "text",
+    keyPath: field.keyPath,
+    detail,
+    status: "ready",
+    ...shown === void 0 ? {} : { value: shown },
+    ...choices === void 0 ? {} : { choices },
+    ...diagnosis === void 0 ? {} : { statusText: diagnosis }
+  };
+}
+function displayScalar(value) {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return void 0;
+}
+function isBooleanEnum(spec) {
+  return spec.kind === "enum" && spec.choices.length === 2 && spec.choices.every((choice) => choice === "true" || choice === "false");
+}
+function storedTypeMatches(field, value) {
+  if (field.spec.kind === "number") {
+    return typeof value === "number" && Number.isFinite(value) && (!field.spec.integer || Number.isInteger(value));
+  }
+  if (isBooleanEnum(field.spec)) return typeof value === "boolean";
+  return typeof value === "string";
+}
+function storedDiagnosis(field, stored, effective) {
+  if (!stored.present) return void 0;
+  if (!storedTypeMatches(field, stored.value)) return "stored type does not match this field";
+  if (field.spec.kind === "enum" && !isBooleanEnum(field.spec) && !field.spec.choices.includes(stored.value)) {
+    return "stored value is not a supported scalar";
+  }
+  if (field.spec.kind === "number") {
+    const value = stored.value;
+    if (value < field.spec.min || value > field.spec.max) return "stored value is not a supported scalar";
+  }
+  if (stored.value !== effective) return "stored value is not a supported scalar";
+  return void 0;
+}
+function writeConfigEditorValue(target, sectionId, fieldId, raw) {
+  const field = requireField(sectionId, fieldId);
+  const value = parseEditorValue(field, raw);
+  setKxmConfigValue(target.cwd, field.keyPath, value, {
+    scope: target.scope,
+    ...target.userConfigDir === void 0 ? {} : { userConfigDir: target.userConfigDir }
+  });
+}
+function clearConfigEditorValue(target, sectionId, fieldId) {
+  const field = requireField(sectionId, fieldId);
+  deleteKxmConfigValue(target.cwd, field.keyPath, {
+    scope: target.scope,
+    ...target.userConfigDir === void 0 ? {} : { userConfigDir: target.userConfigDir }
+  });
+}
+function requireField(sectionId, fieldId) {
+  const section = SECTIONS.find((item) => item.id === sectionId);
+  const field = section?.fields.find((item) => item.id === fieldId);
+  if (!field) throw new KxmConfigEditorError("unknown configuration field");
+  return field;
+}
+function parseEditorValue(field, raw) {
+  if (raw === void 0) throw new KxmConfigEditorError("a value is required");
+  if (raw.length === 0 || raw.length > 128 || /[\u0000-\u001f\u007f]/u.test(raw)) {
+    throw new KxmConfigEditorError("value must be a single bounded line");
+  }
+  if (field.spec.kind === "enum") {
+    if (!field.spec.choices.includes(raw)) throw new KxmConfigEditorError("value is not a supported choice");
+    if (isBooleanEnum(field.spec)) return raw === "true";
+    return raw;
+  }
+  if (field.spec.kind === "text") {
+    if (!TEXT_VALUE.test(raw)) throw new KxmConfigEditorError("value must be a single bounded line");
+    return raw;
+  }
+  if (!(field.spec.integer ? INTEGER_TEXT : DECIMAL_TEXT).test(raw)) {
+    throw new KxmConfigEditorError("value must be a finite number in range");
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || field.spec.integer && !Number.isInteger(parsed) || parsed < field.spec.min || parsed > field.spec.max) {
+    throw new KxmConfigEditorError("value must be a finite number in range");
+  }
+  return parsed;
+}
+function readScopeDocument(file) {
+  if (!existsSync46(file)) return void 0;
+  const parsed = (0, import_yaml21.parse)(readFileSync41(file, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new KxmConfigEditorError(`config file ${file} must be a mapping`);
+  }
+  return parsed;
+}
+function ownValue(root, keyPath) {
+  if (!root) return { present: false, value: void 0 };
+  let cursor2 = root;
+  for (const part of keyPath.split(".")) {
+    if (!cursor2 || typeof cursor2 !== "object" || Array.isArray(cursor2)) return { present: false, value: void 0 };
+    const record = cursor2;
+    if (!Object.prototype.hasOwnProperty.call(record, part)) return { present: false, value: void 0 };
+    cursor2 = record[part];
+  }
+  return { present: true, value: cursor2 };
+}
+var EDITOR_HELP = [
+  "\u2191\u2193 move \xB7 enter edits \xB7 x clears this scope's override \xB7 q quits",
+  "Writes are checked, saved, then re-read. A refused edit leaves the file unchanged."
+];
+var FRAME_NOW_MS = Date.UTC(2026, 9, 11);
+async function runKxmConfigEditor(input) {
+  const registry = createKxmTuiRegistry();
+  try {
+    registry.register(createKxmConfigEditorContribution(input.target));
+    registry.getSections();
+    const failed2 = registry.getIssues()[0];
+    if (failed2) throw new KxmConfigEditorError(failed2.message);
+    const interactive = input.isTty && !input.dryRun;
+    return await runKxmTuiPanel({
+      registry,
+      title: "KXM configuration",
+      breadcrumb: `kxm.config.v1 \xB7 ${input.target.scope} scope`,
+      helpLines: EDITOR_HELP,
+      stdout: input.stdout,
+      isTty: interactive,
+      ...interactive ? {} : { theme: createPlainKxmTuiTheme() },
+      now: () => FRAME_NOW_MS
+    });
+  } finally {
+    registry.dispose();
+  }
+}
+
 // plugins/kxm/src/autocomplete.ts
 var TOP_LEVEL_COMMANDS = [
   "init",
@@ -54354,7 +56044,7 @@ var SUBCOMMANDS = {
   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"],
@@ -54476,7 +56166,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)'
@@ -54520,7 +56210,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"
@@ -54540,7 +56230,7 @@ complete -c kxm -n "__fish_seen_subcommand_from goal" -a "create list get"
 }
 
 // plugins/kxm/src/completion-install.ts
-import { existsSync as existsSync46, mkdirSync as mkdirSync33, readFileSync as readFileSync41, writeFileSync as writeFileSync28 } from "node:fs";
+import { existsSync as existsSync47, mkdirSync as mkdirSync33, readFileSync as readFileSync42, writeFileSync as writeFileSync28 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import { basename as basename10, delimiter, dirname as dirname24, isAbsolute as isAbsolute11, join as join55, resolve as resolve32 } from "node:path";
 var COMPLETION_MARKER = "# kxm completion";
@@ -54569,7 +56259,7 @@ function completionScriptPath(shell, options = {}) {
 function bashRcCandidate(options) {
   const home = effectiveHome(options);
   const candidates = [join55(home, ".bashrc"), join55(home, ".bash_profile")];
-  const existing = candidates.find((candidate) => existsSync46(candidate));
+  const existing = candidates.find((candidate) => existsSync47(candidate));
   return existing ?? candidates[0];
 }
 function zshRcCandidate(options) {
@@ -54614,13 +56304,13 @@ function installShellCompletion(shellInput, options = {}) {
   const scriptPath = completionScriptPath(shell, options);
   const { rcFile } = completionRcTarget(shell, options);
   const script = generateShellCompletion(shell);
-  const existingScript = existsSync46(scriptPath);
-  const existingScriptMatches = existingScript && readFileSync41(scriptPath, "utf8") === script;
+  const existingScript = existsSync47(scriptPath);
+  const existingScriptMatches = existingScript && readFileSync42(scriptPath, "utf8") === script;
   let rcModified = false;
   let alreadyInstalled = false;
   if (shell === "fish") {
     const fishTarget = fishCompletionTarget(shell, options);
-    const fishInstalled = existsSync46(fishTarget) && readFileSync41(fishTarget, "utf8") === script;
+    const fishInstalled = existsSync47(fishTarget) && readFileSync42(fishTarget, "utf8") === script;
     alreadyInstalled = fishInstalled;
     if (!options.dryRun && (!fishInstalled || options.overwrite)) {
       mkdirSync33(resolve32(fishTarget, ".."), { recursive: true });
@@ -54637,7 +56327,7 @@ function installShellCompletion(shellInput, options = {}) {
   }
   if (rcFile) {
     const line = sourceLine(shell, scriptPath);
-    const rcContent = existsSync46(rcFile) ? readFileSync41(rcFile, "utf8") : "";
+    const rcContent = existsSync47(rcFile) ? readFileSync42(rcFile, "utf8") : "";
     alreadyInstalled = rcContent.includes(line) || rcContent.includes(`${COMPLETION_MARKER}`);
   }
   if (!options.dryRun) {
@@ -54653,7 +56343,7 @@ ${marker}
 ${line}
 `;
       mkdirSync33(resolve32(rcFile, ".."), { recursive: true });
-      writeFileSync28(rcFile, (existsSync46(rcFile) ? readFileSync41(rcFile, "utf8") : "") + stanza, { encoding: "utf8" });
+      writeFileSync28(rcFile, (existsSync47(rcFile) ? readFileSync42(rcFile, "utf8") : "") + stanza, { encoding: "utf8" });
       rcModified = true;
     }
   }
@@ -54670,13 +56360,13 @@ function kxmBinDir(env = process.env) {
   const argv1 = env.KXM_ENTRY ?? process.argv[1];
   if (argv1 && isAbsolute11(argv1)) {
     const dir = dirname24(argv1);
-    if (existsSync46(join55(dir, process.platform === "win32" ? "kxm.cmd" : "kxm"))) return dir;
+    if (existsSync47(join55(dir, process.platform === "win32" ? "kxm.cmd" : "kxm"))) return dir;
   }
   const pathEnv = env.PATH ?? "";
   for (const part of pathEnv.split(delimiter)) {
     if (!part) continue;
     const candidate = resolve32(part, process.platform === "win32" ? "kxm.cmd" : "kxm");
-    if (existsSync46(candidate)) return resolve32(part);
+    if (existsSync47(candidate)) return resolve32(part);
   }
   return void 0;
 }
@@ -54694,7 +56384,7 @@ function installPathEntry(shellInput, options = {}) {
   }
   const { rcFile } = completionRcTarget(shell, options);
   const line = pathLine(binDir);
-  const rcContent = existsSync46(rcFile ?? "") ? readFileSync41(rcFile, "utf8") : "";
+  const rcContent = existsSync47(rcFile ?? "") ? readFileSync42(rcFile, "utf8") : "";
   const alreadyInstalled = rcContent.includes(binDir) || (options.env?.PATH ?? process.env.PATH ?? "").split(delimiter).includes(binDir);
   if (!options.dryRun && rcFile && !alreadyInstalled) {
     mkdirSync33(dirname24(rcFile), { recursive: true });
@@ -54707,9 +56397,9 @@ ${line}
 }
 
 // plugins/kxm/src/init-guide-setup.ts
-var import_yaml21 = __toESM(require_dist(), 1);
+var import_yaml22 = __toESM(require_dist(), 1);
 init_routes();
-import { existsSync as existsSync47, mkdirSync as mkdirSync34, writeFileSync as writeFileSync29 } from "node:fs";
+import { existsSync as existsSync48, mkdirSync as mkdirSync34, writeFileSync as writeFileSync29 } from "node:fs";
 import { dirname as dirname25, join as join56 } from "node:path";
 var ADMITTED_GUIDE_BINDINGS = Object.freeze({
   "anthropic/claude-fable-5.1": { harness: "claude", provider: "anthropic", model: "fable" },
@@ -55142,7 +56832,7 @@ function renderGuideSetupFiles(projectRoot, plan) {
     if (binding.harness === "pi" && !piMatch) {
       files.push({
         path: join56(projectRoot, ".kxm", "agents", `${role}.yaml`),
-        content: (0, import_yaml21.stringify)(agentDocument(role, stage))
+        content: (0, import_yaml22.stringify)(agentDocument(role, stage))
       });
       continue;
     }
@@ -55167,15 +56857,15 @@ function renderGuideSetupFiles(projectRoot, plan) {
     }
     files.push({
       path: join56(projectRoot, ".kxm", "agents", `${role}.yaml`),
-      content: (0, import_yaml21.stringify)(agentDocument(role, stage))
+      content: (0, import_yaml22.stringify)(agentDocument(role, stage))
     });
     files.push({
       path: join56(projectRoot, ".kxm", "models", `${routeId2}.yaml`),
-      content: (0, import_yaml21.stringify)(modelDocument)
+      content: (0, import_yaml22.stringify)(modelDocument)
     });
     files.push({
       path: join56(projectRoot, ".kxm", "roles", `${role}.yaml`),
-      content: (0, import_yaml21.stringify)({
+      content: (0, import_yaml22.stringify)({
         schema: "kxm.role.v2",
         id: role,
         purpose: writer ? "writer" : "experiment",
@@ -55188,7 +56878,7 @@ function renderGuideSetupFiles(projectRoot, plan) {
   for (const workflow of plan.workflows) {
     files.push({
       path: join56(projectRoot, ".kxm", "workflows", `${workflow.slug}.yaml`),
-      content: (0, import_yaml21.stringify)(workflowDocument(workflow))
+      content: (0, import_yaml22.stringify)(workflowDocument(workflow))
     });
   }
   return files;
@@ -55206,14 +56896,14 @@ function mergeGuideRouteAdmission(projectRoot, plan) {
   policy.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const path4 = join56(projectRoot, ".kxm", "routes.yaml");
   mkdirSync34(dirname25(path4), { recursive: true });
-  writeFileSync29(path4, (0, import_yaml21.stringify)(policy), "utf8");
+  writeFileSync29(path4, (0, import_yaml22.stringify)(policy), "utf8");
   return added;
 }
 function writeGuideSetupFiles(files) {
   const written = [];
   const existed = [];
   for (const file of files) {
-    if (existsSync47(file.path)) {
+    if (existsSync48(file.path)) {
       existed.push(file.path);
       continue;
     }
@@ -55294,7 +56984,7 @@ function applyKxmPackageUpdate(runtime, notice) {
     for (const step of planned) {
       if (step.kind === "verify") {
         if (!verifyReleaseAssetDigest(step.path, step.sha256)) {
-          const actual = existsSync48(step.path) ? createHash19("sha256").update(readFileSync42(step.path)).digest("hex") : "missing";
+          const actual = existsSync49(step.path) ? createHash19("sha256").update(readFileSync43(step.path)).digest("hex") : "missing";
           return {
             ok: false,
             error: "release_digest_mismatch",
@@ -55622,12 +57312,12 @@ async function cmdValidate(runtime, fileFlag) {
   }
   const selectedFile = explicitFile || configuredFile;
   const file = selectedFile ? resolve33(runtime.cwd, selectedFile) : void 0;
-  if (file && !existsSync48(file)) {
+  if (file && !existsSync49(file)) {
     printWorker(runtime, worker, { ok: false, command: "validate", error: "file_not_found", file }, `workflow file not found: ${file}`);
     return 1;
   }
   try {
-    const raw = file ? readFileSync42(file, "utf8") : inline;
+    const raw = file ? readFileSync43(file, "utf8") : inline;
     if (explicitFile && file && !raw.trimStart().startsWith("[")) {
       const value = parseRestrictedYaml2(raw, file);
       const issues = new KxmSchemaRegistry().validate("workflow", value, file);
@@ -55802,6 +57492,37 @@ async function cmdConfigSet(runtime, key, value, options) {
     return 1;
   }
 }
+async function cmdConfigEdit(runtime, options, isTty = Boolean(process.stdin.isTTY && process.stdout.isTTY)) {
+  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 === void 0 ? {} : { 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}
+`);
+    return 1;
+  }
+}
 async function cmdConfigList(runtime) {
   try {
     const config = loadKxmConfig(runtime.cwd);
@@ -55876,9 +57597,9 @@ async function maybeOfferCompletionInstall(runtime) {
   if (!pathNeeded) {
     const scriptPath = completionScriptPath(shell, { env: runtime.env, configDir: runtime.env.KXM_USER_CONFIG_DIR });
     const { rcFile } = completionRcTarget(shell, { env: runtime.env });
-    if (rcFile && existsSync48(rcFile)) {
+    if (rcFile && existsSync49(rcFile)) {
       try {
-        if (readFileSync42(rcFile, "utf8").includes(scriptPath)) return;
+        if (readFileSync43(rcFile, "utf8").includes(scriptPath)) return;
       } catch {
       }
     }
@@ -56253,6 +57974,7 @@ var DRY_RUN_COMMANDS = /* @__PURE__ */ new Set([
   "hub unbind",
   "config get",
   "config set",
+  "config edit",
   "config list",
   "goal create",
   "goal list",
@@ -56825,7 +58547,7 @@ function createProgram(ctx, result, argv) {
   });
   const gate = addGlobalOptions(program2.command("gate").description("Validate definitions and operate evidence gates"));
   gate.helpCommand("help", "Show gate help");
-  addGlobalOptions(gate.command("validate").description("Parse workflow definitions without printing secrets")).option("--file <path>", "Workflow definition file").action(async function validateAction(options) {
+  addGlobalOptions(gate.command("validate").description("Parse workflow definitions without printing secrets")).option("--file <path>", "Workflow definition file").action(async function validateAction2(options) {
     result.code = await cmdValidate(runtimeFrom(ctx, this), options.file);
   });
   addGlobalOptions(gate.command("artifacts-exist").description("Verify a non-empty file under workspace assets")).requiredOption("--path <file>", "Artifact file under workspace assets").action(async function artifactsExistAction(options) {
@@ -56953,6 +58675,9 @@ function createProgram(ctx, result, argv) {
   addGlobalOptions(configCmd.command("set <key> <value>").description("Set a configuration value")).option("--scope <scope>", "Configuration scope: user or project (default: project)", "project").action(async function configSetAction(key, value, options) {
     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(options) {
+    result.code = await cmdConfigEdit(runtimeFrom(ctx, this), options);
+  });
   addGlobalOptions(configCmd.command("list", { isDefault: true }).description("List resolved configuration values")).action(async function configListAction() {
     result.code = await cmdConfigList(runtimeFrom(ctx, this));
   });