@kontextmind/kxm 0.7.173 → 0.7.175

package/.claude-plugin/marketplace.json

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

package/CHANGELOG.md

@@ -181,6 +181,19 @@ All notable user-facing changes are documented here. The project follows [Semant
 
 ### Changed
 
+- **`kxm update --kxm` defaults to npm.** Missing or source-less `update.yaml` now
+  uses the public `@kontextmind/kxm` package instead of the GitHub release tarball.
+  `source: github` still selects the digest-checked tarball. When the working
+  directory is this repository, `--kxm` installs the local files and does not fetch.
+- **`kxm update` is a full update by default.** Bare `kxm update` and `--all` run
+  detected harness `--self` first (default harness leading), then the kxm package,
+  then extensions and models. `--kxm` remains kxm-only. Detected harness updater
+  failures on `--all` degrade the receipt and do not fail the command; an unknown
+  harness id still exits 2.
+- **`kxm land` runs `npm` on Windows.** The verify stage launches `npm.cmd` through `cmd.exe` when `npm` is not an `.exe`.
+- **npm 12 `pack --json`.** The install smoke and pack tests accept the package-keyed object as well as the older one-element array.
+- **Roadmap links on Windows.** `kxm land` keeps the git symlink text when this process cannot create the `docs/roadmap` links.
+
 - **Tool policy is enforced at load and before dispatch.**
   `coordinator` and `read-only` select the read-only one-shot profile.
   `workspace-writer` and `tests-writer` select the edit profile. Dispatch

package/docs/contributing/decisions.md

@@ -2,7 +2,7 @@
 title: "Decisions"
 description: "Decisions of medium significance or higher made by automated KXM work in this repository. One entry per decision: the options evaluated with their weights, and why the selected option won. Recorded the turn the decision is taken."
 audience: "agents and maintainers"
-updated: "2026-09-28"
+updated: "2026-10-02"
 ---
 
 # Decisions
@@ -151,3 +151,24 @@ Evidence: Evidence: test/core/oneshot-producer.test.ts (real reviewer shapes), r
 - Selected: port through the engine lane `vision-assert-port`; the PR is
   closed by its replacement landing, not by hand.
 Evidence: Evidence: merge-base 77beda4 predates the CLI restructure; merge-tree showed cli/vnext.ts deleted on main; vision-gate.ts already on main.
+
+## 2026-10-02 — Porting the stale update-default branch onto main (landing)
+
+- Context: `feat/update-npm-default-and-all` was based on 2026-09-24 main
+  and still uncommitted. `origin/main` had moved about 66 commits and
+  already contained the claude-bridge `apiKey` registration fix and the
+  `gh`/`curl` release downloader. `kxm land`'s rebase stage only resolves
+  union conflicts, which cannot merge the `planKxmPackageUpdate` signature
+  clash (`downloader` vs `localRoot`).
+- Options:
+  - Rebase the 2026-09-24 branch through `kxm land`'s rebase stage — weight
+    0.2. Its union-only resolver cannot handle the `planKxmPackageUpdate`
+    signature clash.
+  - Stash-apply onto a fresh lane, take upstream for claude-bridge, `dist`,
+    and `package.json`, and merge the rest — weight 0.9. Keeps the reviewed
+    update-default work and the upstream fixes that must not be duplicated.
+  - Discard and re-dispatch to the writer — weight 0.3. Re-authors reviewed
+    work that already had a specified merge.
+- Selected: stash-apply onto a fresh lane off `origin/main`, take upstream
+  for claude-bridge, `dist`, and `package.json`, and merge the rest.
+Evidence: Evidence: `git diff HEAD origin/main` on the stale branch showed upstream's claude-bridge fix and curl downloader already landed; the lane port keeps both those and the npm/`--all` behavior.

package/docs/contributing/test-matrix.md

@@ -145,7 +145,7 @@ The context suites in detail:
 | Permission-diff trust: authority lattice, prose neutrality, Git base shadowing, CLI diff and check | `permission.test.ts`, `cli.test.ts`, `contracts.test.ts`, `package-install.test.ts` |
 | KXM schemas, restricted YAML fixtures, cross-resource semantics and sync-safe rejection | `contracts.test.ts`, `restricted-yaml.test.ts` |
 | Harness detection, auth and dispatch for the built-in catalog, including Windows launch rules | `harness.test.ts` |
-| `kxm update`: `update.yaml` validation, GitHub or npm version checks, install-kind detection, `kxm-<v>.tgz` asset selection | `kxm-update.test.ts`, `kxm-update-cli.test.ts`, `kxm-install-kind.test.ts` |
+| `kxm update`: `update.yaml` validation, npm default / GitHub override, local checkout install, install-kind detection, `kxm-<v>.tgz` asset selection | `kxm-update.test.ts`, `kxm-update-cli.test.ts`, `kxm-install-kind.test.ts` |
 
 The round trip seeds its Runtime stores in a project-local `.kxm/runtime/`
 layout that the Runtime never writes. Separate tests seed two projects' event

package/docs/operations/upgrade.md

@@ -6,7 +6,7 @@ Move the `kxm` CLI, the hub, the Runtime, and the Claude Code or Pi integrations
 
 - Protected storage for a full backup; see [Back up and restore KXM](backup-and-restore.md).
 - A window in which the hub, the Runtime supervisor and long-lived workers may stop.
-- The GitHub CLI (`gh`, signed in) if you apply updates with `kxm update --kxm` from the default `github` source. When `gh` is not installed, that command downloads the same `kxm-<version>.tgz` with curl and still checks the release sha256 before installing. Without a working `kxm` either, use the curl commands in [Update the CLI without gh](#update-the-cli-without-gh).
+- The GitHub CLI (`gh`, signed in), only when `update.yaml` sets `source: github`. When `gh` is not installed, that command downloads the same `kxm-<version>.tgz` with curl and still checks the release sha256 before installing. Without a working `kxm` either, use the curl commands in [Update the CLI without gh](#update-the-cli-without-gh).
 
 ## Check for an update
 
@@ -17,7 +17,7 @@ kxm update --check
 Expected output when a newer release exists:
 
 ```text
-kxm 0.7.1 → 0.7.2 available · kxm update --kxm
+kxm 0.7.1 → 0.7.2 available · kxm update
 ```
 
 From a source checkout, the check makes no network call and reports the checkout instead:
@@ -26,7 +26,7 @@ From a source checkout, the check makes no network call and reports the checkout
 kxm 0.7.1 (running from source at /work/kxm)
 ```
 
-The check reads `update.yaml` under the user state root. Its `source` is `github` (release tarballs) by default; `npm` is also accepted. See [Updater settings](../reference/config-reference.md#updater-settings-kxmupdatev1). Add `--json` to see the install kind KXM detected.
+The check reads `update.yaml` under the user state root. Its `source` is `npm` by default; `github` (release tarballs) is also accepted. When the working directory is this repository, `kxm update --kxm` installs the local files instead of fetching. See [Updater settings](../reference/config-reference.md#updater-settings-kxmupdatev1). Add `--json` to see the install kind KXM detected.
 
 ## Stop the services and back up
 
@@ -48,7 +48,7 @@ Use the path that matches how KXM was installed. `kxm update --kxm` applies an u
 
 | Install kind | Upgrade with |
 |---|---|
-| Global npm install | `kxm update --kxm` (release tarball, or npm with `source: npm`), or `npm install --global --omit=peer @kontextmind/kxm@latest` |
+| Global npm install | `kxm update --kxm` (npm registry, or GitHub tarball with `source: github`), or `npm install --global --omit=peer @kontextmind/kxm@latest` |
 | Pi package | `pi update` |
 | Claude Code marketplace plugin | Reinstall the plugin; see the plugin note below |
 | Project dependency | `npm install @kontextmind/kxm@latest` in that project |
@@ -77,7 +77,7 @@ Refuse a tarball whose sha256 does not match the release asset digest.
 
 ### Update harnesses and plugins
 
-Without `--check` or a lone `--kxm`, `kxm update` also runs the native updaters of detected harnesses. Narrow it with a harness id and one scope:
+Bare `kxm update` (same as `--all`) runs detected harness `--self` updaters first, then the kxm package, then extensions and models; `--kxm` alone updates only kxm. Narrow it with a harness id and one scope:
 
 ```bash
 kxm update --dry-run               # plan every detected harness

package/docs/reference/cli-reference.md

@@ -971,7 +971,7 @@ Not run: stores a credential.
 ## `kxm update`
 
 ```text
-kxm update [harness] [--check | --kxm] [--self | --extensions | --models]
+kxm update [harness] [--check | --kxm] [--all | --self | --extensions | --models]
 ```
 
 Checks for or applies a KXM operator package update, and runs the native updaters of detected harnesses.
@@ -979,14 +979,15 @@ Checks for or applies a KXM operator package update, and runs the native updater
 | Option | Argument | Default | Description |
 |---|---|---|---|
 | `--check` | none | off | Check for a kxm package update without applying |
-| `--kxm` | none | off | Apply the kxm operator package update (GitHub release tarball or npm) |
-| `--self` | none | off | Update only the harness CLI |
+| `--all` | none | off | Update harness CLIs first (`--self`), then kxm, extensions, and models (default for a bare `kxm update`) |
+| `--kxm` | none | off | Apply only the kxm operator package update (npm by default, GitHub tarball when configured, or local files in this repo) |
+| `--self` | none | off | Update only harness CLIs |
 | `--extensions` | none | off | Update only extensions/plugins (Pi packages, Claude kxm) |
 | `--models` | none | off | Refresh model catalogs where the harness supports it |
 
 - Arguments: `[harness]`, Harness id (default: every detected harness).
-- `--check` cannot be combined with any other update flag or a harness (exit 2, `scope_conflict`), and at most one of `--self`, `--extensions`, `--models` is allowed (exit 2).
-- From a source checkout, `--check` reports the running version without network access, and `--kxm` is refused (exit 2, `install_kind_source`) with an instruction to `git pull`. Only npm-global installs can apply `--kxm`; other install kinds exit 2 with `install_kind_<kind>`. A GitHub release must publish a sha256 digest for `kxm-<version>.tgz` or the install fails closed (`release_digest_missing`, `release_digest_mismatch`). When `gh` is missing, the github source downloads that same asset with `curl --fail --silent --show-error --location` and still verifies the digest before `npm install -g`.
+- `--check` cannot be combined with any other update flag or a harness (exit 2, `scope_conflict`), and at most one of `--all`, `--self`, `--extensions`, `--models` is allowed (exit 2).
+- Default `source` is npm. Set `update.yaml` `source: github` for the release tarball. When the working directory is this repository (`@kontextmind/kxm` plus `.git`), `--check` reports `source: local` without a network fetch and `--kxm` runs `npm install --global --omit=peer <cwd>`. From a source-built binary used outside this repo, `--check` reports the running version without network access, and `--kxm` is refused (exit 2, `install_kind_source`) with an instruction to `git pull`. Only npm-global installs can apply a registry or GitHub `--kxm`; other install kinds exit 2 with `install_kind_<kind>`. A GitHub release must publish a sha256 digest for `kxm-<version>.tgz` or the install fails closed (`release_digest_missing`, `release_digest_mismatch`). When `gh` is missing, the github source downloads that same asset with `curl --fail --silent --show-error --location` and still verifies the digest before `npm install -g`.
 
 On a host with neither `gh` nor a working `kxm`, download and check it yourself:
 
@@ -1001,7 +1002,7 @@ npm install --global --omit=peer "./kxm-${version}.tgz"
 ```
 
 - Settings come only from `update.yaml` under the user state root (`auto: true` enables auto-apply); a project `.kxm/update.yaml` is ignored with a warning.
-- Without `--check` or a lone `--kxm`, KXM probes harnesses (as `harness list` does) and runs each updater for the selected scope. An unknown harness id exits 2 (`unknown_harness` step); a failed step exits 1.
+- Without `--check` or a lone `--kxm`, KXM probes harnesses (as `harness list` does) and runs each updater for the selected scope. An unknown harness id exits 2 (`unknown_harness` step); a failed step exits 1, except under `--all` (the default), where a failed harness updater sets `degraded: true` and exits 0.
 - Honors `--dry-run`: steps are planned, not run, and the cached update notice is not refreshed.
 - JSON keys: `--check` gives `current`, `available`, `auto`, `source`, `latest`, `message`, `installKind`, `root`; otherwise `dryRun`, `scope`, `notice`, `kxm` (when applying), `steps` (`harness`, `scope`, `command`, `args`, `outcome`, `detail`), `installKind`, `root`.
 
@@ -1010,7 +1011,7 @@ kxm update --check --dry-run --json
 ```
 
 ```text
-{"schema":"kxm.cli-result.v1","ok":true,"command":"update check","current":"0.7.1","available":false,"auto":false,"source":"github","installKind":"source","root":"/work/kxm","message":"kxm 0.7.1 (running from source at /work/kxm)"}
+{"schema":"kxm.cli-result.v1","ok":true,"command":"update check","current":"0.7.1","available":false,"auto":false,"source":"npm","installKind":"source","root":"/work/kxm","message":"kxm 0.7.1 (running from source at /work/kxm)"}
 ```
 
 ```bash

package/docs/reference/config-reference.md

@@ -1656,14 +1656,14 @@ never mints a token or writes a file, and always exits 0. See the
 |---|---|---|
 | `schema` | `kxm.update.v1` | Required |
 | `auto` | Boolean | Required |
-| `source` | `github` or `npm` | Optional, `github` |
+| `source` | `github` or `npm` | Optional, `npm` |
 
 Unknown fields are refused (`update.yaml unknown field <name>`).
 
 ```yaml
 schema: kxm.update.v1
 auto: false        # required boolean
-source: github     # github (default) | npm
+source: npm        # npm (default) | github
 ```
 
 ## Workspace layout: tracked, ignored, and state

package/docs/start/install.md

@@ -8,7 +8,7 @@ KXM has three parts you can install: the `kxm` command-line tool, the Claude Cod
 - Git.
 - Claude Code, if you want the plugin.
 - Pi, if you want Pi agents. Install it with `npm install --global @earendil-works/pi-coding-agent` and sign in to a model provider as the [Pi documentation](https://pi.dev/docs/latest) describes.
-- The GitHub CLI (`gh`), only if you plan to update with `kxm update --kxm` from the GitHub source. When `gh` is missing, that command falls back to curl and still checks the release checksum. The manual curl commands are in [Upgrade KXM](../operations/upgrade.md#update-the-cli-without-gh).
+- The GitHub CLI (`gh`), only if `update.yaml` sets `source: github` so `kxm update --kxm` downloads the release tarball. When `gh` is missing, that command falls back to curl and still checks the release checksum. The manual curl commands are in [Upgrade KXM](../operations/upgrade.md#update-the-cli-without-gh).
 
 ## Choose what to install
 
@@ -107,13 +107,13 @@ npm ci
 node scripts/kxm.mjs --version
 ```
 
-Use `node scripts/kxm.mjs` wherever the docs show `kxm`. It runs the CLI bundle committed in `plugins/kxm/dist/`. Update a checkout with `git pull` and `npm ci`; `kxm update --kxm` refuses to run there. [Develop KXM](../contributing/development.md) covers building and testing.
+Use `node scripts/kxm.mjs` wherever the docs show `kxm`. It runs the CLI bundle committed in `plugins/kxm/dist/`. Update a checkout with `git pull` and `npm ci`. From this repository, `kxm update --kxm` installs those local files globally. [Develop KXM](../contributing/development.md) covers building and testing.
 
 ## Update
 
 | Part | Command |
 |---|---|
-| `kxm` CLI | `npm install --global --omit=peer @kontextmind/kxm@latest` (check first with `kxm update --check`) |
+| `kxm` CLI | `kxm update --kxm` or `npm install --global --omit=peer @kontextmind/kxm@latest` (check first with `kxm update --check`) |
 | Claude Code plugin | `claude plugin marketplace update kxm`, then uninstall and reinstall the plugin; `claude plugin update` never refreshes it |
 | Pi package | `pi update --extensions` |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontextmind/kxm",
-  "version": "0.7.173",
+  "version": "0.7.175",
   "description": "KXM local-first multi-agent orchestration and operator dashboard",
   "type": "module",
   "author": "KontextMind",
@@ -37,7 +37,7 @@
     "test:core": "npm run build && node scripts/run-bounded.mjs 1200000 node --disable-warning=ExperimentalWarning --experimental-strip-types --test --test-force-exit --test-concurrency=4 test/core/*.test.ts",
     "test:simulations": "npm run build && node scripts/run-bounded.mjs 1200000 node --disable-warning=ExperimentalWarning --experimental-strip-types --test --test-force-exit --test-concurrency=4 test/simulations/*.test.ts",
     "test:complete": "npm run build && node scripts/run-bounded.mjs 2400000 node --disable-warning=ExperimentalWarning --experimental-strip-types --test --test-force-exit --test-concurrency=4 test/core/*.test.ts test/simulations/*.test.ts",
-    "test": "npm run build && node scripts/run-bounded.mjs 1200000 node --disable-warning=ExperimentalWarning --experimental-strip-types --test --test-force-exit --test-concurrency=4 test/core/*.test.ts packages/core/*/tests/unit/*.test.ts",
+    "test": "npm run build && node scripts/run-bounded.mjs 1800000 node --disable-warning=ExperimentalWarning --experimental-strip-types --test --test-force-exit --test-concurrency=4 test/core/*.test.ts packages/core/*/tests/unit/*.test.ts",
     "test:ci-shard": "node scripts/ci-unit-shard.mjs",
     "e2e": "node scripts/obscura.mjs --ensure && playwright test",
     "test:coverage:core": "npm run build && node scripts/run-bounded.mjs 2400000 node --disable-warning=ExperimentalWarning --experimental-strip-types --test --test-force-exit --test-concurrency=4 --experimental-test-coverage --test-coverage-lines=91 --test-coverage-branches=80 --test-coverage-functions=92 --test-coverage-include=plugins/kxm/src/**/*.ts --test-coverage-exclude=plugins/kxm/src/server.ts --test-coverage-exclude=plugins/kxm/src/mcp-server.ts --test-coverage-exclude=plugins/kxm/src/runtime-supervisor.ts --test-coverage-include=packages/core/*/src/**/*.ts test/core/*.test.ts packages/core/*/tests/unit/*.test.ts",

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

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

package/plugins/kxm/dist/cli.js

@@ -19780,8 +19780,17 @@ function argsFor(entry, scope) {
   if (scope === "extensions") return entry.update.extensions;
   return entry.update.models;
 }
+function detectedHarnesses(inventory, requestedHarness) {
+  if (requestedHarness) return inventory.harnesses.filter((entry) => entry.id === requestedHarness);
+  const detected = inventory.harnesses.filter((entry) => entry.detected);
+  const preferred = inventory.defaultHarness;
+  return [
+    ...detected.filter((entry) => entry.id === preferred),
+    ...detected.filter((entry) => entry.id !== preferred)
+  ];
+}
 function planHarnessUpdate(inventory, requested) {
-  const selected = requested.harness ? inventory.harnesses.filter((entry) => entry.id === requested.harness) : inventory.harnesses.filter((entry) => entry.detected);
+  const selected = detectedHarnesses(inventory, requested.harness);
   if (requested.harness && selected.length === 0) {
     return [{
       harness: requested.harness,
@@ -19792,36 +19801,44 @@ function planHarnessUpdate(inventory, requested) {
       detail: isKnownHarnessId(requested.harness) ? "not_detected" : "unknown_harness"
     }];
   }
+  const waves = requested.scope === "all" ? ["self", "extensions", "models"] : [requested.scope];
   const steps = [];
-  for (const status of selected) {
-    const entry = BUILTIN_HARNESSES.find((candidate) => candidate.id === status.id);
-    if (!entry) continue;
-    const scopes = scopesFor(requested.scope, entry);
-    if (scopes.length === 0) {
-      steps.push({
-        harness: status.id,
-        scope: requested.scope === "all" ? "self" : requested.scope,
-        command: status.command ?? entry.commands[0],
-        args: [],
-        outcome: "skipped",
-        detail: "no_updater"
-      });
-      continue;
-    }
-    if (!status.detected || !status.command) {
+  for (const scope of waves) {
+    for (const status of selected) {
+      const entry = BUILTIN_HARNESSES.find((candidate) => candidate.id === status.id);
+      if (!entry) continue;
+      const supported = scopesFor(requested.scope === "all" ? "all" : scope, entry);
+      if (!supported.includes(scope)) {
+        if (requested.scope !== "all") {
+          steps.push({
+            harness: status.id,
+            scope,
+            command: status.command ?? entry.commands[0],
+            args: [],
+            outcome: "skipped",
+            detail: "no_updater"
+          });
+        }
+        continue;
+      }
+      if (!status.detected || !status.command) {
+        steps.push({
+          harness: status.id,
+          scope,
+          command: entry.commands[0],
+          args: argsFor(entry, scope) ?? [],
+          outcome: "skipped",
+          detail: "not_detected"
+        });
+        continue;
+      }
       steps.push({
         harness: status.id,
-        scope: scopes[0],
-        command: entry.commands[0],
-        args: argsFor(entry, scopes[0]) ?? [],
-        outcome: "skipped",
-        detail: "not_detected"
+        scope,
+        command: status.command,
+        args: argsFor(entry, scope) ?? [],
+        outcome: "would"
       });
-      continue;
-    }
-    for (const scope of scopes) {
-      const args = argsFor(entry, scope) ?? [];
-      steps.push({ harness: status.id, scope, command: status.command, args, outcome: "would" });
     }
   }
   return steps;
@@ -35526,7 +35543,7 @@ function compareSemver(left, right) {
 }
 function formatKxmUpdateNotice(notice) {
   if (!notice.available) return notice.message;
-  const apply = notice.auto ? "kxm update --kxm (auto)" : "kxm update --kxm";
+  const apply = notice.auto ? "kxm update (auto)" : "kxm update";
   return `kxm ${notice.current} \u2192 ${notice.latest} available \xB7 ${apply}`;
 }
 function withAsset(notice, asset) {
@@ -35644,7 +35661,11 @@ function verifyReleaseAssetDigest(path4, sha256) {
     return false;
   }
 }
-function planKxmPackageUpdate(source, latest, releaseDir, asset, downloader = "gh") {
+function planKxmPackageUpdate(source, latest, releaseDir, asset, downloader = "gh", localRoot) {
+  if (source === "local") {
+    if (!localRoot) return [];
+    return [{ kind: "install", command: "npm", args: ["install", "--global", "--omit=peer", localRoot] }];
+  }
   if (source === "npm") {
     return [{ kind: "install", command: "npm", args: ["install", "--global", "--omit=peer", `@kontextmind/kxm@${latest}`] }];
   }
@@ -51787,6 +51808,11 @@ init_hub_binding();
 init_bindings();
 import { existsSync as existsSync38, readFileSync as readFileSync34 } from "node:fs";
 import { dirname as dirname21, join as join48 } from "node:path";
+function kxmSourceCheckoutRoot(dir) {
+  if (!existsSync38(join48(dir, ".git"))) return void 0;
+  if (!packageIsKxm(dir)) return void 0;
+  return dir;
+}
 function packageIsKxm(root) {
   try {
     const pkg = JSON.parse(readFileSync34(join48(root, "package.json"), "utf8"));
@@ -51872,7 +51898,7 @@ import { join as join49 } from "node:path";
 init_bindings();
 function loadKxmUpdateConfig(env = process.env) {
   const path4 = join49(kxmUserStateRoot({ env }), "update.yaml");
-  if (!existsSync39(path4)) return { schema: KXM_UPDATE_SCHEMA, auto: false, source: "github" };
+  if (!existsSync39(path4)) return { schema: KXM_UPDATE_SCHEMA, auto: false, source: "npm" };
   let parsed;
   try {
     parsed = (0, import_yaml19.parse)(readFileSync35(path4, "utf8"));
@@ -51893,7 +51919,7 @@ function loadKxmUpdateConfig(env = process.env) {
   if (typeof row.auto !== "boolean") {
     throw new KxmUpdateConfigError("update.yaml auto must be a boolean");
   }
-  const source = row.source === void 0 ? "github" : row.source;
+  const source = row.source === void 0 ? "npm" : row.source;
   if (source !== "npm" && source !== "github") {
     throw new KxmUpdateConfigError("update.yaml source must be npm or github");
   }
@@ -55090,7 +55116,7 @@ function applyKxmPackageUpdate(runtime, notice) {
   const releaseDir = mkdtempSync3(join57(tmpdir3(), "kxm-pkg-update-"));
   try {
     const downloader = notice.source === "github" && !ghReleaseDownloadAvailable(runtime.env) ? "curl" : "gh";
-    const planned = planKxmPackageUpdate(notice.source, notice.latest, releaseDir, notice.asset, downloader);
+    const planned = planKxmPackageUpdate(notice.source, notice.latest, releaseDir, notice.asset, downloader, notice.localRoot);
     if (runtime.dryRun) {
       return { ok: true, detail: planned.map(formatPackageUpdateStep).join(" && ") };
     }
@@ -55216,22 +55242,34 @@ async function cmdSshClose(runtime, host) {
   return 0;
 }
 async function cmdUpdate(runtime, harness, options) {
-  if (options.check && (options.kxm || options.self || options.extensions || options.models || harness)) {
+  if (options.check && (options.kxm || options.self || options.extensions || options.models || options.all || harness)) {
     print(runtime.io, runtime.json, { ok: false, command: "update", error: "scope_conflict" }, "--check cannot be combined with other update flags");
     return 2;
   }
-  const selected = [options.self, options.extensions, options.models].filter(Boolean).length;
+  const selected = [options.self, options.extensions, options.models, options.all].filter(Boolean).length;
   if (selected > 1) {
-    print(runtime.io, runtime.json, { ok: false, command: "update", error: "scope_conflict" }, "specify at most one of --self, --extensions, or --models");
+    print(runtime.io, runtime.json, { ok: false, command: "update", error: "scope_conflict" }, "specify at most one of --all, --self, --extensions, or --models");
     return 2;
   }
   warnIgnoredProjectUpdateYaml(runtime);
   const probe = installProbeFrom(runtime);
   const classified = classifyInstallRoot(probe);
   const current = installedKxmVersion(classified.root) ?? installedKxmVersion(findKxmRepoRoot(import.meta.url));
+  const localRoot = kxmSourceCheckoutRoot(runtime.dirs.workdir) ?? kxmSourceCheckoutRoot(runtime.cwd);
   let notice;
   let kindReport = classified;
-  if (classified.kind === "source") {
+  if (localRoot) {
+    const localVersion = installedKxmVersion(localRoot) ?? current ?? "unknown";
+    notice = {
+      current: current ?? localVersion,
+      latest: localVersion,
+      available: true,
+      auto: false,
+      source: "local",
+      message: `kxm ${current ?? localVersion} (local ${localRoot})`,
+      localRoot
+    };
+  } else if (classified.kind === "source") {
     if (options.check) {
       const message = `kxm ${current ?? "unknown"} (running from source at ${classified.root})`;
       print(runtime.io, runtime.json, {
@@ -55240,7 +55278,7 @@ async function cmdUpdate(runtime, harness, options) {
         current: current ?? "unknown",
         available: false,
         auto: false,
-        source: "github",
+        source: "npm",
         installKind: "source",
         root: classified.root,
         message
@@ -55262,7 +55300,7 @@ async function cmdUpdate(runtime, harness, options) {
       current: current ?? "unknown",
       available: false,
       auto: false,
-      source: "github",
+      source: "npm",
       message: `kxm ${current ?? "unknown"} (running from source)`
     };
   } else {
@@ -55285,13 +55323,30 @@ async function cmdUpdate(runtime, harness, options) {
     }, notice.message);
     return 0;
   }
-  const applyKxm = Boolean(options.kxm || notice.auto);
+  const fullUpdate = Boolean(options.all) || selected === 0 && !options.kxm && !harness;
+  const applyKxm = Boolean(options.kxm || fullUpdate || notice.auto);
   let kxmApply;
-  if (applyKxm) {
+  const applyKxmPackage = (requireSuccess) => {
+    if (!applyKxm) return void 0;
+    if (notice.source === "local" && notice.localRoot) {
+      kxmApply = applyKxmPackageUpdate(runtime, notice);
+      if (!kxmApply.ok && requireSuccess) {
+        print(runtime.io, runtime.json, {
+          ok: false,
+          command: "update",
+          error: kxmApply.error,
+          kxm: kxmApply,
+          notice,
+          ...installKindPayload(classified)
+        }, kxmApply.detail);
+        return 1;
+      }
+      return void 0;
+    }
     const resolved = resolveInstallKind(probe, npmGlobalRootFn(runtime));
     kindReport = resolved;
     if (resolved.kind !== "npm-global") {
-      if (options.kxm) {
+      if (requireSuccess) {
         print(runtime.io, runtime.json, {
           ok: false,
           command: "update",
@@ -55305,9 +55360,11 @@ async function cmdUpdate(runtime, harness, options) {
       }
       if (notice.available) runtime.io.stderr(`kxm: ${resolved.instruction}
 `);
-    } else if (notice.available) {
+      return void 0;
+    }
+    if (notice.available) {
       kxmApply = applyKxmPackageUpdate(runtime, notice);
-      if (!kxmApply.ok && options.kxm) {
+      if (!kxmApply.ok && requireSuccess) {
         print(runtime.io, runtime.json, {
           ok: false,
           command: "update",
@@ -55319,9 +55376,12 @@ async function cmdUpdate(runtime, harness, options) {
         return 1;
       }
     }
-  }
-  const skipHarness = Boolean(options.kxm && selected === 0 && !harness && !notice.auto);
+    return void 0;
+  };
+  const skipHarness = Boolean(options.kxm && !fullUpdate && selected === 0 && !harness && !notice.auto);
   if (skipHarness) {
+    const aborted = applyKxmPackage(true);
+    if (aborted !== void 0) return aborted;
     print(
       runtime.io,
       runtime.json,
@@ -55332,23 +55392,39 @@ async function cmdUpdate(runtime, harness, options) {
   }
   const scope = options.self ? "self" : options.extensions ? "extensions" : options.models ? "models" : "all";
   const inventory = await probeHarnessesAsync({ env: runtime.env });
-  const planned = planHarnessUpdate(inventory, { ...harness ? { harness } : {}, scope });
-  const steps = runHarnessUpdate(planned, { env: runtime.env, dryRun: runtime.dryRun });
-  const failed2 = steps.some((step) => step.outcome === "failed") || kxmApply?.ok === false;
+  const planned = planHarnessUpdate(inventory, { ...harness ? { harness } : {}, scope: fullUpdate ? "all" : scope });
+  const runOpts = { env: runtime.env, dryRun: runtime.dryRun };
+  let steps;
+  if (fullUpdate) {
+    const selfSteps = runHarnessUpdate(planned.filter((step) => step.scope === "self"), runOpts);
+    applyKxmPackage(false);
+    const restSteps = runHarnessUpdate(planned.filter((step) => step.scope !== "self"), runOpts);
+    steps = [...selfSteps, ...restSteps];
+  } else {
+    const aborted = applyKxmPackage(Boolean(options.kxm));
+    if (aborted !== void 0) return aborted;
+    steps = runHarnessUpdate(planned, runOpts);
+  }
+  const kxmFailed = kxmApply?.ok === false;
   const skippedUnknown = steps.some((step) => step.detail === "unknown_harness");
+  const harnessFailed = steps.some((step) => step.outcome === "failed");
   const text = [notice.available ? notice.message : void 0, kxmApply?.detail, formatHarnessUpdate(steps)].filter(Boolean).join("\n");
   print(runtime.io, runtime.json, {
-    ok: !failed2 && !skippedUnknown,
+    ok: !kxmFailed && !skippedUnknown,
     command: "update",
     dryRun: runtime.dryRun,
-    scope,
+    scope: fullUpdate ? "all" : scope,
+    defaultHarness: inventory.defaultHarness,
     notice,
     ...kxmApply ? { kxm: kxmApply } : {},
     steps,
+    ...harnessFailed ? { degraded: true } : {},
     ...installKindPayload(kindReport)
   }, text);
   if (skippedUnknown) return 2;
-  return failed2 ? 1 : 0;
+  if (kxmFailed) return 1;
+  if (harnessFailed && !fullUpdate) return 1;
+  return 0;
 }
 async function cmdValidate(runtime, fileFlag) {
   const worker = gateOf(runtime, "validate");
@@ -56420,7 +56496,7 @@ function createProgram(ctx, result, argv) {
   addGlobalOptions(authCmd.command("token").description("Inspect, issue, or clear local disk session tokens")).option("--status", "Check status of the active session token").option("--clear", "Clear persisted disk session token").option("--issue", "Force issuing a fresh session token").action(async function authTokenAction(options) {
     result.code = await cmdAuthToken(runtimeFrom(ctx, this), options);
   });
-  addGlobalOptions(program2.command("update").description("Update kxm, harness CLIs, extensions, plugins, and model catalogs").argument("[harness]", "Harness id (default: every detected harness)").option("--check", "Check for a kxm package update without applying").option("--kxm", "Apply the kxm operator package update (GitHub release tarball or npm)").option("--self", "Update only the harness CLI").option("--extensions", "Update only extensions/plugins (Pi packages, Claude kxm)").option("--models", "Refresh model catalogs where the harness supports it")).action(async function updateAction(harness, options) {
+  addGlobalOptions(program2.command("update").description("Update kxm, harness CLIs, extensions, plugins, and model catalogs").argument("[harness]", "Harness id (default: every detected harness)").option("--check", "Check for a kxm package update without applying").option("--all", "Update harness CLIs first (--self), then kxm, extensions, and models (default)").option("--kxm", "Apply only the kxm operator package update").option("--self", "Update only harness CLIs").option("--extensions", "Update only extensions/plugins (Pi packages, Claude kxm)").option("--models", "Refresh model catalogs where the harness supports it")).action(async function updateAction(harness, options) {
     result.code = await cmdUpdate(runtimeFrom(ctx, this), harness, options);
   });
   const runtimeCmd = addGlobalOptions(program2.command("runtime").description("Manage the KXM Runtime supervisor"));

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

@@ -25438,7 +25438,7 @@ function sessionTokenFixHint(policy) {
 }
 
 // plugins/kxm/src/mcp-server.ts
-var VERSION = "0.7.173";
+var VERSION = "0.7.175";
 var CONFIGURE_PLUGIN = "/plugin configure kxm@kxm";
 var inbox = /* @__PURE__ */ new Map();
 var notifiedInbox = /* @__PURE__ */ new Set();

package/plugins/kxm/dist/runtime.js

@@ -17298,8 +17298,17 @@ function argsFor(entry, scope) {
   if (scope === "extensions") return entry.update.extensions;
   return entry.update.models;
 }
+function detectedHarnesses(inventory, requestedHarness) {
+  if (requestedHarness) return inventory.harnesses.filter((entry) => entry.id === requestedHarness);
+  const detected = inventory.harnesses.filter((entry) => entry.detected);
+  const preferred = inventory.defaultHarness;
+  return [
+    ...detected.filter((entry) => entry.id === preferred),
+    ...detected.filter((entry) => entry.id !== preferred)
+  ];
+}
 function planHarnessUpdate(inventory, requested) {
-  const selected = requested.harness ? inventory.harnesses.filter((entry) => entry.id === requested.harness) : inventory.harnesses.filter((entry) => entry.detected);
+  const selected = detectedHarnesses(inventory, requested.harness);
   if (requested.harness && selected.length === 0) {
     return [{
       harness: requested.harness,
@@ -17310,36 +17319,44 @@ function planHarnessUpdate(inventory, requested) {
       detail: isKnownHarnessId(requested.harness) ? "not_detected" : "unknown_harness"
     }];
   }
+  const waves = requested.scope === "all" ? ["self", "extensions", "models"] : [requested.scope];
   const steps = [];
-  for (const status of selected) {
-    const entry = BUILTIN_HARNESSES.find((candidate) => candidate.id === status.id);
-    if (!entry) continue;
-    const scopes = scopesFor(requested.scope, entry);
-    if (scopes.length === 0) {
-      steps.push({
-        harness: status.id,
-        scope: requested.scope === "all" ? "self" : requested.scope,
-        command: status.command ?? entry.commands[0],
-        args: [],
-        outcome: "skipped",
-        detail: "no_updater"
-      });
-      continue;
-    }
-    if (!status.detected || !status.command) {
+  for (const scope of waves) {
+    for (const status of selected) {
+      const entry = BUILTIN_HARNESSES.find((candidate) => candidate.id === status.id);
+      if (!entry) continue;
+      const supported = scopesFor(requested.scope === "all" ? "all" : scope, entry);
+      if (!supported.includes(scope)) {
+        if (requested.scope !== "all") {
+          steps.push({
+            harness: status.id,
+            scope,
+            command: status.command ?? entry.commands[0],
+            args: [],
+            outcome: "skipped",
+            detail: "no_updater"
+          });
+        }
+        continue;
+      }
+      if (!status.detected || !status.command) {
+        steps.push({
+          harness: status.id,
+          scope,
+          command: entry.commands[0],
+          args: argsFor(entry, scope) ?? [],
+          outcome: "skipped",
+          detail: "not_detected"
+        });
+        continue;
+      }
       steps.push({
         harness: status.id,
-        scope: scopes[0],
-        command: entry.commands[0],
-        args: argsFor(entry, scopes[0]) ?? [],
-        outcome: "skipped",
-        detail: "not_detected"
+        scope,
+        command: status.command,
+        args: argsFor(entry, scope) ?? [],
+        outcome: "would"
       });
-      continue;
-    }
-    for (const scope of scopes) {
-      const args = argsFor(entry, scope) ?? [];
-      steps.push({ harness: status.id, scope, command: status.command, args, outcome: "would" });
     }
   }
   return steps;

package/plugins/kxm/package.json

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

package/plugins/kxm/skills/kxm-harness-auth/SKILL.md

@@ -34,15 +34,20 @@ still blocks the tools.
 | Command | Purpose |
 |---|---|
 | `kxm update --check` | Check for a kxm package update without applying it |
-| `kxm update --kxm` | Apply the kxm package update |
+| `kxm update` / `--all` | Harness `--self` first, then kxm, extensions, and models |
+| `kxm update --kxm` | Apply only the kxm package update |
 | `kxm update [harness] --self` | Update only the harness CLI |
 | `kxm update [harness] --extensions` | Update only extensions and plugins (Pi packages, the Claude kxm plugin) |
 | `kxm update [harness] --models` | Refresh model catalogs where the harness supports it |
 
-- `kxm update --kxm` downloads the GitHub release tarball by default. It uses
-  `gh` when that CLI answers `gh --version`, and otherwise curl with the same
+- Bare `kxm update` (and `--all`) updates detected harness CLIs first, then kxm,
+  then extensions and models. `--kxm` is kxm-only. kxm installs from npm by default;
+  it needs an authenticated `gh` only when `update.yaml` sets `source: github`.
+  It uses `gh` when that CLI answers `gh --version`, and otherwise curl with the same
   sha256 check. A host with neither can follow the curl commands in
   docs/operations/upgrade.md.
+  Inside the kxm repository it installs the local files. Detected harness updater
+  failures on `--all` are degraded, not fatal.
 - `kxm update claude --extensions` updates only a user-scope plugin install;
   its dry run prints `claude extensions: would claude plugin update kxm -y`.
   A project-scope install is the operator's `claude plugin update kxm@kxm --scope project`.

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

@@ -68,6 +68,7 @@ import {
 } from "../init-guide-setup.ts";
 import {
   classifyInstallRoot,
+  kxmSourceCheckoutRoot,
   resolveInstallKind,
   type InstallKindReport,
   type InstallProbe,
@@ -161,7 +162,7 @@ export function applyKxmPackageUpdate(runtime: Runtime, notice: KxmUpdateNotice)
   const releaseDir = mkdtempSync(join(tmpdir(), "kxm-pkg-update-"));
   try {
     const downloader = notice.source === "github" && !ghReleaseDownloadAvailable(runtime.env) ? "curl" : "gh";
-    const planned = planKxmPackageUpdate(notice.source, notice.latest, releaseDir, notice.asset, downloader);
+    const planned = planKxmPackageUpdate(notice.source, notice.latest, releaseDir, notice.asset, downloader, notice.localRoot);
     if (runtime.dryRun) {
       return { ok: true, detail: planned.map(formatPackageUpdateStep).join(" && ") };
     }
@@ -309,14 +310,15 @@ export async function cmdUpdate(runtime: Runtime, harness: string | undefined, o
   models?: boolean | undefined;
   check?: boolean | undefined;
   kxm?: boolean | undefined;
+  all?: boolean | undefined;
 }): Promise<number> {
-  if (options.check && (options.kxm || options.self || options.extensions || options.models || harness)) {
+  if (options.check && (options.kxm || options.self || options.extensions || options.models || options.all || harness)) {
     print(runtime.io, runtime.json, { ok: false, command: "update", error: "scope_conflict" }, "--check cannot be combined with other update flags");
     return 2;
   }
-  const selected = [options.self, options.extensions, options.models].filter(Boolean).length;
+  const selected = [options.self, options.extensions, options.models, options.all].filter(Boolean).length;
   if (selected > 1) {
-    print(runtime.io, runtime.json, { ok: false, command: "update", error: "scope_conflict" }, "specify at most one of --self, --extensions, or --models");
+    print(runtime.io, runtime.json, { ok: false, command: "update", error: "scope_conflict" }, "specify at most one of --all, --self, --extensions, or --models");
     return 2;
   }
   warnIgnoredProjectUpdateYaml(runtime);
@@ -328,10 +330,24 @@ export async function cmdUpdate(runtime: Runtime, harness: string | undefined, o
   // `cd ~ && kxm update --kxm` into an uncaught ENOENT on `$HOME/package.json`,
   // and would happily compare a stranger project's version wherever one did
   // exist. Unreadable is now a stated refusal.
+  // Exception: a cwd that *is* this repository (`@kontextmind/kxm` plus `.git`)
+  // is a local-files apply, not a stranger version compare.
   const current = installedKxmVersion(classified.root) ?? installedKxmVersion(findKxmRepoRoot(import.meta.url));
+  const localRoot = kxmSourceCheckoutRoot(runtime.dirs.workdir) ?? kxmSourceCheckoutRoot(runtime.cwd);
   let notice: KxmUpdateNotice;
   let kindReport = classified;
-  if (classified.kind === "source") {
+  if (localRoot) {
+    const localVersion = installedKxmVersion(localRoot) ?? current ?? "unknown";
+    notice = {
+      current: current ?? localVersion,
+      latest: localVersion,
+      available: true,
+      auto: false,
+      source: "local",
+      message: `kxm ${current ?? localVersion} (local ${localRoot})`,
+      localRoot,
+    };
+  } else if (classified.kind === "source") {
     if (options.check) {
       const message = `kxm ${current ?? "unknown"} (running from source at ${classified.root})`;
       print(runtime.io, runtime.json, {
@@ -340,7 +356,7 @@ export async function cmdUpdate(runtime: Runtime, harness: string | undefined, o
         current: current ?? "unknown",
         available: false,
         auto: false,
-        source: "github",
+        source: "npm",
         installKind: "source",
         root: classified.root,
         message,
@@ -362,7 +378,7 @@ export async function cmdUpdate(runtime: Runtime, harness: string | undefined, o
       current: current ?? "unknown",
       available: false,
       auto: false,
-      source: "github",
+      source: "npm",
       message: `kxm ${current ?? "unknown"} (running from source)`,
     };
   } else {
@@ -385,13 +401,30 @@ export async function cmdUpdate(runtime: Runtime, harness: string | undefined, o
     }, notice.message);
     return 0;
   }
-  const applyKxm = Boolean(options.kxm || notice.auto);
+  const fullUpdate = Boolean(options.all) || (selected === 0 && !options.kxm && !harness);
+  const applyKxm = Boolean(options.kxm || fullUpdate || notice.auto);
   let kxmApply: { ok: boolean; detail: string; error?: string } | undefined;
-  if (applyKxm) {
+  const applyKxmPackage = (requireSuccess: boolean): number | undefined => {
+    if (!applyKxm) return undefined;
+    if (notice.source === "local" && notice.localRoot) {
+      kxmApply = applyKxmPackageUpdate(runtime, notice);
+      if (!kxmApply.ok && requireSuccess) {
+        print(runtime.io, runtime.json, {
+          ok: false,
+          command: "update",
+          error: kxmApply.error,
+          kxm: kxmApply,
+          notice,
+          ...installKindPayload(classified),
+        }, kxmApply.detail);
+        return 1;
+      }
+      return undefined;
+    }
     const resolved = resolveInstallKind(probe, npmGlobalRootFn(runtime));
     kindReport = resolved;
     if (resolved.kind !== "npm-global") {
-      if (options.kxm) {
+      if (requireSuccess) {
         print(runtime.io, runtime.json, {
           ok: false,
           command: "update",
@@ -404,9 +437,11 @@ export async function cmdUpdate(runtime: Runtime, harness: string | undefined, o
         return 2;
       }
       if (notice.available) runtime.io.stderr(`kxm: ${resolved.instruction}\n`);
-    } else if (notice.available) {
+      return undefined;
+    }
+    if (notice.available) {
       kxmApply = applyKxmPackageUpdate(runtime, notice);
-      if (!kxmApply.ok && options.kxm) {
+      if (!kxmApply.ok && requireSuccess) {
         print(runtime.io, runtime.json, {
           ok: false,
           command: "update",
@@ -418,9 +453,12 @@ export async function cmdUpdate(runtime: Runtime, harness: string | undefined, o
         return 1;
       }
     }
-  }
-  const skipHarness = Boolean(options.kxm && selected === 0 && !harness && !notice.auto);
+    return undefined;
+  };
+  const skipHarness = Boolean(options.kxm && !fullUpdate && selected === 0 && !harness && !notice.auto);
   if (skipHarness) {
+    const aborted = applyKxmPackage(true);
+    if (aborted !== undefined) return aborted;
     print(
       runtime.io,
       runtime.json,
@@ -431,23 +469,39 @@ export async function cmdUpdate(runtime: Runtime, harness: string | undefined, o
   }
   const scope: HarnessUpdateScope = options.self ? "self" : options.extensions ? "extensions" : options.models ? "models" : "all";
   const inventory = await probeHarnessesAsync({ env: runtime.env });
-  const planned = planHarnessUpdate(inventory, { ...(harness ? { harness } : {}), scope });
-  const steps = runHarnessUpdate(planned, { env: runtime.env, dryRun: runtime.dryRun });
-  const failed = steps.some((step) => step.outcome === "failed") || kxmApply?.ok === false;
+  const planned = planHarnessUpdate(inventory, { ...(harness ? { harness } : {}), scope: fullUpdate ? "all" : scope });
+  const runOpts = { env: runtime.env, dryRun: runtime.dryRun };
+  let steps;
+  if (fullUpdate) {
+    const selfSteps = runHarnessUpdate(planned.filter((step) => step.scope === "self"), runOpts);
+    applyKxmPackage(false);
+    const restSteps = runHarnessUpdate(planned.filter((step) => step.scope !== "self"), runOpts);
+    steps = [...selfSteps, ...restSteps];
+  } else {
+    const aborted = applyKxmPackage(Boolean(options.kxm));
+    if (aborted !== undefined) return aborted;
+    steps = runHarnessUpdate(planned, runOpts);
+  }
+  const kxmFailed = kxmApply?.ok === false;
   const skippedUnknown = steps.some((step) => step.detail === "unknown_harness");
+  const harnessFailed = steps.some((step) => step.outcome === "failed");
   const text = [notice.available ? notice.message : undefined, kxmApply?.detail, formatHarnessUpdate(steps)].filter(Boolean).join("\n");
   print(runtime.io, runtime.json, {
-    ok: !failed && !skippedUnknown,
+    ok: !kxmFailed && !skippedUnknown,
     command: "update",
     dryRun: runtime.dryRun,
-    scope,
+    scope: fullUpdate ? "all" : scope,
+    defaultHarness: inventory.defaultHarness,
     notice,
     ...(kxmApply ? { kxm: kxmApply } : {}),
     steps,
+    ...(harnessFailed ? { degraded: true } : {}),
     ...installKindPayload(kindReport),
   }, text);
   if (skippedUnknown) return 2;
-  return failed ? 1 : 0;
+  if (kxmFailed) return 1;
+  if (harnessFailed && !fullUpdate) return 1;
+  return 0;
 }
 
 export async function cmdValidate(runtime: Runtime, fileFlag?: string | undefined): Promise<number> {

package/plugins/kxm/src/cli.ts

@@ -788,8 +788,9 @@ function createProgram(ctx: CliContext, result: { code: number }, argv: readonly
   addGlobalOptions(program.command("update").description("Update kxm, harness CLIs, extensions, plugins, and model catalogs")
     .argument("[harness]", "Harness id (default: every detected harness)")
     .option("--check", "Check for a kxm package update without applying")
-    .option("--kxm", "Apply the kxm operator package update (GitHub release tarball or npm)")
-    .option("--self", "Update only the harness CLI")
+    .option("--all", "Update harness CLIs first (--self), then kxm, extensions, and models (default)")
+    .option("--kxm", "Apply only the kxm operator package update")
+    .option("--self", "Update only harness CLIs")
     .option("--extensions", "Update only extensions/plugins (Pi packages, Claude kxm)")
     .option("--models", "Refresh model catalogs where the harness supports it"))
     .action(async function updateAction(this: Command, harness: string | undefined, options: {
@@ -798,6 +799,7 @@ function createProgram(ctx: CliContext, result: { code: number }, argv: readonly
       models?: boolean;
       check?: boolean;
       kxm?: boolean;
+      all?: boolean;
     }) {
       result.code = await cmdUpdate(runtimeFrom(ctx, this), harness, options);
     });

package/plugins/kxm/src/harness.ts

@@ -1449,13 +1449,24 @@ function argsFor(entry: HarnessCatalogEntry, scope: Exclude<HarnessUpdateScope,
   return entry.update.models;
 }
 
+function detectedHarnesses(
+  inventory: HarnessInventory,
+  requestedHarness?: string,
+): HarnessStatus[] {
+  if (requestedHarness) return inventory.harnesses.filter((entry) => entry.id === requestedHarness);
+  const detected = inventory.harnesses.filter((entry) => entry.detected);
+  const preferred = inventory.defaultHarness;
+  return [
+    ...detected.filter((entry) => entry.id === preferred),
+    ...detected.filter((entry) => entry.id !== preferred),
+  ];
+}
+
 export function planHarnessUpdate(
   inventory: HarnessInventory,
   requested: { harness?: string; scope: HarnessUpdateScope },
 ): HarnessUpdateStep[] {
-  const selected = requested.harness
-    ? inventory.harnesses.filter((entry) => entry.id === requested.harness)
-    : inventory.harnesses.filter((entry) => entry.detected);
+  const selected = detectedHarnesses(inventory, requested.harness);
   if (requested.harness && selected.length === 0) {
     return [{
       harness: requested.harness,
@@ -1466,36 +1477,46 @@ export function planHarnessUpdate(
       detail: isKnownHarnessId(requested.harness) ? "not_detected" : "unknown_harness",
     }];
   }
+  const waves: Exclude<HarnessUpdateScope, "all">[] = requested.scope === "all"
+    ? ["self", "extensions", "models"]
+    : [requested.scope];
   const steps: HarnessUpdateStep[] = [];
-  for (const status of selected) {
-    const entry = BUILTIN_HARNESSES.find((candidate) => candidate.id === status.id);
-    if (!entry) continue;
-    const scopes = scopesFor(requested.scope, entry);
-    if (scopes.length === 0) {
-      steps.push({
-        harness: status.id,
-        scope: requested.scope === "all" ? "self" : requested.scope,
-        command: status.command ?? entry.commands[0]!,
-        args: [],
-        outcome: "skipped",
-        detail: "no_updater",
-      });
-      continue;
-    }
-    if (!status.detected || !status.command) {
+  for (const scope of waves) {
+    for (const status of selected) {
+      const entry = BUILTIN_HARNESSES.find((candidate) => candidate.id === status.id);
+      if (!entry) continue;
+      const supported = scopesFor(requested.scope === "all" ? "all" : scope, entry);
+      if (!supported.includes(scope)) {
+        if (requested.scope !== "all") {
+          steps.push({
+            harness: status.id,
+            scope,
+            command: status.command ?? entry.commands[0]!,
+            args: [],
+            outcome: "skipped",
+            detail: "no_updater",
+          });
+        }
+        continue;
+      }
+      if (!status.detected || !status.command) {
+        steps.push({
+          harness: status.id,
+          scope,
+          command: entry.commands[0]!,
+          args: argsFor(entry, scope) ?? [],
+          outcome: "skipped",
+          detail: "not_detected",
+        });
+        continue;
+      }
       steps.push({
         harness: status.id,
-        scope: scopes[0]!,
-        command: entry.commands[0]!,
-        args: argsFor(entry, scopes[0]!) ?? [],
-        outcome: "skipped",
-        detail: "not_detected",
+        scope,
+        command: status.command,
+        args: argsFor(entry, scope) ?? [],
+        outcome: "would",
       });
-      continue;
-    }
-    for (const scope of scopes) {
-      const args = argsFor(entry, scope) ?? [];
-      steps.push({ harness: status.id, scope, command: status.command, args, outcome: "would" });
     }
   }
   return steps;

package/plugins/kxm/src/kxm-install-kind.ts

@@ -19,6 +19,12 @@ export interface InstallKindReport {
   instruction: string;
 }
 
+export function kxmSourceCheckoutRoot(dir: string): string | undefined {
+  if (!existsSync(join(dir, ".git"))) return undefined;
+  if (!packageIsKxm(dir)) return undefined;
+  return dir;
+}
+
 function packageIsKxm(root: string): boolean {
   try {
     const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as { name?: unknown };

package/plugins/kxm/src/kxm-update-config.ts

@@ -10,7 +10,7 @@ import { kxmUserStateRoot } from "./bindings.ts";
 
 export function loadKxmUpdateConfig(env: NodeJS.ProcessEnv = process.env): KxmUpdateConfig {
   const path = join(kxmUserStateRoot({ env }), "update.yaml");
-  if (!existsSync(path)) return { schema: KXM_UPDATE_SCHEMA, auto: false, source: "github" };
+  if (!existsSync(path)) return { schema: KXM_UPDATE_SCHEMA, auto: false, source: "npm" };
   let parsed: unknown;
   try {
     parsed = parseYaml(readFileSync(path, "utf8"));
@@ -31,7 +31,7 @@ export function loadKxmUpdateConfig(env: NodeJS.ProcessEnv = process.env): KxmUp
   if (typeof row.auto !== "boolean") {
     throw new KxmUpdateConfigError("update.yaml auto must be a boolean");
   }
-  const source = row.source === undefined ? "github" : row.source;
+  const source = row.source === undefined ? "npm" : row.source;
   if (source !== "npm" && source !== "github") {
     throw new KxmUpdateConfigError("update.yaml source must be npm or github");
   }

package/plugins/kxm/src/kxm-update.ts

@@ -10,6 +10,7 @@ const CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 const SHA256_DIGEST = /^sha256:([0-9a-fA-F]{64})$/;
 
 export type KxmUpdateSource = "npm" | "github";
+export type KxmApplySource = KxmUpdateSource | "local";
 
 export interface KxmReleaseAsset {
   name: string;
@@ -27,9 +28,10 @@ export interface KxmUpdateNotice {
   latest?: string;
   available: boolean;
   auto: boolean;
-  source: KxmUpdateSource;
+  source: KxmApplySource;
   message: string;
   asset?: KxmReleaseAsset;
+  localRoot?: string;
 }
 
 export class KxmUpdateConfigError extends Error {
@@ -100,7 +102,7 @@ export function compareSemver(left: string, right: string): number | undefined {
 
 export function formatKxmUpdateNotice(notice: KxmUpdateNotice): string {
   if (!notice.available) return notice.message;
-  const apply = notice.auto ? "kxm update --kxm (auto)" : "kxm update --kxm";
+  const apply = notice.auto ? "kxm update (auto)" : "kxm update";
   return `kxm ${notice.current} → ${notice.latest} available · ${apply}`;
 }
 
@@ -243,14 +245,19 @@ export function verifyReleaseAssetDigest(path: string, sha256: string): boolean
   }
 }
 
-/** npm registry apply is for after the public package exists. npm verifies registry integrity itself; do not duplicate that check here. Git installs use GitHub release tarballs. */
+/** npm is the default source and npm verifies registry integrity itself. "local" installs this repository's checkout. "github" downloads the release tarball (gh, or curl without gh) and verifies its sha256. */
 export function planKxmPackageUpdate(
-  source: KxmUpdateSource,
+  source: KxmApplySource,
   latest: string,
   releaseDir: string,
   asset?: KxmReleaseAsset,
   downloader: "gh" | "curl" = "gh",
+  localRoot?: string,
 ): KxmPackageUpdateStep[] {
+  if (source === "local") {
+    if (!localRoot) return [];
+    return [{ kind: "install", command: "npm", args: ["install", "--global", "--omit=peer", localRoot] }];
+  }
   if (source === "npm") {
     return [{ kind: "install", command: "npm", args: ["install", "--global", "--omit=peer", `@kontextmind/kxm@${latest}`] }];
   }

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

@@ -11,7 +11,7 @@ import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 import { sessionTokenFixHint } from "./session-token-hint.ts";
 
-const VERSION = "0.7.173";
+const VERSION = "0.7.175";
 const CONFIGURE_PLUGIN = "/plugin configure kxm@kxm";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();

package/scripts/docker-install-smoke.mjs

@@ -14,6 +14,7 @@ import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "nod
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 
+import { npmPackArtifacts } from "./npm-pack-json.mjs";
 const repoRoot = resolve(import.meta.dirname, "..");
 
 const vault = process.env.KXM_SMOKE_VAULT ?? "AI Provider Keys";
@@ -92,7 +93,7 @@ function main() {
     //    commit gate (`npm run verify` -> check:generated) enforces that.
     process.stdout.write("==> npm pack\n");
     const packed = run("npm", ["pack", "--pack-destination", scratch, "--json"], { cwd: repoRoot });
-    const filename = JSON.parse(packed.stdout)[0]?.filename;
+    const filename = npmPackArtifacts(packed.stdout)[0]?.filename;
     if (!filename) die("npm pack produced no tarball");
     const tarball = join(scratch, filename);
 

package/scripts/npm-pack-json.d.mts

@@ -0,0 +1,4 @@
+export function npmPackArtifacts(stdout: string): Array<{
+  filename?: string;
+  files?: Array<{ path: string }>;
+}>;

package/scripts/npm-pack-json.mjs

@@ -0,0 +1,15 @@
+/**
+ * `npm pack --json` is a one-element array through npm 11. npm 12 returns
+ * one object keyed by package name. Both shapes carry `filename` and `files`.
+ */
+export function npmPackArtifacts(stdout) {
+  const parsed = JSON.parse(stdout);
+  if (Array.isArray(parsed)) return parsed;
+  if (parsed && typeof parsed === "object") {
+    const values = Object.values(parsed);
+    if (values.length > 0 && values.every((value) => value && typeof value === "object" && !Array.isArray(value))) {
+      return values;
+    }
+  }
+  throw new Error(`unexpected npm pack JSON: ${String(stdout).slice(0, 200)}`);
+}

package/scripts/pr-land.mjs

@@ -8,7 +8,7 @@
 
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { delimiter, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const STAGES = Object.freeze([
@@ -67,13 +67,55 @@ function childEnv() {
   return env;
 }
 
+function pathValue(env) {
+  const key = Object.keys(env).find((name) => name.toUpperCase() === "PATH");
+  return key ? env[key] : "";
+}
+
+function comSpec(env) {
+  const key = Object.keys(env).find((name) => name.toUpperCase() === "COMSPEC");
+  return (key && env[key].trim()) || "cmd.exe";
+}
+
+/** CreateProcess does not run `npm.cmd`. Prefer a real `.exe`; otherwise launch the `.cmd`/`.bat` through cmd. */
+function windowsScriptOnPath(command, env) {
+  if (process.platform !== "win32") return undefined;
+  if (/\.(?:exe|com)$/i.test(command) || /[\\/]/.test(command)) return undefined;
+  if (/\.(?:cmd|bat)$/i.test(command)) return command;
+  for (const dir of pathValue(env).split(delimiter)) {
+    if (!dir) continue;
+    if (existsSync(join(dir, `${command}.exe`))) return undefined;
+    const cmd = join(dir, `${command}.cmd`);
+    if (existsSync(cmd)) return cmd;
+    const bat = join(dir, `${command}.bat`);
+    if (existsSync(bat)) return bat;
+  }
+  return undefined;
+}
+
+function quoteCmdArg(value) {
+  const text = String(value);
+  if (/[\0\r\n"%!]/.test(text)) {
+    throw new Error(`cannot pass ${JSON.stringify(text)} to a Windows command script`);
+  }
+  return `"${text}"`;
+}
+
 function run(command, args, timeout = 120_000) {
-  const result = spawnSync(command, args, {
+  const env = childEnv();
+  const script = windowsScriptOnPath(command, env);
+  const windowsCommandScript = Boolean(script);
+  const launchCommand = windowsCommandScript ? comSpec(env) : command;
+  const launchArgs = windowsCommandScript
+    ? ["/d", "/s", "/v:off", "/c", `"${[script, ...args].map(quoteCmdArg).join(" ")}"`]
+    : args;
+  const result = spawnSync(launchCommand, launchArgs, {
     cwd: root,
     encoding: "utf8",
-    env: childEnv(),
+    env,
     timeout,
     windowsHide: true,
+    windowsVerbatimArguments: windowsCommandScript,
   });
   return {
     status: result.status ?? 1,