@time-machine-lab/tmlbrain 0.1.0 → 0.1.1

package/README.md

@@ -34,12 +34,29 @@ TMLBrain/
   docs/                   Architecture, decisions, and operating docs.
 ```
 
-## Local Tooling
+## Client Install
 
-The npm package exposes a dependency-light CLI:
+Recommended npm install:
+
+```text
+npm install -g @time-machine-lab/tmlbrain@latest
+tmlbrain client install
+```
+
+The installer asks for a server URL. Leave it empty to start in local-only
+mode, or provide the TMLBrain server URL and token to enable team sync and
+server-side writes.
+
+Non-interactive npm install:
+
+```text
+npm install -g @time-machine-lab/tmlbrain@latest
+tmlbrain client install --server http://server-host:8477 --token <token> --yes
+```
+
+After installation:
 
 ```text
-npx @time-machine-lab/tmlbrain client install
 tmlbrain find "keyword"
 tmlbrain save --title "Title" --content "Content"
 ```
@@ -49,23 +66,22 @@ need Git. Server-side writes use Node plus Git from the server worktree.
 Python-based CocoIndex and LightRAG support are optional graph retrieval
 enhancements.
 
-Interactive client install asks for a server URL. Leave it empty to start in
-local-only mode, or provide the TMLBrain server URL and token to enable team
-sync and server-side writes.
-
-Non-interactive client install:
+Update an existing client without re-entering the setup flow:
 
 ```text
-npx @time-machine-lab/tmlbrain client install --server http://server-host:7389 --token secret --yes
+tmlbrain update
 ```
 
+Use `npx -y @time-machine-lab/tmlbrain@latest client install` only when you
+want a one-time install without keeping a global `tmlbrain` command.
+
 ## Server Docker
 
 The server is deployed separately from clients and requires a token:
 
 ```text
 docker run -d --name tmlbrain-server \
-  -p 7389:7389 \
+  -p 8477:8477 \
   -e TMLBRAIN_SERVER_TOKEN=change-me \
   -e TMLBRAIN_KNOWLEDGE_REPO=https://github.com/Time-Machine-Lab/TMLBrainKnowledge.git \
   -e TMLBRAIN_KNOWLEDGE_REF=main \
@@ -87,13 +103,13 @@ Only pushes to `main` are considered. A release runs when the HEAD commit
 message contains `<Auto>` and a version flag:
 
 ```text
-[tml-brain]<Auto> release server and client -v:0.1.0 -rp:7389 -de:<-e KEY=value>
+[tml-brain]<Auto> release server and client -v:0.1.0 -rp:8477 -de:<-e KEY=value>
 ```
 
 - `-v` is required and becomes both the npm package version and Docker image
   version; use a Docker-compatible value such as `0.1.0` or `0.1.0-beta.1`.
 - `-rp` sets the default server port baked into the Docker image; it defaults
-  to `7389`.
+  to `8477`.
 - `-de` is optional runtime Docker argument metadata recorded in
   the commit message and may also be copied into `prod_deploy.log` manually.
 
@@ -101,6 +117,8 @@ The workflow publishes `@time-machine-lab/tmlbrain` to npm, pushes the server
 image to the Docker repository configured by `DOCKER_REPO`, and then deploys
 that image to the configured server with `SERVER_HOST`, `SERVER_USER`, and
 `SERVER_PWD`. Docker images are tagged as `latest`, `version`, and `vversion`.
+The server deploy step skips Docker login by default and directly pulls the
+public image. Only set `TMLBRAIN_SERVER_DOCKER_LOGIN=true` for private images.
 The workflow does not mutate repository files; if
 maintainers want a production release note, update `prod_deploy.log` manually
 before committing the auto-release instruction.

package/bin/tmlbrain.js

@@ -19,11 +19,12 @@ const CONFLICT_DIR = path.join(LOCAL_DIR, "conflicts");
 const PATCH_DIR = path.join(LOCAL_DIR, "patches");
 const LOG_DIR = path.join(LOCAL_DIR, "logs");
 const STATE_FILE = path.join(LOCAL_DIR, "state.json");
+const PACKAGE_INFO = readPackageInfo();
 
 const VALID_TYPES = new Set(["project", "area", "resource", "reference", "meeting", "decision"]);
 const VALID_STATUSES = new Set(["draft", "active", "stale", "archived"]);
 const DEFAULT_SERVER_HOST = "127.0.0.1";
-const DEFAULT_SERVER_PORT = 7389;
+const DEFAULT_SERVER_PORT = 8477;
 
 main().catch((error) => fail(error.message || String(error)));
 
@@ -38,10 +39,18 @@ async function main() {
       case "--help":
         printHelp();
         break;
+      case "version":
+      case "-v":
+      case "--version":
+        console.log(PACKAGE_INFO.version);
+        break;
       case "install":
       case "init":
         cmdInstall(args);
         break;
+      case "update":
+        await cmdUpdate(args);
+        break;
       case "client":
         await cmdClient(args);
         break;
@@ -109,6 +118,8 @@ function printHelp() {
 
 Usage:
   tmlbrain client install [--server <http-url>] [--token <token>] [--local] [--yes]
+  tmlbrain update [latest|<version>] [--sync] [--dry-run]
+  tmlbrain version|--version
   tmlbrain install [--server <http-url>] [--token <token>] [--graph] [--with-git]
   tmlbrain config show|set-server|clear-token
   tmlbrain doctor
@@ -143,6 +154,7 @@ async function cmdClient(args) {
 
 Usage:
   tmlbrain client install [--server <http-url>] [--token <token>] [--local] [--yes]
+  tmlbrain client update [latest|<version>] [--sync] [--dry-run]
   tmlbrain client doctor
 
 If --server is omitted, interactive install asks for one. Press Enter to start
@@ -153,6 +165,10 @@ in local-only mode.`);
     await cmdClientInstall(args);
     return;
   }
+  if (action === "update") {
+    await cmdUpdate(args);
+    return;
+  }
   if (action === "doctor") {
     cmdDoctor(args);
     return;
@@ -164,9 +180,10 @@ async function cmdClientInstall(args) {
   const opts = parseArgs(args);
   const interactive = !opts.yes && !opts["non-interactive"];
   ensureLocalDirs();
+  const existingState = readState();
 
-  let server = opts.local ? "" : (opts.server || "");
-  let token = opts.token || "";
+  let server = opts.local ? "" : (opts.server || existingState.server || "");
+  let token = opts.local ? "" : (opts.token || existingState.token || "");
   let graph = Boolean(opts.graph);
 
   if (interactive) {
@@ -180,6 +197,7 @@ async function cmdClientInstall(args) {
   if (server && !token) fail("Server token is required when a server URL is configured. Use --token <token> or leave the server URL empty for local-only mode.");
 
   const installArgs = [];
+  if (opts.local) installArgs.push("--local");
   if (server) installArgs.push("--server", server);
   if (token) installArgs.push("--token", token);
   if (graph) installArgs.push("--graph");
@@ -207,9 +225,17 @@ function cmdInstall(args) {
     ? ensureGit({ install: true, dryRun: Boolean(opts["dry-run"]) })
     : checkCommand("git", ["--version"]);
   const state = readState();
+  if (opts.local) {
+    delete state.server;
+    delete state.token;
+  }
   if (opts.server) state.server = opts.server;
   if (opts.token) state.token = opts.token;
   if (!state.workspaceVersion) state.workspaceVersion = 1;
+  state.package = {
+    name: PACKAGE_INFO.name,
+    version: PACKAGE_INFO.version
+  };
   state.git = { detected: gitInfo.ok, version: gitInfo.version || null };
   state.updatedAt = new Date().toISOString();
   writeJson(STATE_FILE, state);
@@ -218,6 +244,59 @@ function cmdInstall(args) {
   console.log("TMLBrain workspace is ready.");
 }
 
+async function cmdUpdate(args) {
+  const opts = parseArgs(args);
+  ensureLocalDirs();
+  const state = readState();
+  const target = opts.version || opts.tag || opts._[0] || "latest";
+  const packageSpec = `${PACKAGE_INFO.name}@${target}`;
+  const dryRun = Boolean(opts["dry-run"]);
+  const skipNpm = Boolean(opts["skip-npm"]);
+  const server = opts.local ? "" : (opts.server || state.server || "");
+  const token = opts.local ? "" : (opts.token || state.token || "");
+  const installArgs = ["install"];
+
+  if (opts.local) installArgs.push("--local");
+  if (opts.server) installArgs.push("--server", opts.server);
+  if (opts.token) installArgs.push("--token", opts.token);
+  if (opts.graph) installArgs.push("--graph");
+  if (dryRun) installArgs.push("--dry-run");
+
+  if (dryRun) {
+    console.log(`Would update npm package: npm install -g ${packageSpec}`);
+    console.log(`Would refresh local runtime: tmlbrain ${redactArgs(installArgs).join(" ")}`);
+    if (server && !opts.server) console.log("Would preserve the existing configured server.");
+    if (token && !opts.token) console.log("Would preserve the existing configured token.");
+    return;
+  }
+
+  if (!skipNpm) {
+    if (!checkCommand("npm", ["--version"]).ok) {
+      fail("npm is required for `tmlbrain update`. Install Node.js/npm first, or use `npx -y @time-machine-lab/tmlbrain@latest client install`.");
+    }
+    console.log(`Updating ${packageSpec} with npm...`);
+    const npmResult = runCommand("npm", ["install", "-g", packageSpec], { stdio: "inherit" });
+    if (npmResult.status !== 0) fail(`npm update failed for ${packageSpec}.`);
+  }
+
+  console.log("Refreshing TMLBrain workspace runtime and skill from the installed package...");
+  const cliPath = path.join(PACKAGE_ROOT, "bin", "tmlbrain.js");
+  const refreshResult = fs.existsSync(cliPath)
+    ? spawnSync(process.execPath, [cliPath, ...installArgs], { cwd: ROOT, stdio: "inherit" })
+    : runCommand("tmlbrain", installArgs, { cwd: ROOT, stdio: "inherit" });
+
+  if (refreshResult.status !== 0) {
+    console.warn("Updated package, but automatic runtime refresh failed. Falling back to current CLI runtime.");
+    cmdInstall(installArgs.slice(1));
+  }
+
+  if (opts.sync && server) {
+    await cmdSync(["--pull", ...(opts.json ? ["--json"] : [])]);
+  }
+
+  console.log("TMLBrain update is complete.");
+}
+
 function cmdDoctor(args) {
   const opts = parseArgs(args);
   const state = readState();
@@ -788,6 +867,7 @@ function capabilities() {
     configuredServer: state.server || null,
     config: safeConfigView(state),
     userCommands: [
+      { command: "tmlbrain update", role: "client", description: "Update the npm package, refresh the local Skill/runtime, and preserve existing client configuration." },
       { command: "tmlbrain config show", role: "client", description: "Show the configured server without printing the token." },
       { command: "tmlbrain config set-server <http-url> --token <token>", role: "client", description: "Switch this client to another TMLBrain server." },
       { command: "tmlbrain sync --pull", role: "client", description: "Refresh the local read-only knowledge snapshot from the configured server." },
@@ -797,6 +877,7 @@ function capabilities() {
       { command: "tmlbrain remote update --file <path> --replace <old> --with <new>", role: "client-request", description: "Ask the server to update a precise text region." }
     ],
     commands: [
+      { command: "tmlbrain update", role: "client", description: "Update the globally installed package and refresh local runtime files without asking for setup again." },
       { command: "tmlbrain sync --pull", role: "client", description: "Fetch a read-only knowledge snapshot from the configured HTTP server." },
       { command: "tmlbrain search <query>", role: "client", description: "Search local Markdown snapshot." },
       { command: "tmlbrain find <query>", role: "client", description: "Alias for local search." },
@@ -1071,7 +1152,7 @@ async function requestServerJson(endpoint, body, opts) {
 async function requestServer(method, endpoint, body, opts) {
   const state = readState();
   const base = opts.server || state.server;
-  if (!base || !isHttpUrl(base)) fail("Configure an HTTP TMLBrain server first: tmlbrain install --server http://host:7389");
+  if (!base || !isHttpUrl(base)) fail("Configure an HTTP TMLBrain server first: tmlbrain install --server http://host:8477");
   const token = opts.token || state.token || process.env.TMLBRAIN_TOKEN || null;
   const url = new URL(endpoint, base.endsWith("/") ? base : `${base}/`);
   const transport = url.protocol === "https:" ? https : http;
@@ -1399,6 +1480,18 @@ function parseArgs(args) {
   return opts;
 }
 
+function redactArgs(args) {
+  const redacted = [];
+  for (let i = 0; i < args.length; i += 1) {
+    redacted.push(args[i]);
+    if (args[i] === "--token" && i + 1 < args.length) {
+      redacted.push("<token>");
+      i += 1;
+    }
+  }
+  return redacted;
+}
+
 function promptText(label, defaultValue = "") {
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
   return promptLine(`${label}${suffix}: `).then((answer) => {
@@ -1556,6 +1649,21 @@ function parseRgLine(line) {
   return { path: match[1], line: Number(match[2]), text: match[3] };
 }
 
+function readPackageInfo() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
+    return {
+      name: pkg.name || "@time-machine-lab/tmlbrain",
+      version: pkg.version || "0.0.0"
+    };
+  } catch {
+    return {
+      name: "@time-machine-lab/tmlbrain",
+      version: "0.0.0"
+    };
+  }
+}
+
 function readState() {
   return fs.existsSync(STATE_FILE) ? JSON.parse(fs.readFileSync(STATE_FILE, "utf8")) : {};
 }
@@ -1610,10 +1718,20 @@ function checkCommand(command, args = []) {
   if (process.env.TMLBRAIN_SIMULATE_MISSING_GIT === "1" && command === "git") {
     return { ok: false, version: null };
   }
-  const result = spawnSync(command, args, { encoding: "utf8" });
+  const result = runCommand(command, args, { encoding: "utf8" });
   return { ok: result.status === 0, version: result.stdout ? result.stdout.split(/\r?\n/)[0] : null };
 }
 
+function runCommand(command, args = [], opts = {}) {
+  const spawnOpts = {
+    cwd: opts.cwd || ROOT,
+    shell: process.platform === "win32"
+  };
+  if (opts.stdio) spawnOpts.stdio = opts.stdio;
+  else spawnOpts.encoding = opts.encoding || "utf8";
+  return spawnSync(command, args, spawnOpts);
+}
+
 function git(args, opts = {}) {
   const result = spawnSync("git", args, { cwd: ROOT, encoding: "utf8" });
   const out = { ok: result.status === 0, stdout: result.stdout || "", stderr: result.stderr || "" };

package/docs/install.md

@@ -2,10 +2,11 @@
 
 ## Client
 
-Recommended interactive install:
+Recommended npm install:
 
 ```text
-npx @time-machine-lab/tmlbrain client install
+npm install -g @time-machine-lab/tmlbrain@latest
+tmlbrain client install
 ```
 
 The installer asks for:
@@ -19,21 +20,31 @@ search, index, and save Markdown under the local `knowledge/` folder. They can
 connect to a team server later:
 
 ```text
-tmlbrain config set-server http://server-host:7389 --token <token>
+tmlbrain config set-server http://server-host:8477 --token <token>
 tmlbrain sync --pull
 ```
 
-Non-interactive client install:
+Non-interactive npm install:
 
 ```text
-npx @time-machine-lab/tmlbrain client install --server http://server-host:7389 --token <token> --yes
+npm install -g @time-machine-lab/tmlbrain@latest
+tmlbrain client install --server http://server-host:8477 --token <token> --yes
 ```
 
-Global install is also supported after the npm package is published:
+Update an existing npm-installed client:
 
 ```text
-npm install -g @time-machine-lab/tmlbrain
-tmlbrain client install
+tmlbrain update
+```
+
+`tmlbrain update` runs `npm install -g @time-machine-lab/tmlbrain@latest`,
+refreshes the local Skill/runtime, and preserves the existing server URL and
+token. Use `tmlbrain update 0.1.1` to update to a specific version.
+
+Optional one-time npx install without keeping a global command:
+
+```text
+npx -y @time-machine-lab/tmlbrain@latest client install
 ```
 
 ## Server
@@ -45,7 +56,7 @@ skeleton.
 
 ```text
 docker run -d --name tmlbrain-server \
-  -p 7389:7389 \
+  -p 8477:8477 \
   -e TMLBRAIN_SERVER_TOKEN=<required-token> \
   -e TMLBRAIN_KNOWLEDGE_REPO=https://github.com/Time-Machine-Lab/TMLBrainKnowledge.git \
   -e TMLBRAIN_KNOWLEDGE_REF=main \
@@ -89,7 +100,11 @@ repository configured in GitHub Actions secret `DOCKER_REPO`. The npm client
 package is published by the same workflow with the `NPM_TOKEN` repository
 secret. The workflow then logs in to the target server with
 `SERVER_HOST`, `SERVER_USER`, and `SERVER_PWD`, pulls the new image, and
-restarts the `tmlbrain-server` container.
+restarts the `tmlbrain-server` container. Server-side Docker login is skipped
+by default because the runtime image is expected to be public; only the GitHub
+Actions runner needs Docker credentials to push the image. For a private image,
+set `TMLBRAIN_SERVER_DOCKER_LOGIN=true` and provide
+`TMLBRAIN_SERVER_DOCKER_USERNAME` plus `TMLBRAIN_SERVER_DOCKER_PASSWORD`.
 
 ```text
 <DOCKER_REPO>:latest
@@ -135,7 +150,7 @@ commits that do not contain `<Auto>`.
 Example:
 
 ```text
-[tml-brain]<Auto> release server and client -v:0.1.0 -rp:7389 -de:<-e KEY=value>
+[tml-brain]<Auto> release server and client -v:0.1.0 -rp:8477 -de:<-e KEY=value>
 ```
 
 Fields:
@@ -143,7 +158,7 @@ Fields:
 - `<Auto>` is required to trigger publishing.
 - `-v:<semver>` is required and is used for both npm and Docker versions. Use a
   Docker-compatible value such as `0.1.0` or `0.1.0-beta.1`.
-- `-rp:<port>` is optional and defaults to `7389`; it becomes the Docker image
+- `-rp:<port>` is optional and defaults to `8477`; it becomes the Docker image
   default `TMLBRAIN_PORT`.
 - `-de:<...>` is optional single-line Docker runtime metadata, such as
   additional `docker run -e` arguments. It stays in the commit message and is

package/docs/runtime.md

@@ -5,7 +5,8 @@
 TMLBrain should feel like one product to the user:
 
 ```text
-npx @time-machine-lab/tmlbrain client install
+npm install -g @time-machine-lab/tmlbrain@latest
+tmlbrain client install
 @TMLBrain search or update knowledge
 ```
 
@@ -43,7 +44,8 @@ If Python, CocoIndex, or LightRAG cannot be activated, core TMLBrain remains usa
 Recommended npm client entry:
 
 ```text
-npx @time-machine-lab/tmlbrain client install
+npm install -g @time-machine-lab/tmlbrain@latest
+tmlbrain client install
 ```
 
 The client installer asks for a server URL. Leaving it empty starts local-only
@@ -66,7 +68,8 @@ Both scripts call the same CLI bootstrap flow and keep the user away from raw Gi
 Non-interactive client install:
 
 ```text
-npx @time-machine-lab/tmlbrain client install --server http://server-host:7389 --token secret --yes
+npm install -g @time-machine-lab/tmlbrain@latest
+tmlbrain client install --server http://server-host:8477 --token secret --yes
 ```
 
 ## Server Runtime
@@ -74,7 +77,7 @@ npx @time-machine-lab/tmlbrain client install --server http://server-host:7389 -
 Run with Docker:
 
 ```text
-docker run -d --name tmlbrain-server -p 7389:7389 -e TMLBRAIN_SERVER_TOKEN=secret -e TMLBRAIN_KNOWLEDGE_REPO=https://github.com/Time-Machine-Lab/TMLBrainKnowledge.git -v tmlbrain-data:/data <DOCKER_REPO>:latest
+docker run -d --name tmlbrain-server -p 8477:8477 -e TMLBRAIN_SERVER_TOKEN=secret -e TMLBRAIN_KNOWLEDGE_REPO=https://github.com/Time-Machine-Lab/TMLBrainKnowledge.git -v tmlbrain-data:/data <DOCKER_REPO>:latest
 ```
 
 The image contains tooling and templates only. Real knowledge is restored from
@@ -86,7 +89,7 @@ port with `-e TMLBRAIN_PORT=<port>` and the corresponding Docker `-p` mapping.
 Manual development mode from the server worktree:
 
 ```text
-node bin/tmlbrain.js serve --host 0.0.0.0 --port 7389
+node bin/tmlbrain.js serve --host 0.0.0.0 --port 8477
 ```
 
 Only the server runtime should mutate Markdown, commit repository changes, or

package/docs/server-api.md

@@ -13,7 +13,7 @@ Recommended Docker deployment:
 
 ```text
 docker run -d --name tmlbrain-server \
-  -p 7389:7389 \
+  -p 8477:8477 \
   -e TMLBRAIN_SERVER_TOKEN=secret \
   -e TMLBRAIN_KNOWLEDGE_REPO=https://github.com/Time-Machine-Lab/TMLBrainKnowledge.git \
   -v tmlbrain-data:/data \
@@ -27,19 +27,19 @@ worktree instead of cloning again.
 Run from the server worktree:
 
 ```text
-node bin/tmlbrain.js serve --host 0.0.0.0 --port 7389
+node bin/tmlbrain.js serve --host 0.0.0.0 --port 8477
 ```
 
 Optional token protection:
 
 ```text
-TMLBRAIN_SERVER_TOKEN=secret node bin/tmlbrain.js serve --host 0.0.0.0 --port 7389
+TMLBRAIN_SERVER_TOKEN=secret node bin/tmlbrain.js serve --host 0.0.0.0 --port 8477
 ```
 
 Clients then install with:
 
 ```text
-npx @time-machine-lab/tmlbrain client install --server http://server-host:7389 --token secret --yes
+npx -y @time-machine-lab/tmlbrain@latest client install --server http://server-host:8477 --token secret --yes
 ```
 
 The client stores this in `.tmlbrain/state.json`. The token is not shown by
@@ -54,19 +54,19 @@ node bin/tmlbrain.js config show
 Switch a client to a different server:
 
 ```text
-node bin/tmlbrain.js config set-server http://new-server-host:7389 --token secret
+node bin/tmlbrain.js config set-server http://new-server-host:8477 --token secret
 node bin/tmlbrain.js sync --pull
 ```
 
 `--server` and `--token` can also be passed to one command for temporary
 overrides.
 
-If the cloud security group does not expose port `7389`, keep the API private
+If the cloud security group does not expose port `8477`, keep the API private
 and use a tunnel from the client machine:
 
 ```text
-ssh -N -L 7390:127.0.0.1:7389 tmlbrain-1007
-npx @time-machine-lab/tmlbrain client install --server http://127.0.0.1:7390 --token secret --yes
+ssh -N -L 8478:127.0.0.1:8477 tmlbrain-1007
+npx -y @time-machine-lab/tmlbrain@latest client install --server http://127.0.0.1:8478 --token secret --yes
 ```
 
 ## Client Commands

package/docs/sync.md

@@ -102,7 +102,7 @@ Use:
 
 ```text
 tmlbrain config show
-tmlbrain config set-server http://server-host:7389 --token <token>
+tmlbrain config set-server http://server-host:8477 --token <token>
 tmlbrain sync --pull
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@time-machine-lab/tmlbrain",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "TMLBrain local-first team knowledge base tooling.",
   "type": "commonjs",
   "bin": {

package/scripts/docker/server-entrypoint.sh

@@ -12,7 +12,7 @@ BARE_REPO="${TMLBRAIN_BARE_REPO:-$DATA_DIR/tmlbrain.git}"
 KNOWLEDGE_REPO="${TMLBRAIN_KNOWLEDGE_REPO:-}"
 KNOWLEDGE_REF="${TMLBRAIN_KNOWLEDGE_REF:-main}"
 HOST="${TMLBRAIN_HOST:-0.0.0.0}"
-PORT="${TMLBRAIN_PORT:-7389}"
+PORT="${TMLBRAIN_PORT:-8477}"
 
 mkdir -p "$DATA_DIR"
 

package/scripts/release/parse-auto-release.js

@@ -71,7 +71,7 @@ function parseReleaseMessage(message) {
   const result = {
     auto,
     version: "",
-    runtimePort: "7389",
+    runtimePort: "8477",
     dockerExtraArgs: "",
   };
 

package/skills/tmlbrain/SKILL.md

@@ -82,10 +82,17 @@ for newly saved knowledge.
 Initialize or repair local runtime:
 
 ```text
-npx @time-machine-lab/tmlbrain client install
+npm install -g @time-machine-lab/tmlbrain@latest
+tmlbrain client install
+```
+
+Update an existing npm-installed client without re-entering setup:
+
+```text
+tmlbrain update
 ```
 
-Run local CLI after global/package installation:
+Run local CLI after package installation:
 
 ```text
 tmlbrain client install
@@ -143,19 +150,19 @@ Show or change the configured server:
 
 ```text
 tmlbrain config show
-tmlbrain config set-server http://server-host:7389 --token <token>
+tmlbrain config set-server http://server-host:8477 --token <token>
 ```
 
 Start the server API from the server worktree:
 
 ```text
-tmlbrain serve --host 0.0.0.0 --port 7389
+tmlbrain serve --host 0.0.0.0 --port 8477
 ```
 
 Deploy the server with Docker:
 
 ```text
-docker run -d --name tmlbrain-server -p 7389:7389 -e TMLBRAIN_SERVER_TOKEN=<token> -e TMLBRAIN_KNOWLEDGE_REPO=<git-url> -v tmlbrain-data:/data <DOCKER_REPO>:latest
+docker run -d --name tmlbrain-server -p 8477:8477 -e TMLBRAIN_SERVER_TOKEN=<token> -e TMLBRAIN_KNOWLEDGE_REPO=<git-url> -v tmlbrain-data:/data <DOCKER_REPO>:latest
 ```
 
 Back up server state: