@wolfx/opencode-magic-context 0.26.0 → 0.27.2

package/src/shared/redaction.ts

@@ -0,0 +1,264 @@
+import { homedir, userInfo } from "node:os";
+
+function escapeRegex(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// Whole-segment match: the key (or its components when split on common
+// separators) must BE one of these words, not merely contain them as a
+// substring. Bare substring matching wrongly redacts benign fields like
+// `pin_key_files`, `token_budget`, and `injection_budget_tokens`.
+const SECRET_WORDS = [
+    "key",
+    "token",
+    "secret",
+    "password",
+    "auth",
+    "authorization",
+    "bearer",
+    "credential",
+];
+const SECRET_SEGMENT_PATTERN = new RegExp(
+    `^(?:${SECRET_WORDS.map((w) => `${w}s?`).join("|")})$`,
+    "i",
+);
+const TRAILING_DESCRIPTORS = new Set(["id", "ids", "value", "values", "header", "headers"]);
+
+function redactionTypeForKey(key: string): string {
+    const normalized = key
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_.-]+/g, "_");
+    const suffix = normalized.split(".").filter(Boolean).at(-1) ?? normalized;
+    return suffix || "secret";
+}
+
+// A bare number / boolean / null is never a secret — an API key, bearer token,
+// password, or credential is always a high-entropy string. So when a key-based
+// pattern (the `name=value` / `"name":"value"` forms below) matches purely on
+// the KEY containing a word like "token", but the VALUE is numeric/boolean, it's
+// a count or flag, not a secret. These must stay readable in logs:
+// `tokens.input=45000`, `hasUsageTokens=true`, `max_tokens=4096` are diagnostics,
+// not credentials. (High-entropy secret VALUES are still caught by the
+// value-shaped patterns above — bearer, JWT, AKIA, gh*_, etc. — independent of
+// the key name, so relaxing the key-based match for scalars loses no coverage.)
+function isNonSecretScalarValue(value: string): boolean {
+    const v = value.trim();
+    if (v === "true" || v === "false" || v === "null" || v === "undefined") return true;
+    // Integer or decimal, optional sign/exponent — token counts, ports, sizes.
+    return /^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(v);
+}
+
+const SECRET_QUALIFIERS = new Set([
+    "api",
+    "access",
+    "private",
+    "client",
+    "auth",
+    "authorization",
+    "secret",
+    "bearer",
+    "session",
+    "refresh",
+    "service",
+    "x",
+    "openai",
+    "anthropic",
+    "google",
+    "github",
+    "huggingface",
+    "aws",
+    "azure",
+]);
+
+export function isSecretKey(key: string): boolean {
+    const segments = key
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .toLowerCase()
+        .split(/[._-]+/)
+        .filter(Boolean);
+    if (segments.length === 0) return false;
+
+    if (segments.length === 1) {
+        const first = segments[0];
+        return Boolean(first && SECRET_SEGMENT_PATTERN.test(first));
+    }
+
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if (!seg || !SECRET_SEGMENT_PATTERN.test(seg)) continue;
+
+        let trailingOk = true;
+        for (let j = i + 1; j < segments.length; j++) {
+            const tail = segments[j];
+            if (!tail) continue;
+            if (TRAILING_DESCRIPTORS.has(tail)) continue;
+            if (SECRET_SEGMENT_PATTERN.test(tail)) continue;
+            trailingOk = false;
+            break;
+        }
+        if (!trailingOk) continue;
+
+        for (let k = i - 1; k >= 0; k--) {
+            const lead = segments[k];
+            if (lead && SECRET_QUALIFIERS.has(lead)) return true;
+        }
+    }
+    return false;
+}
+
+export function sanitizePathString(value: string): string {
+    const home = homedir();
+    const username = userInfo().username;
+    let sanitized = value;
+    if (home) {
+        sanitized = sanitized.replace(new RegExp(escapeRegex(home), "g"), "~");
+    }
+    sanitized = sanitized.replace(/\/Users\/[^/]+\//g, "/Users/<USER>/");
+    sanitized = sanitized.replace(/\/home\/[^/]+\//g, "/home/<USER>/");
+    sanitized = sanitized.replace(/C:\\Users\\[^\\]+\\/g, "C:\\Users\\<USER>\\");
+    if (username) {
+        sanitized = sanitized.replace(new RegExp(escapeRegex(username), "g"), "<USER>");
+    }
+    return sanitized;
+}
+
+const SECRET_TEXT_PATTERNS: Array<{
+    pattern: RegExp;
+    replacement: string | ((match: string, ...groups: string[]) => string);
+}> = [
+    {
+        pattern: /\bsk-ant-(?:api03-)?[A-Za-z0-9_-]{32,}/g,
+        replacement: "<ANTHROPIC_API_KEY_REDACTED>",
+    },
+    {
+        pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{32,}/g,
+        replacement: "<OPENAI_API_KEY_REDACTED>",
+    },
+    {
+        pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+        replacement: "<GITHUB_PAT_REDACTED>",
+    },
+    {
+        pattern: /\b(?:gh[opsu]|ghr)_[A-Za-z0-9]{30,}/g,
+        replacement: "<GITHUB_TOKEN_REDACTED>",
+    },
+    {
+        pattern: /\bhf_[A-Za-z0-9]{30,}/g,
+        replacement: "<HUGGINGFACE_TOKEN_REDACTED>",
+    },
+    {
+        pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+        replacement: "<AWS_ACCESS_KEY_ID_REDACTED>",
+    },
+    {
+        pattern: /\bxox[abprsuvc]-[A-Za-z0-9-]{10,}/g,
+        replacement: "<SLACK_TOKEN_REDACTED>",
+    },
+    {
+        pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g,
+        replacement: "<GOOGLE_API_KEY_REDACTED>",
+    },
+    {
+        pattern: /\b(Authorization\s*:\s*Bearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi,
+        replacement: (_full: string, prefix: string) => `${prefix}<REDACTED:bearer>`,
+    },
+    {
+        pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
+        replacement: "<JWT_REDACTED>",
+    },
+    {
+        pattern:
+            /(["'])([^"']*(?:key|token|secret|password|auth|bearer|credential)[^"']*)\1(\s*:\s*)(["'])([^"']*)\4/gi,
+        replacement: (
+            full: string,
+            quote: string,
+            key: string,
+            separator: string,
+            valueQuote: string,
+            value: string,
+        ) =>
+            // A numeric/boolean value matched only because the KEY contains a
+            // secret word (e.g. "max_tokens": "4096") is a count, not a secret.
+            isNonSecretScalarValue(value)
+                ? full
+                : `${quote}${key}${quote}${separator}${valueQuote}<REDACTED:${redactionTypeForKey(key)}>${valueQuote}`,
+    },
+    {
+        pattern:
+            /\b([A-Za-z0-9_.-]*(?:key|token|secret|password|auth|bearer|credential)[A-Za-z0-9_.-]*)\s*=\s*([^\s'"`]+)/gi,
+        replacement: (full: string, key: string, value: string) =>
+            // tokens.input=45000 / hasUsageTokens=true are diagnostics, not
+            // secrets — keep them readable. Real secret values are still caught
+            // by the value-shaped patterns above.
+            isNonSecretScalarValue(value) ? full : `${key}=<REDACTED:${redactionTypeForKey(key)}>`,
+    },
+];
+
+export function redactSecretText(value: string): string {
+    let redacted = value;
+    for (const { pattern, replacement } of SECRET_TEXT_PATTERNS) {
+        if (typeof replacement === "string") {
+            redacted = redacted.replace(pattern, replacement);
+        } else {
+            redacted = redacted.replace(
+                pattern,
+                replacement as (match: string, ...groups: string[]) => string,
+            );
+        }
+    }
+    return redacted;
+}
+
+export function sanitizeDiagnosticText(value: string): string {
+    return redactSecretText(sanitizePathString(value));
+}
+
+// Extra shareability-only signals — patterns that mark text as unsafe to share
+// with teammates but that the diagnostic sanitizer (tuned for secret/path
+// REDACTION, not share-gating) does not rewrite. Kept here, NOT in
+// sanitizeDiagnosticText, so diagnostic redaction output is unchanged.
+const SHAREABILITY_SENSITIVE_PATTERNS: RegExp[] = [
+    // Windows user home, forward- OR back-slash (sanitizePathString only rewrites
+    // the backslash form).
+    /\bC:\/Users\/[^/\s]+/i,
+    // A `~`-rooted home path (personal/local).
+    /(?:^|\s)~\/[^\s]+/,
+    // Inline `key: value` / `key=value` secrets the keyed redactor misses in free
+    // text (it keys on config OBJECT keys, not prose).
+    /\b(?:api[_-]?key|secret|token|password|passwd|pwd|client[_-]?secret|access[_-]?key)\b\s*[:=]\s*\S+/i,
+    // Local / private endpoints — environment-specific, not a shared truth.
+    /\b(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::\d+)?\b/i,
+    /\b(?:10|127)\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,
+    /\b192\.168\.\d{1,3}\.\d{1,3}\b/,
+    /\b172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}\b/,
+];
+
+export function hasShareabilitySensitiveText(text: string): boolean {
+    try {
+        if (sanitizeDiagnosticText(text) !== text) return true;
+        return SHAREABILITY_SENSITIVE_PATTERNS.some((pattern) => pattern.test(text));
+    } catch {
+        return true;
+    }
+}
+
+export function sanitizeConfigValue(value: unknown, keyPath: string[] = []): unknown {
+    const key = keyPath.at(-1) ?? "";
+    if (key && isSecretKey(key)) {
+        return `<REDACTED:${redactionTypeForKey(key)}>`;
+    }
+    if (typeof value === "string") return sanitizeDiagnosticText(value);
+    if (Array.isArray(value)) {
+        return value.map((entry, index) => sanitizeConfigValue(entry, [...keyPath, String(index)]));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(
+            Object.entries(value).map(([entryKey, entry]) => [
+                entryKey,
+                sanitizeConfigValue(entry, [...keyPath, entryKey]),
+            ]),
+        );
+    }
+    return value;
+}

package/src/shared/resolve-fallbacks.ts

@@ -64,3 +64,17 @@ export function parseProviderModel(spec: string): { providerID: string; modelID:
         modelID: spec.slice(slash + 1).trim(),
     };
 }
+
+/**
+ * Build the `{ model: { providerID, modelID } }` fragment for an OpenCode prompt
+ * body from a `provider/model` spec string, or `{}` when the spec is absent or
+ * unparseable (the session falls back to its default model). Spread into a
+ * `client.session.prompt` body.
+ */
+export function modelBodyField(spec: string | undefined): {
+    model?: { providerID: string; modelID: string };
+} {
+    if (!spec) return {};
+    const parsed = parseProviderModel(spec);
+    return parsed ? { model: parsed } : {};
+}

package/src/shared/rpc-server.ts

@@ -1,9 +1,11 @@
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import {
+    chmodSync,
     mkdirSync,
     readdirSync,
     readFileSync,
     renameSync,
+    rmSync,
     unlinkSync,
     writeFileSync,
 } from "node:fs";
@@ -85,7 +87,22 @@ export class MagicContextRpcServer {
                     // file 0o600. renameSync preserves the tmp file's mode, so
                     // the 0o600 on the write covers the final file.
                     mkdirSync(dir, { recursive: true, mode: 0o700 });
+                    // mkdirSync's mode only applies on CREATION — a dir left by an
+                    // older build (or default 0o755 umask) keeps its loose perms, so
+                    // chmod it defensively so the bearer token isn't world-readable.
+                    try {
+                        chmodSync(dir, 0o700);
+                    } catch {
+                        // best-effort
+                    }
                     const tmpPath = `${this.portFilePath}.tmp`;
+                    // A stale tmp from a crashed write could exist with loose perms;
+                    // writeFileSync's mode only applies on create, so remove it first.
+                    try {
+                        rmSync(tmpPath, { force: true });
+                    } catch {
+                        // best-effort
+                    }
                     writeFileSync(
                         tmpPath,
                         JSON.stringify({
@@ -97,6 +114,13 @@ export class MagicContextRpcServer {
                         { encoding: "utf-8", mode: 0o600 },
                     );
                     renameSync(tmpPath, this.portFilePath);
+                    // renameSync preserves the tmp's mode, but chmod the final path
+                    // defensively in case the token file pre-existed with loose perms.
+                    try {
+                        chmodSync(this.portFilePath, 0o600);
+                    } catch {
+                        // best-effort
+                    }
                     log(`[rpc] server listening on 127.0.0.1:${this.port}`);
                 } catch (err) {
                     log(`[rpc] failed to write port file: ${err}`);

package/src/shared/rpc-types.ts

@@ -121,6 +121,8 @@ export interface StatusDetail extends SidebarSnapshot {
     historyBlockTokens: number;
     compressionBudget: number | null;
     compressionUsage: string | null;
+    /** Effective configured toast duration in ms after config resolution. */
+    toastDurationMs: number;
 }
 
 /** Embedding coverage for `/ctx-embed` status (mirrors getEmbeddingCoverageStatus). */

package/src/shared/subagent-runner.ts

@@ -155,9 +155,9 @@ export type SubagentProgressEvent =
  * Fields:
  * - `ok`: true iff the child produced a final assistant message.
  * - `assistantText`: concatenated text content from the final assistant
- *   message, with leading/trailing whitespace trimmed. Empty string if the
- *   child finished but produced no text (rare — usually means the model
- *   only emitted tool calls and we didn't follow up).
+ *   message, with leading/trailing whitespace trimmed. Empty assistant text is
+ *   reported as `ok: false, reason: "no_assistant"` so callers can try fallback
+ *   models instead of accepting an unusable success.
  * - `reason`: failure category, one of:
  *     - `"timeout"`: hit `timeoutMs` before the child finished
  *     - `"abort"`: caller's `signal` was triggered
@@ -180,6 +180,15 @@ export type SubagentRunResult =
           ok: true;
           assistantText: string;
           durationMs: number;
+          /**
+           * Number of tool invocations the agent made during the run. Pi reports
+           * this so callers that gate on "did the agent actually investigate vs
+           * just paraphrase" (refresh-primers' grounding gate) work on Pi, whose
+           * facade otherwise surfaces only the final assistant text. OpenCode
+           * leaves it undefined — its callers read tool-call parts straight off
+           * the real session messages.
+           */
+          toolCallCount?: number;
           meta?: Record<string, unknown>;
       }
     | {

package/src/shared/tui-config.test.ts

@@ -0,0 +1,106 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const roots: string[] = [];
+const prevConfigDir = process.env.OPENCODE_CONFIG_DIR;
+
+afterEach(() => {
+    if (prevConfigDir === undefined) delete process.env.OPENCODE_CONFIG_DIR;
+    else process.env.OPENCODE_CONFIG_DIR = prevConfigDir;
+    for (const root of roots.splice(0)) {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+describe("ensureTuiPluginEntry", () => {
+    it("preserves tuple dev-path plugin entry and does not add @latest", async () => {
+        const root = mkdtempSync(join(tmpdir(), "mc-tui-"));
+        roots.push(root);
+        process.env.OPENCODE_CONFIG_DIR = root;
+        const devPath = "/Work/magic-context/packages/plugin";
+        const tuiPath = join(root, "tui.json");
+        writeFileSync(
+            tuiPath,
+            `${JSON.stringify({ plugin: [[devPath, { sidebar: true }], "other-plugin"] }, null, 2)}\n`,
+        );
+
+        const { ensureTuiPluginEntry } = await import("./tui-config");
+        const changed = ensureTuiPluginEntry();
+        expect(changed).toBe(false);
+        const parsed = JSON.parse(readFileSync(tuiPath, "utf-8")) as { plugin: unknown[] };
+        expect(parsed.plugin).toHaveLength(2);
+        expect(Array.isArray(parsed.plugin[0])).toBe(true);
+        expect((parsed.plugin[0] as unknown[])[0]).toBe(devPath);
+        expect(parsed.plugin[1]).toBe("other-plugin");
+        expect(existsSync(`${tuiPath}.tmp`)).toBe(false);
+    });
+
+    it("upgrades bare npm name to @latest while preserving tuple options", async () => {
+        const root = mkdtempSync(join(tmpdir(), "mc-tui-npm-"));
+        roots.push(root);
+        process.env.OPENCODE_CONFIG_DIR = root;
+        const tuiPath = join(root, "tui.json");
+        writeFileSync(
+            tuiPath,
+            `${JSON.stringify(
+                {
+                    plugin: [["@wolfx/opencode-magic-context", { enabled: true }]],
+                },
+                null,
+                2,
+            )}\n`,
+        );
+
+        const { ensureTuiPluginEntry } = await import("./tui-config");
+        expect(ensureTuiPluginEntry()).toBe(true);
+        const parsed = JSON.parse(readFileSync(tuiPath, "utf-8")) as { plugin: unknown[] };
+        const entry = parsed.plugin[0] as unknown[];
+        expect(entry[0]).toBe("@wolfx/opencode-magic-context@latest");
+        expect(entry[1]).toEqual({ enabled: true });
+    });
+
+    it("creates tui.jsonc (not tui.json) on a fresh install", async () => {
+        const root = mkdtempSync(join(tmpdir(), "mc-tui-fresh-"));
+        roots.push(root);
+        process.env.OPENCODE_CONFIG_DIR = root;
+
+        const { ensureTuiPluginEntry } = await import("./tui-config");
+        expect(ensureTuiPluginEntry()).toBe(true);
+
+        // The new file must be tui.jsonc so a tui.json stub never ends up
+        // sitting next to a tui.jsonc the user writes later (#176).
+        expect(existsSync(join(root, "tui.jsonc"))).toBe(true);
+        expect(existsSync(join(root, "tui.json"))).toBe(false);
+        const parsed = JSON.parse(readFileSync(join(root, "tui.jsonc"), "utf-8")) as {
+            plugin: unknown[];
+        };
+        expect(parsed.plugin).toContain("@wolfx/opencode-magic-context@latest");
+    });
+
+    it("writes into the existing tui.jsonc when both files exist", async () => {
+        const root = mkdtempSync(join(tmpdir(), "mc-tui-both-"));
+        roots.push(root);
+        process.env.OPENCODE_CONFIG_DIR = root;
+        // A real user config in tui.jsonc plus a leftover empty tui.json.
+        writeFileSync(
+            join(root, "tui.jsonc"),
+            `${JSON.stringify({ keybinds: { x: "y" } }, null, 2)}\n`,
+        );
+        writeFileSync(join(root, "tui.json"), "{}\n");
+
+        const { ensureTuiPluginEntry } = await import("./tui-config");
+        expect(ensureTuiPluginEntry()).toBe(true);
+
+        // The plugin entry must land in tui.jsonc (higher precedence), and the
+        // user's keybinds must survive; tui.json must be left untouched.
+        const jsonc = JSON.parse(readFileSync(join(root, "tui.jsonc"), "utf-8")) as {
+            plugin: unknown[];
+            keybinds: Record<string, string>;
+        };
+        expect(jsonc.plugin).toContain("@wolfx/opencode-magic-context@latest");
+        expect(jsonc.keybinds).toEqual({ x: "y" });
+        expect(readFileSync(join(root, "tui.json"), "utf-8")).toBe("{}\n");
+    });
+});

package/src/shared/tui-config.ts

@@ -3,7 +3,15 @@
  * Called from the server plugin at startup so the TUI sidebar loads on next restart.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+    chmodSync,
+    existsSync,
+    mkdirSync,
+    readFileSync,
+    renameSync,
+    statSync,
+    writeFileSync,
+} from "node:fs";
 import { dirname, join } from "node:path";
 import { parse, stringify } from "comment-json";
 import { log } from "./logger";
@@ -12,27 +20,41 @@ import { getOpenCodeConfigPaths } from "./opencode-config-dir";
 const PLUGIN_NAME = "@wolfx/opencode-magic-context";
 const PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 
-/**
- * Detect whether a tui.json plugin entry already references magic-context, in
- * any form. Covers:
- *   - Bare npm name: "@wolfx/opencode-magic-context"
- *   - Versioned npm: "@wolfx/opencode-magic-context@latest" / "@0.15.7" / etc.
- *   - Local dev directory path (absolute or relative): ".../magic-context"
- *     or ".../magic-context/packages/plugin"
- *   - file:// URLs pointing at the same paths
- *   - Tarball paths ending in opencode-magic-context-*.tgz
- *
- * Without the path/URL detection, doctor/setup auto-injection adds the npm
- * @latest entry on top of an existing dev path, double-loading the plugin.
- */
-function isMagicContextEntry(entry: string): boolean {
-    if (!entry) return false;
-    if (entry === PLUGIN_NAME) return true;
-    if (entry.startsWith(`${PLUGIN_NAME}@`)) return true;
-    // Local directory paths: match anywhere in the string so the setup pattern
-    // (dir-only, dir + /packages/plugin, file:// + either) all qualify.
-    if (entry.includes("opencode-magic-context")) return true;
-    return false;
+function pluginEntryId(entry: unknown): string {
+    if (typeof entry === "string") return entry;
+    if (Array.isArray(entry) && typeof entry[0] === "string") return entry[0];
+    return "";
+}
+
+function isLocalMagicContextDevEntry(entry: unknown): boolean {
+    const id = pluginEntryId(entry);
+    if (!id) return false;
+    if (id === PLUGIN_NAME || id.startsWith(`${PLUGIN_NAME}@`)) return false;
+    const isPath =
+        id.startsWith("file://") || id.startsWith("/") || id.startsWith("./") || id.includes("\\");
+    if (!isPath) return false;
+    return id.includes("opencode-magic-context") || id.includes("magic-context");
+}
+
+function isMagicContextPluginEntry(entry: unknown): boolean {
+    const id = pluginEntryId(entry);
+    if (!id) return false;
+    if (id === PLUGIN_NAME || id.startsWith(`${PLUGIN_NAME}@`)) return true;
+    return isLocalMagicContextDevEntry(entry);
+}
+
+function writeTuiConfigAtomic(configPath: string, config: Record<string, unknown>): void {
+    const body = `${stringify(config, null, 2)}\n`;
+    const tmpPath = `${configPath}.tmp`;
+    writeFileSync(tmpPath, body);
+    try {
+        if (statSync(configPath, { throwIfNoEntry: false })?.isFile()) {
+            chmodSync(tmpPath, statSync(configPath).mode & 0o777);
+        }
+    } catch {
+        /* new file */
+    }
+    renameSync(tmpPath, configPath);
 }
 
 function resolveTuiConfigPath(): string {
@@ -40,9 +62,16 @@ function resolveTuiConfigPath(): string {
     const jsoncPath = join(configDir, "tui.jsonc");
     const jsonPath = join(configDir, "tui.json");
 
+    // OpenCode loads BOTH tui.json and tui.jsonc and merges them (tui.json first,
+    // tui.jsonc second, so .jsonc wins overlapping keys; plugin origins are
+    // deduped). So an existing tui.jsonc is the higher-precedence, user-facing
+    // file — write into it when present. Otherwise update an existing tui.json.
+    // For a fresh install create tui.jsonc, not tui.json: it lets the user add
+    // comments later and avoids leaving a second, lower-precedence config file
+    // alongside a tui.jsonc they create afterward (#176).
     if (existsSync(jsoncPath)) return jsoncPath;
     if (existsSync(jsonPath)) return jsonPath;
-    return jsonPath; // default: create tui.json
+    return jsoncPath;
 }
 
 /**
@@ -59,35 +88,41 @@ export function ensureTuiPluginEntry(): boolean {
             config = (parse(raw) as Record<string, unknown>) ?? {};
         }
 
-        const plugins = Array.isArray(config.plugin)
-            ? config.plugin.filter((p): p is string => typeof p === "string")
-            : [];
+        const plugins: unknown[] = Array.isArray(config.plugin) ? [...config.plugin] : [];
 
-        const existingIdx = plugins.findIndex(isMagicContextEntry);
+        const existingIdx = plugins.findIndex(isMagicContextPluginEntry);
         if (existingIdx >= 0) {
             const existing = plugins[existingIdx];
-            if (existing === PLUGIN_ENTRY) {
-                return false; // Already @latest
+            if (isLocalMagicContextDevEntry(existing)) {
+                return false;
+            }
+            const id = pluginEntryId(existing);
+            if (id === PLUGIN_ENTRY) {
+                return false;
             }
-            // Only upgrade the bare versionless npm name to @latest.
-            // Pinned versions (e.g. @0.8.10), local dev paths
-            // (~/Work/OSS/magic-context/packages/plugin), and
-            // file:// URLs are all left as-is — the user chose them
-            // intentionally and overwriting their dev-loop entry would
-            // either double-load the plugin (npm + dev) or replace
-            // their working directory pointer.
-            if (existing === PLUGIN_NAME) {
-                plugins[existingIdx] = PLUGIN_ENTRY;
+            if (id === PLUGIN_NAME) {
+                if (Array.isArray(existing) && existing.length >= 1) {
+                    const replacement = [...existing];
+                    replacement[0] = PLUGIN_ENTRY;
+                    plugins[existingIdx] = replacement;
+                } else {
+                    plugins[existingIdx] = PLUGIN_ENTRY;
+                }
             } else {
                 return false;
             }
         } else {
-            plugins.push(PLUGIN_ENTRY);
+            const hasDev = plugins.some(isLocalMagicContextDevEntry);
+            if (!hasDev) {
+                plugins.push(PLUGIN_ENTRY);
+            } else {
+                return false;
+            }
         }
         config.plugin = plugins;
 
         mkdirSync(dirname(configPath), { recursive: true });
-        writeFileSync(configPath, `${stringify(config, null, 2)}\n`);
+        writeTuiConfigAtomic(configPath, config);
         log(`[magic-context] updated TUI plugin entry in ${configPath}`);
         return true;
     } catch (error) {

package/src/tui/data/context-db.ts

@@ -205,6 +205,7 @@ export async function loadStatusDetail(
         historyBlockTokens: 0,
         compressionBudget: null,
         compressionUsage: null,
+        toastDurationMs: 5000,
     };
 
     if (!rpcClient) return emptyDetail;
@@ -299,6 +300,17 @@ export async function dismissUpgradeReminder(sessionId: string): Promise<boolean
     }
 }
 
+/** Resolve global toast duration from server config via RPC. */
+export async function loadToastDurationMs(): Promise<number> {
+    if (!rpcClient) return 5000;
+    try {
+        const result = await rpcClient.call<{ toastDurationMs?: number }>("toast-duration", {});
+        return typeof result.toastDurationMs === "number" ? result.toastDurationMs : 5000;
+    } catch {
+        return 5000;
+    }
+}
+
 export interface TuiMessage {
     id: number;
     type: string;