@diffexai/diffex 0.2.2 → 0.2.4

package/dist/core/extensions/loader.js

@@ -25,9 +25,9 @@ import * as _bundledDiffexCodingAgent from "../../index.js";
 import { resolvePath } from "../../utils/paths.js";
 import { readDiffexManifest } from "../diffex-manifest.js";
 import { createEventBus } from "../event-bus.js";
-import { execCommand } from "../exec.js";
-import { createSyntheticSourceInfo } from "../source-info.js";
 import { time } from "../timings.js";
+import { createExtension, createExtensionAPI, createExtensionRuntime } from "./factory.js";
+export { createExtensionRuntime, loadExtensionFromFactory } from "./factory.js";
 /** Modules available to extensions via virtualModules (for compiled Bun binary) */
 const VIRTUAL_MODULES = {
     typebox: _bundledTypebox,
@@ -112,223 +112,6 @@ function useExtensionCacheCwd(cwd) {
     extensionCacheCwd = resolvedCwd;
     return { cwd: resolvedCwd, generation: extensionCacheGeneration };
 }
-/**
- * Create a runtime with throwing stubs for action methods.
- * Runner.bindCore() replaces these with real implementations.
- */
-export function createExtensionRuntime() {
-    const notInitialized = () => {
-        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
-    };
-    const state = {};
-    const eventBusUnsubscribers = new Set();
-    const assertActive = () => {
-        if (state.staleMessage) {
-            throw new Error(state.staleMessage);
-        }
-    };
-    const runtime = {
-        sendMessage: notInitialized,
-        sendUserMessage: notInitialized,
-        appendEntry: notInitialized,
-        setSessionName: notInitialized,
-        getSessionName: notInitialized,
-        setLabel: notInitialized,
-        getActiveTools: notInitialized,
-        getAllTools: notInitialized,
-        setActiveTools: notInitialized,
-        // registerTool() is valid during extension load; refresh is only needed post-bind.
-        refreshTools: () => { },
-        getCommands: notInitialized,
-        setModel: () => Promise.reject(new Error("Extension runtime not initialized")),
-        getThinkingLevel: notInitialized,
-        setThinkingLevel: notInitialized,
-        flagValues: new Map(),
-        pendingProviderRegistrations: [],
-        pendingNativeProviderRegistrations: [],
-        assertActive,
-        invalidate: (message) => {
-            if (state.staleMessage)
-                return;
-            state.staleMessage =
-                message ??
-                    "This extension ctx is stale after session replacement or reload. Do not use a captured Diffex API or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
-            for (const unsubscribe of eventBusUnsubscribers)
-                unsubscribe();
-            eventBusUnsubscribers.clear();
-        },
-        trackEventBusSubscription: (unsubscribe) => {
-            let active = true;
-            const trackedUnsubscribe = () => {
-                if (!active)
-                    return;
-                active = false;
-                eventBusUnsubscribers.delete(trackedUnsubscribe);
-                unsubscribe();
-            };
-            eventBusUnsubscribers.add(trackedUnsubscribe);
-            return trackedUnsubscribe;
-        },
-        // Pre-bind: queue registrations so bindCore() can flush them once the
-        // model registry is available. bindCore() replaces both with direct calls.
-        registerProvider: (name, config, extensionPath = "<unknown>") => {
-            runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
-        },
-        registerNativeProvider: (provider, extensionPath = "<unknown>") => {
-            runtime.pendingNativeProviderRegistrations.push({ provider, extensionPath });
-        },
-        unregisterProvider: (name) => {
-            runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter((r) => r.name !== name);
-            runtime.pendingNativeProviderRegistrations = runtime.pendingNativeProviderRegistrations.filter((r) => r.provider.id !== name);
-        },
-    };
-    return runtime;
-}
-/**
- * Create the ExtensionAPI for an extension.
- * Registration methods write to the extension object.
- * Action methods delegate to the shared runtime.
- */
-function createExtensionAPI(extension, runtime, cwd, eventBus) {
-    const api = {
-        // Registration methods - write to extension
-        on(event, handler) {
-            runtime.assertActive();
-            const list = extension.handlers.get(event) ?? [];
-            list.push(handler);
-            extension.handlers.set(event, list);
-        },
-        registerTool(tool) {
-            runtime.assertActive();
-            extension.tools.set(tool.name, {
-                definition: tool,
-                sourceInfo: extension.sourceInfo,
-            });
-            runtime.refreshTools();
-        },
-        registerCommand(name, options) {
-            runtime.assertActive();
-            extension.commands.set(name, {
-                name,
-                sourceInfo: extension.sourceInfo,
-                ...options,
-            });
-        },
-        registerShortcut(shortcut, options) {
-            runtime.assertActive();
-            extension.shortcuts.set(shortcut, { shortcut, extensionPath: extension.path, ...options });
-        },
-        registerFlag(name, options) {
-            runtime.assertActive();
-            extension.flags.set(name, { name, extensionPath: extension.path, ...options });
-            if (options.default !== undefined && !runtime.flagValues.has(name)) {
-                runtime.flagValues.set(name, options.default);
-            }
-        },
-        registerMessageRenderer(customType, renderer) {
-            runtime.assertActive();
-            extension.messageRenderers.set(customType, renderer);
-        },
-        registerMarkdownTransformer(transformer) {
-            runtime.assertActive();
-            extension.markdownTransformer = transformer;
-        },
-        registerEntryRenderer(customType, renderer) {
-            runtime.assertActive();
-            extension.entryRenderers ??= new Map();
-            extension.entryRenderers.set(customType, renderer);
-        },
-        // Flag access - checks extension registered it, reads from runtime
-        getFlag(name) {
-            runtime.assertActive();
-            if (!extension.flags.has(name))
-                return undefined;
-            return runtime.flagValues.get(name);
-        },
-        // Action methods - delegate to shared runtime
-        sendMessage(message, options) {
-            runtime.assertActive();
-            runtime.sendMessage(message, options);
-        },
-        sendUserMessage(content, options) {
-            runtime.assertActive();
-            runtime.sendUserMessage(content, options);
-        },
-        appendEntry(customType, data) {
-            runtime.assertActive();
-            runtime.appendEntry(customType, data);
-        },
-        setSessionName(name) {
-            runtime.assertActive();
-            runtime.setSessionName(name);
-        },
-        getSessionName() {
-            runtime.assertActive();
-            return runtime.getSessionName();
-        },
-        setLabel(entryId, label) {
-            runtime.assertActive();
-            runtime.setLabel(entryId, label);
-        },
-        exec(command, args, options) {
-            runtime.assertActive();
-            return execCommand(command, args, options?.cwd ?? cwd, options);
-        },
-        getActiveTools() {
-            runtime.assertActive();
-            return runtime.getActiveTools();
-        },
-        getAllTools() {
-            runtime.assertActive();
-            return runtime.getAllTools();
-        },
-        setActiveTools(toolNames) {
-            runtime.assertActive();
-            runtime.setActiveTools(toolNames);
-        },
-        getCommands() {
-            runtime.assertActive();
-            return runtime.getCommands();
-        },
-        setModel(model) {
-            runtime.assertActive();
-            return runtime.setModel(model);
-        },
-        getThinkingLevel() {
-            runtime.assertActive();
-            return runtime.getThinkingLevel();
-        },
-        setThinkingLevel(level) {
-            runtime.assertActive();
-            runtime.setThinkingLevel(level);
-        },
-        registerProvider(providerOrName, config) {
-            runtime.assertActive();
-            if (typeof providerOrName === "string") {
-                if (!config)
-                    throw new Error("Provider config is required when registering by name");
-                runtime.registerProvider(providerOrName, config, extension.path);
-                return;
-            }
-            runtime.registerNativeProvider(providerOrName, extension.path);
-        },
-        unregisterProvider(name) {
-            runtime.assertActive();
-            runtime.unregisterProvider(name, extension.path);
-        },
-        events: {
-            emit(channel, data) {
-                runtime.assertActive();
-                eventBus.emit(channel, data);
-            },
-            on(channel, handler) {
-                runtime.assertActive();
-                return runtime.trackEventBusSubscription(eventBus.on(channel, handler));
-            },
-        },
-    };
-    return api;
-}
 function isCurrentCacheToken(cacheToken) {
     return (cacheToken !== undefined &&
         extensionCacheCwd === cacheToken.cwd &&
@@ -361,27 +144,6 @@ async function loadExtensionModule(extensionPath, cacheToken) {
     }
     return factory;
 }
-/**
- * Create an Extension object with empty collections.
- */
-function createExtension(extensionPath, resolvedPath) {
-    const source = extensionPath.startsWith("<") && extensionPath.endsWith(">")
-        ? extensionPath.slice(1, -1).split(":")[0] || "temporary"
-        : "local";
-    const baseDir = extensionPath.startsWith("<") ? undefined : path.dirname(resolvedPath);
-    return {
-        path: extensionPath,
-        resolvedPath,
-        sourceInfo: createSyntheticSourceInfo(extensionPath, { source, baseDir }),
-        handlers: new Map(),
-        tools: new Map(),
-        messageRenderers: new Map(),
-        entryRenderers: new Map(),
-        commands: new Map(),
-        flags: new Map(),
-        shortcuts: new Map(),
-    };
-}
 async function loadExtension(extensionPath, cwd, eventBus, runtime, cacheToken) {
     const resolvedPath = resolvePath(extensionPath, cwd, { normalizeUnicodeSpaces: true });
     try {
@@ -401,17 +163,6 @@ async function loadExtension(extensionPath, cwd, eventBus, runtime, cacheToken)
         return { extension: null, error: `Failed to load extension: ${message}` };
     }
 }
-/**
- * Create an Extension from an inline factory function.
- */
-export async function loadExtensionFromFactory(factory, cwd, eventBus, runtime, extensionPath = "<inline>") {
-    const extension = createExtension(extensionPath, extensionPath);
-    const resolvedCwd = resolvePath(cwd);
-    const api = createExtensionAPI(extension, runtime, resolvedCwd, eventBus);
-    await factory(api);
-    time(`${extensionPath} factory`, "extensions");
-    return extension;
-}
 /**
  * Load extensions from paths.
  */

package/dist/core/resource-loader.js

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import chalk from "chalk";
-import { CONFIG_DIR_NAME } from "../config.js";
+import { CONFIG_DIR_NAME, getPackageDir, IS_PRODUCTION_DISTRIBUTION } from "../config.js";
 import { loadThemeFromPath } from "../modes/interactive/theme/theme.js";
 import { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
 import { createEventBus } from "./event-bus.js";
@@ -83,8 +83,13 @@ export function loadProjectContextFiles(options) {
     const resolvedAgentDir = resolvePath(options.agentDir);
     const contextFiles = [];
     const seenPaths = new Set();
+    if (IS_PRODUCTION_DISTRIBUTION) {
+        const path = join(getPackageDir(), "dist", "AGENTS.md");
+        contextFiles.push({ path, content: readFileSync(path, "utf-8") });
+        seenPaths.add(path);
+    }
     const globalContext = loadContextFileFromDir(resolvedAgentDir);
-    if (globalContext) {
+    if (globalContext && !seenPaths.has(globalContext.path)) {
         contextFiles.push(globalContext);
         seenPaths.add(globalContext.path);
     }

package/dist/core/tools/subagents.js

@@ -104,6 +104,7 @@ export function createSpawnAgentTool(spawn, assertCanSpawn = () => { }) {
         label: "Spawn Agent",
         description: "Start an independent child agent asynchronously. The tool returns after acceptance, but the enclosing parent prompt remains active until coordinated child work is delivered.",
         promptGuidelines: [
+            "For broad research, audits, or implementation work with independent areas, use spawn_agent to delegate focused subtasks in parallel when available. Request file references and supporting evidence for research and audits, and assign clear, non-overlapping file ownership for implementation work.",
             "After spawning child agents, you may finish the current response. The session waits for the frozen child batch and automatically sends one hidden, name-sorted result message before the parent prompt settles.",
         ],
         parameters: spawnAgentSchema,

package/dist/main.js

@@ -4,7 +4,6 @@
  * This file handles CLI argument parsing and translates them into
  * createAgentSession() options. The SDK does the heavy lifting.
  */
-import { createInterface } from "node:readline";
 import { modelsAreEqual } from "@diffexai/diffex-ai";
 import chalk from "chalk";
 import { parseArgs, printHelp } from "./cli/args.js";
@@ -15,7 +14,7 @@ import { processFileArguments } from "./cli/file-processor.js";
 import { buildInitialMessage } from "./cli/initial-message.js";
 import { listModels } from "./cli/list-models.js";
 import { createProjectTrustContext } from "./cli/project-trust.js";
-import { selectSession } from "./cli/session-picker.js";
+import { applySessionName, createSessionManager, validateForkFlags, validateSessionIdFlags, } from "./cli/session-selection.js";
 import { shouldRunFirstTimeSetup, showFirstTimeSetup, showStartupSelector } from "./cli/startup-ui.js";
 import { APP_NAME, ENV_SESSION_DIR, expandTildePath, getAgentDir, getPackageDir, VERSION } from "./config.js";
 import { createAgentSessionRuntime, } from "./core/agent-session-runtime.js";
@@ -32,7 +31,7 @@ import { ModelRuntime } from "./core/model-runtime.js";
 import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
 import { resolveProjectTrusted } from "./core/project-trust.js";
 import { formatMissingSessionCwdPrompt, getMissingSessionCwdIssue, MissingSessionCwdError, } from "./core/session-cwd.js";
-import { assertValidSessionId, SessionManager } from "./core/session-manager.js";
+import { SessionManager } from "./core/session-manager.js";
 import { SettingsManager } from "./core/settings-manager.js";
 import { printTimings, resetTimings, time } from "./core/timings.js";
 import { hasTrustRequiringProjectResources, ProjectTrustStore } from "./core/trust-manager.js";
@@ -192,171 +191,6 @@ async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
         stdinContent,
     });
 }
-/**
- * Resolve a session argument to a file path.
- * If it looks like a path, use as-is. Otherwise try to match as session ID prefix.
- */
-async function findLocalSessionByExactId(sessionId, cwd, sessionDir) {
-    const localSessions = await SessionManager.list(cwd, sessionDir);
-    const localMatch = localSessions.find((s) => s.id === sessionId);
-    return localMatch ? { type: "local", path: localMatch.path } : undefined;
-}
-async function resolveSessionPath(sessionArg, cwd, sessionDir) {
-    // If it looks like a file path, resolve it before handing it to the session manager.
-    if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
-        return { type: "path", path: resolvePath(sessionArg, cwd) };
-    }
-    // Try to match as session ID in current project first
-    const localSessions = await SessionManager.list(cwd, sessionDir);
-    const localMatch = localSessions.find((s) => s.id === sessionArg) ?? localSessions.find((s) => s.id.startsWith(sessionArg));
-    if (localMatch) {
-        return { type: "local", path: localMatch.path };
-    }
-    // Try global search across all projects
-    const allSessions = await SessionManager.listAll(sessionDir);
-    const globalMatch = allSessions.find((s) => s.id === sessionArg) ?? allSessions.find((s) => s.id.startsWith(sessionArg));
-    if (globalMatch) {
-        return { type: "global", path: globalMatch.path, cwd: globalMatch.cwd };
-    }
-    // Not found anywhere
-    return { type: "not_found", arg: sessionArg };
-}
-/** Prompt user for yes/no confirmation */
-async function promptConfirm(message) {
-    return new Promise((resolve) => {
-        const rl = createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.question(`${message} [y/N] `, (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
-        });
-    });
-}
-function validateForkFlags(parsed) {
-    if (!parsed.fork)
-        return;
-    const conflictingFlags = [
-        parsed.session ? "--session" : undefined,
-        parsed.continue ? "--continue" : undefined,
-        parsed.resume ? "--resume" : undefined,
-        parsed.noSession ? "--no-session" : undefined,
-    ].filter((flag) => flag !== undefined);
-    if (conflictingFlags.length > 0) {
-        console.error(chalk.red(`Error: --fork cannot be combined with ${conflictingFlags.join(", ")}`));
-        process.exit(1);
-    }
-}
-function validateSessionIdFlags(parsed) {
-    if (parsed.sessionId === undefined)
-        return;
-    const conflictingFlags = [
-        parsed.session ? "--session" : undefined,
-        parsed.continue ? "--continue" : undefined,
-        parsed.resume ? "--resume" : undefined,
-    ].filter((flag) => flag !== undefined);
-    if (conflictingFlags.length > 0) {
-        console.error(chalk.red(`Error: --session-id cannot be combined with ${conflictingFlags.join(", ")}`));
-        process.exit(1);
-    }
-    try {
-        assertValidSessionId(parsed.sessionId);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red(`Error: ${message}`));
-        process.exit(1);
-    }
-}
-function openSessionOrExit(path, sessionDir) {
-    try {
-        return SessionManager.open(path, sessionDir);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red(`Error: ${message}`));
-        process.exit(1);
-    }
-}
-function forkSessionOrExit(sourcePath, cwd, sessionDir, sessionId) {
-    try {
-        return SessionManager.forkFrom(sourcePath, cwd, sessionDir, { id: sessionId });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red(`Error: ${message}`));
-        process.exit(1);
-    }
-}
-async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
-    if (parsed.noSession || parsed.help || parsed.listModels !== undefined) {
-        return SessionManager.inMemory(cwd, parsed.sessionId !== undefined ? { id: parsed.sessionId } : undefined);
-    }
-    if (parsed.fork) {
-        if (parsed.sessionId) {
-            const existingTarget = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
-            if (existingTarget) {
-                console.error(chalk.red(`Session already exists with id '${parsed.sessionId}'`));
-                process.exit(1);
-            }
-        }
-        const resolved = await resolveSessionPath(parsed.fork, cwd, sessionDir);
-        switch (resolved.type) {
-            case "path":
-            case "local":
-            case "global":
-                return forkSessionOrExit(resolved.path, cwd, sessionDir, parsed.sessionId);
-            case "not_found":
-                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
-                process.exit(1);
-        }
-    }
-    if (parsed.session) {
-        const resolved = await resolveSessionPath(parsed.session, cwd, sessionDir);
-        switch (resolved.type) {
-            case "path":
-            case "local":
-                return openSessionOrExit(resolved.path, sessionDir);
-            case "global": {
-                console.log(chalk.yellow(`Session found in different project: ${resolved.cwd}`));
-                const shouldFork = await promptConfirm("Fork this session into current directory?");
-                if (!shouldFork) {
-                    console.log(chalk.dim("Aborted."));
-                    process.exit(0);
-                }
-                return forkSessionOrExit(resolved.path, cwd, sessionDir);
-            }
-            case "not_found":
-                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
-                process.exit(1);
-        }
-    }
-    if (parsed.resume) {
-        try {
-            const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, sessionDir, onProgress), (onProgress) => SessionManager.listAll(sessionDir, onProgress), settingsManager);
-            if (!selectedPath) {
-                console.log(chalk.dim("No session selected"));
-                process.exit(0);
-            }
-            return SessionManager.open(selectedPath, sessionDir);
-        }
-        finally {
-            stopThemeWatcher();
-        }
-    }
-    if (parsed.continue) {
-        return SessionManager.continueRecent(cwd, sessionDir);
-    }
-    if (parsed.sessionId) {
-        const existingSession = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
-        if (existingSession) {
-            return SessionManager.open(existingSession.path, sessionDir);
-        }
-        console.error(chalk.yellow(`Warning: No project session found with id '${parsed.sessionId}'; creating a new session with that id.`));
-    }
-    return SessionManager.create(cwd, sessionDir, { id: parsed.sessionId });
-}
 function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRuntime, settingsManager) {
     const options = {};
     const diagnostics = [];
@@ -557,14 +391,7 @@ export async function main(args, options) {
             process.exit(1);
         }
     }
-    if (parsed.name !== undefined) {
-        const name = parsed.name.trim();
-        if (!name) {
-            console.error(chalk.red("Error: --name requires a non-empty value"));
-            process.exit(1);
-        }
-        sessionManager.appendSessionInfo(name);
-    }
+    applySessionName(parsed, sessionManager);
     const initialWorkspace = await resolveHarnessWorkspace(sessionManager.getCwd());
     const invocationTraceResult = await createInvocationTrace({
         agentDir: resolveEvolutionWorkspaceStateDirectory(agentDir, initialWorkspace.workspace),

package/dist/modes/interactive/interactive-mode.js

@@ -7,7 +7,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as TuiLayouts from "@diffexai/diffex-tui";
-import { CombinedAutocompleteProvider, Container, fuzzyFilter, getCapabilities, getGlyphs, hyperlink, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TuiAltScreen, TuiMainScreen, visibleWidth, } from "@diffexai/diffex-tui";
+import { CombinedAutocompleteProvider, Container, fuzzyFilter, getGlyphs, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TuiAltScreen, TuiMainScreen, visibleWidth, } from "@diffexai/diffex-tui";
 import chalk from "chalk";
 import { spawn, spawnSync } from "child_process";
 import { APP_NAME, APP_TITLE, CONFIG_DIR_NAME, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getShareViewerUrl, VERSION, } from "../../config.js";
@@ -149,7 +149,6 @@ const AUTH_TYPE_ORDER = { oauth: 0, api_key: 1 };
 const DIFFEX_ACCOUNT_LOGIN_ID = "diffex";
 const DIFFEX_ACCOUNT_SELECTOR_ID = "diffex-account";
 const DIFFEX_ACCOUNT_LOGIN_LABEL = "Sign in to Diffex";
-const DIFFEX_UPDATE_AVAILABLE_NOTIFICATION_ENABLED = false;
 function createFuzzyAutocompleteItems(items, prefix, getSearchText, toAutocompleteItem) {
     const filtered = fuzzyFilter(items, prefix, getSearchText);
     if (filtered.length === 0)
@@ -833,7 +832,7 @@ export class InteractiveMode {
         }
         // Start version check asynchronously
         checkForNewDiffexVersion(this.version).then((newRelease) => {
-            if (newRelease && DIFFEX_UPDATE_AVAILABLE_NOTIFICATION_ENABLED) {
+            if (newRelease) {
                 this.showNewVersionNotification(newRelease);
             }
         });
@@ -3934,25 +3933,9 @@ export class InteractiveMode {
         this.pendingUserDock = undefined;
         const action = theme.fg("accent", `${APP_NAME} update`);
         const updateInstruction = theme.fg("muted", `New version ${release.version} is available. Run `) + action;
-        const changelogUrl = "https://github.com/diffexai/diffex/blob/main/packages/coding-agent/CHANGELOG.md";
-        const changelogLink = getCapabilities().hyperlinks
-            ? hyperlink(theme.fg("accent", changelogUrl), changelogUrl)
-            : theme.fg("accent", changelogUrl);
-        const changelogLine = theme.fg("muted", "Changelog: ") + changelogLink;
-        const note = release.note?.trim();
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
         this.chatContainer.addChild(new Text(`${theme.bold(theme.fg("warning", "Update Available"))}\n${updateInstruction}`, 1, 0));
-        if (note) {
-            this.chatContainer.addChild(new Spacer(1));
-            this.chatContainer.addChild(new Markdown(note, 1, 0, this.getMarkdownThemeWithSettings(), {
-                color: (text) => theme.fg("muted", text),
-            }, {
-                tableStyle: "compact",
-            }));
-            this.chatContainer.addChild(new Spacer(1));
-        }
-        this.chatContainer.addChild(new Text(changelogLine, 1, 0));
         this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
         this.ui.requestRender();
     }

package/dist/node_modules/@diffexai/diffex-agent-core/distribution-components.json

@@ -1,8 +1,8 @@
 [
   {
     "name": "@diffexai/diffex-agent-core",
-    "version": "0.2.2",
-    "sourceCommit": "dbe80a9dfe730c776a99be1ea9c439fe6b3cc023",
+    "version": "0.2.4",
+    "sourceCommit": "f668f241cac464e993edd0d15ba1e57cd2cb8a32",
     "license": "Apache-2.0",
     "portions": "Diffex contributions; Pi-derived portions retain MIT terms in LICENSE",
     "notice": "LICENSE",
@@ -10,12 +10,12 @@
   },
   {
     "name": "@diffexai/diffex-ai",
-    "version": "^0.2.2",
+    "version": "^0.2.4",
     "distribution": "resolved separately by package manager; not bundled in this npm tarball"
   },
   {
     "name": "@diffexai/diffex-telemetry",
-    "version": "^0.2.2",
+    "version": "^0.2.4",
     "distribution": "resolved separately by package manager; not bundled in this npm tarball"
   },
   {

package/dist/node_modules/@diffexai/diffex-agent-core/distribution-files.json

@@ -1,5 +1,5 @@
 {
-  "sourceCommit": "dbe80a9dfe730c776a99be1ea9c439fe6b3cc023",
+  "sourceCommit": "f668f241cac464e993edd0d15ba1e57cd2cb8a32",
   "algorithm": "sha256",
   "files": [
     {

package/dist/node_modules/@diffexai/diffex-agent-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diffexai/diffex-agent-core",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "General-purpose agent with transport abstraction, state management, and attachment support",
   "type": "module",
   "main": "./dist/index.js",