@tenex-chat/backend 0.9.5 → 0.9.6

package/src/commands/agent/import/openclaw.ts

@@ -4,10 +4,11 @@ import { Command } from "commander";
 import chalk from "chalk";
 import { NDKPrivateKeySigner } from "@nostr-dev-kit/ndk";
 import { agentStorage, createStoredAgent } from "@/agents/AgentStorage";
+import { getAgentHomeDirectory } from "@/lib/agent-home";
 import { config as configService } from "@/services/ConfigService";
 import type { LLMConfiguration } from "@/services/config/types";
 import { detectOpenClawStateDir, readOpenClawAgents, convertModelFormat } from "./openclaw-reader";
-import { distillAgentIdentity } from "./openclaw-distiller";
+import { distillAgentIdentity, distillUserContext } from "./openclaw-distiller";
 import type { OpenClawAgent } from "./openclaw-reader";
 
 function toSlug(name: string): string {
@@ -18,23 +19,46 @@ function toSlug(name: string): string {
         .replace(/^-+|-+$/g, "");
 }
 
-async function createHomeDir(pubkey: string, workspacePath: string): Promise<string> {
-    const homeDir = configService.getConfigPath(`agents/${pubkey}`);
+interface CreateHomeDirOptions {
+    noSync?: boolean;
+}
+
+export async function createHomeDir(
+    pubkey: string,
+    workspacePath: string,
+    options: CreateHomeDirOptions = {},
+): Promise<string> {
+    const homeDir = getAgentHomeDirectory(pubkey);
     await fs.mkdir(homeDir, { recursive: true });
 
-    // Symlink MEMORY.md (dangling is ok — file may not exist yet)
-    const memoryMdTarget = path.join(workspacePath, "MEMORY.md");
-    const memoryMdLink = path.join(homeDir, "MEMORY.md");
-    await fs.rm(memoryMdLink, { force: true });
-    await fs.symlink(memoryMdTarget, memoryMdLink);
+    if (options.noSync) {
+        // Copy all workspace files into the home directory
+        await fs.cp(workspacePath, homeDir, { recursive: true });
+
+        const indexContent = `# Memory Files
 
-    // Symlink memory/ directory (dangling is ok)
-    const memoryDirTarget = path.join(workspacePath, "memory");
-    const memoryDirLink = path.join(homeDir, "memory");
-    await fs.rm(memoryDirLink, { force: true });
-    await fs.symlink(memoryDirTarget, memoryDirLink);
+This agent's memory was copied from an OpenClaw installation.
 
-    const indexContent = `# Memory Files
+- \`MEMORY.md\` — long-term curated memory (copied from OpenClaw)
+- \`memory/YYYY-MM-DD.md\` — daily session logs (copied from OpenClaw)
+
+Source: ${workspacePath}
+`;
+        await fs.writeFile(path.join(homeDir, "+INDEX.md"), indexContent, "utf-8");
+    } else {
+        // Symlink MEMORY.md (dangling is ok — file may not exist yet)
+        const memoryMdTarget = path.join(workspacePath, "MEMORY.md");
+        const memoryMdLink = path.join(homeDir, "MEMORY.md");
+        await fs.rm(memoryMdLink, { force: true });
+        await fs.symlink(memoryMdTarget, memoryMdLink);
+
+        // Symlink memory/ directory (dangling is ok)
+        const memoryDirTarget = path.join(workspacePath, "memory");
+        const memoryDirLink = path.join(homeDir, "memory");
+        await fs.rm(memoryDirLink, { force: true });
+        await fs.symlink(memoryDirTarget, memoryDirLink);
+
+        const indexContent = `# Memory Files
 
 This agent's memory is synced live from an OpenClaw installation.
 
@@ -43,16 +67,23 @@ This agent's memory is synced live from an OpenClaw installation.
 
 Source: ${workspacePath}
 `;
-    await fs.writeFile(path.join(homeDir, "+INDEX.md"), indexContent, "utf-8");
+        await fs.writeFile(path.join(homeDir, "+INDEX.md"), indexContent, "utf-8");
+    }
 
     return homeDir;
 }
 
-async function appendUserMdToGlobalPrompt(userMdContent: string): Promise<void> {
+async function appendUserMdToGlobalPrompt(
+    rawUserMd: string,
+    llmConfigs: LLMConfiguration[],
+): Promise<void> {
+    const distilled = await distillUserContext(rawUserMd, llmConfigs);
+    if (!distilled) return;
+
     const globalPath = configService.getGlobalPath();
     const existingConfig = await configService.loadTenexConfig(globalPath);
 
-    const userSection = `\n## About the User (imported from OpenClaw)\n\n${userMdContent.trim()}`;
+    const userSection = `\n## About the User (imported from OpenClaw)\n\n${distilled}`;
     const existingContent = existingConfig.globalSystemPrompt?.content ?? "";
     const newContent = existingContent ? `${existingContent}${userSection}` : userSection.trim();
 
@@ -66,11 +97,15 @@ async function appendUserMdToGlobalPrompt(userMdContent: string): Promise<void>
     await configService.saveGlobalConfig(newConfig);
 }
 
-async function importOneAgent(agent: OpenClawAgent, llmConfig: LLMConfiguration): Promise<void> {
+async function importOneAgent(
+    agent: OpenClawAgent,
+    llmConfigs: LLMConfiguration[],
+    options: { noSync?: boolean } = {},
+): Promise<void> {
     const tenexModel = convertModelFormat(agent.modelPrimary);
 
     console.log(chalk.blue(`\nDistilling identity for agent '${agent.id}'...`));
-    const identity = await distillAgentIdentity(agent.workspaceFiles, llmConfig);
+    const identity = await distillAgentIdentity(agent.workspaceFiles, llmConfigs);
 
     const slug = toSlug(identity.name) || agent.id;
 
@@ -96,21 +131,35 @@ async function importOneAgent(agent: OpenClawAgent, llmConfig: LLMConfiguration)
     });
 
     await agentStorage.saveAgent(storedAgent);
-    const homeDir = await createHomeDir(pubkey, agent.workspacePath);
+    const homeDir = await createHomeDir(pubkey, agent.workspacePath, { noSync: options.noSync });
 
     console.log(chalk.green(`  ✓ Imported: ${identity.name} (${slug})`));
     console.log(chalk.gray(`    Keypair:   ${pubkey}`));
     console.log(chalk.gray(`    Model:     ${tenexModel}`));
     console.log(chalk.gray(`    Home dir:  ${homeDir}`));
-    console.log(chalk.gray(`    Symlinks:  MEMORY.md, memory/`));
+    console.log(chalk.gray(`    Files:     ${options.noSync ? "copied" : "symlinked"} from ${agent.workspacePath}`));
+}
+
+function filterAgents(agents: OpenClawAgent[], slugs?: string): OpenClawAgent[] {
+    if (!slugs) return agents;
+    const allowed = slugs.split(",").map((s) => s.trim());
+    return agents.filter((a) => allowed.includes(a.id));
 }
 
 export const openclawImportCommand = new Command("openclaw")
     .description("Import agents from a local OpenClaw installation")
-    .action(async () => {
+    .option("--dry-run", "Preview what would be imported without making changes")
+    .option("--json", "Output as JSON array (implies --dry-run)")
+    .option("--no-sync", "Copy workspace files instead of symlinking them")
+    .option("--slugs <slugs>", "Comma-separated list of agent IDs to import (default: all)")
+    .action(async (options: { dryRun?: boolean; json?: boolean; noSync?: boolean; slugs?: string }) => {
         try {
             const stateDir = await detectOpenClawStateDir();
             if (!stateDir) {
+                if (options.json) {
+                    console.log("[]");
+                    return;
+                }
                 console.error(chalk.red("No OpenClaw installation detected."));
                 console.error(
                     chalk.gray(
@@ -121,23 +170,65 @@ export const openclawImportCommand = new Command("openclaw")
                 return;
             }
 
-            console.log(chalk.blue(`Found OpenClaw installation at: ${stateDir}`));
+            const allAgents = await readOpenClawAgents(stateDir);
+            const agents = filterAgents(allAgents, options.slugs);
 
-            const agents = await readOpenClawAgents(stateDir);
-            console.log(chalk.blue(`Found ${agents.length} agent(s) to import.`));
+            if (agents.length === 0) {
+                if (options.json) {
+                    console.log("[]");
+                } else {
+                    console.log(chalk.yellow("No matching OpenClaw agents found."));
+                }
+                return;
+            }
 
             await configService.loadConfig();
+            const llmConfigs = configService.getAllLLMConfigs();
+
+            if (options.dryRun || options.json) {
+                const previews = [];
+                for (const agent of agents) {
+                    const identity = await distillAgentIdentity(agent.workspaceFiles, llmConfigs);
+                    const slug = toSlug(identity.name) || agent.id;
+                    previews.push({
+                        id: agent.id,
+                        slug,
+                        model: convertModelFormat(agent.modelPrimary),
+                        ...identity,
+                    });
+                }
+
+                if (options.json) {
+                    console.log(JSON.stringify(previews, null, 2));
+                } else {
+                    console.log(chalk.blue(`Would import ${previews.length} agent(s):\n`));
+                    for (const p of previews) {
+                        console.log(chalk.green(`  ${p.slug}`) + chalk.gray(` (${p.name})`));
+                        console.log(chalk.gray(`    Role:         ${p.role}`));
+                        console.log(chalk.gray(`    Model:        ${p.model}`));
+                        console.log(chalk.gray(`    Description:  ${p.description}`));
+                        console.log(chalk.gray(`    Instructions: ${p.instructions.slice(0, 120)}...`));
+                    }
+                }
+                return;
+            }
+
+            if (!options.json) {
+                console.log(chalk.blue(`Found OpenClaw installation at: ${stateDir}`));
+                console.log(chalk.blue(`Found ${agents.length} agent(s) to import.`));
+            }
+
             await agentStorage.initialize();
 
-            const llmConfig = configService.getLLMConfig();
             let userMdProcessed = false;
 
             for (const agent of agents) {
-                await importOneAgent(agent, llmConfig);
+                await importOneAgent(agent, llmConfigs, { noSync: options.noSync });
 
                 if (!userMdProcessed && agent.workspaceFiles.user) {
-                    await appendUserMdToGlobalPrompt(agent.workspaceFiles.user);
-                    console.log(chalk.green("  ✓ USER.md appended to global system prompt"));
+                    console.log(chalk.blue(`\nDistilling user context from USER.md...`));
+                    await appendUserMdToGlobalPrompt(agent.workspaceFiles.user, llmConfigs);
+                    console.log(chalk.green("  ✓ USER.md distilled and appended to global system prompt"));
                     userMdProcessed = true;
                 }
             }

package/src/commands/agent/index.ts

@@ -1,6 +1,87 @@
 import { Command } from "commander";
+import chalk from "chalk";
+import { NDKPrivateKeySigner, NDKEvent } from "@nostr-dev-kit/ndk";
+import { agentStorage } from "@/agents/AgentStorage";
+import { installAgentFromNostr, installAgentFromNostrEvent } from "@/agents/agent-installer";
+import { initNDK } from "@/nostr/ndkClient";
 import { importCommand } from "./import/index";
 
+// ─── tenex agent add ─────────────────────────────────────────────────────────
+
+async function readStdin(): Promise<string> {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data.trim()));
+        process.stdin.on("error", reject);
+    });
+}
+
+async function addAgent(eventId: string | undefined): Promise<void> {
+    await agentStorage.initialize();
+
+    if (!process.stdin.isTTY) {
+        const raw = await readStdin();
+        const rawEvent = JSON.parse(raw);
+        const event = new NDKEvent(undefined, rawEvent);
+        const stored = await installAgentFromNostrEvent(event);
+        const pubkey = new NDKPrivateKeySigner(stored.nsec).pubkey;
+        console.log(chalk.green(`✓ Installed agent "${stored.name}" (${stored.slug})`));
+        console.log(chalk.gray(`  pubkey: ${pubkey}`));
+        return;
+    }
+
+    if (!eventId) {
+        console.error(chalk.red("Error: provide an event ID or pipe event JSON via stdin"));
+        process.exit(1);
+    }
+
+    await initNDK();
+    const stored = await installAgentFromNostr(eventId);
+    const pubkey = new NDKPrivateKeySigner(stored.nsec).pubkey;
+    console.log(chalk.green(`✓ Installed agent "${stored.name}" (${stored.slug})`));
+    console.log(chalk.gray(`  pubkey: ${pubkey}`));
+}
+
+// ─── tenex agent assign ─────────────────────────────────────────────────────
+
+async function assignAgent(slug: string, projectDTag: string): Promise<void> {
+    await agentStorage.initialize();
+
+    const agent = await agentStorage.getAgentBySlug(slug);
+    if (!agent) {
+        console.error(chalk.red(`Error: no agent found with slug "${slug}"`));
+        process.exit(1);
+    }
+
+    const pubkey = new NDKPrivateKeySigner(agent.nsec).pubkey;
+    await agentStorage.addAgentToProject(pubkey, projectDTag);
+
+    console.log(chalk.green(`✓ Assigned agent "${slug}" to project "${projectDTag}"`));
+}
+
+// ─── Command registration ────────────────────────────────────────────────────
+
+const addCommand = new Command("add")
+    .description("Install an agent from a Nostr event ID or stdin JSON")
+    .argument("[event-id]", "Nostr event ID of the agent definition")
+    .action(async (eventId: string | undefined) => {
+        await addAgent(eventId);
+    });
+
+const assignCommand = new Command("assign")
+    .description("Assign an existing agent to a project")
+    .argument("<slug>", "Agent slug")
+    .argument("<project-dtag>", "Project d-tag to assign the agent to")
+    .action(async (slug: string, projectDTag: string) => {
+        await assignAgent(slug, projectDTag);
+    });
+
 export const agentCommand = new Command("agent")
-    .description("Agent management commands")
-    .addCommand(importCommand);
+    .description("Manage TENEX agents")
+    .addCommand(importCommand)
+    .addCommand(addCommand)
+    .addCommand(assignCommand);

package/src/commands/setup/display.ts

@@ -0,0 +1,123 @@
+import chalk from "chalk";
+
+// Match Rust TUI's xterm-256 color scheme exactly
+const ACCENT = chalk.ansi256(214); // amber #FFC107
+const INFO = chalk.ansi256(117); // sky blue
+const SELECTED = chalk.ansi256(114); // bright green
+
+// Logo palette (xterm-256)
+const DARK = chalk.ansi256(130);
+const MID = chalk.ansi256(172);
+const BRIGHT = chalk.ansi256(220);
+const GLOW = chalk.ansi256(222);
+
+/**
+ * Print an onboarding step header with step number and color rule.
+ *
+ *   3/8  AI Providers
+ *   ─────────────────────────────────────────────
+ */
+export function step(number: number, total: number, title: string): void {
+    const rule = "─".repeat(45);
+    console.log();
+    console.log(`  ${ACCENT.bold(`${number}/${total}`)}  ${ACCENT.bold(title)}`);
+    console.log(`  ${ACCENT(chalk.dim(rule))}`);
+    console.log();
+}
+
+/**
+ * Print dim context/explanation text, 2-space indent.
+ */
+export function context(text: string): void {
+    for (const line of text.split("\n")) {
+        console.log(`  ${chalk.dim(line)}`);
+    }
+}
+
+/**
+ * Print a success message: ✓ text
+ */
+export function success(text: string): void {
+    console.log(`  ${chalk.green.bold("✓")} ${text}`);
+}
+
+/**
+ * Print a hint/tip with a colored arrow.
+ */
+export function hint(text: string): void {
+    console.log(`  ${ACCENT("→")} ${ACCENT(text)}`);
+}
+
+/**
+ * Print a blank line.
+ */
+export function blank(): void {
+    console.log();
+}
+
+/**
+ * Print the welcome banner — stippled Sierpinski triangle
+ * with "T E N E X" and tagline to the right.
+ * Matches the Rust TUI's logo.rs exactly.
+ */
+export function welcome(): void {
+    const art: Array<[string, typeof ACCENT]> = [
+        ["       •       ", GLOW],
+        ["      • •      ", BRIGHT],
+        ["    •     •    ", ACCENT],
+        ["   • • • • •   ", MID],
+        ["  • • • • • •  ", DARK],
+    ];
+
+    console.log();
+    for (let i = 0; i < art.length; i++) {
+        const [line, color] = art[i];
+        let row = "  ";
+        for (const ch of line) {
+            row += ch === " " ? " " : color.bold(ch);
+        }
+        if (i === 2) row += "  " + ACCENT.bold("T E N E X");
+        if (i === 3) row += "  " + chalk.bold("Your AI agent team, powered by Nostr.");
+        if (i === 4) row += "  " + chalk.dim("Let's get everything set up.");
+        process.stdout.write(row + "\n");
+    }
+    console.log();
+}
+
+/**
+ * Print the final setup summary banner.
+ */
+export function setupComplete(): void {
+    console.log();
+    console.log(`  ${ACCENT.bold("▲")} ${ACCENT.bold("Setup complete!")}`);
+    console.log();
+}
+
+/**
+ * Print a summary line for the final recap.
+ */
+export function summaryLine(label: string, value: string): void {
+    const paddedLabel = `${label}:`.padEnd(16);
+    console.log(`    ${INFO(paddedLabel)}${value}`);
+}
+
+/**
+ * Format a provider label with checkmark (for use in choices).
+ */
+export function providerCheck(text: string): string {
+    return `${SELECTED.bold("[✓]")} ${text}`;
+}
+
+/**
+ * Format a provider label with unchecked brackets (for use in choices).
+ */
+export function providerUncheck(text: string): string {
+    return `${chalk.dim("[ ]")} ${text}`;
+}
+
+/**
+ * Format a "Done" label in amber style.
+ */
+export function doneLabel(): string {
+    return ACCENT.bold("  Done");
+}

package/src/commands/setup/embed.ts

@@ -5,7 +5,8 @@ import {
     EmbeddingProviderFactory,
 } from "@/services/rag/EmbeddingProviderFactory";
 import { config as configService } from "@/services/ConfigService";
-import { logger } from "@/utils/logger";
+import { inquirerTheme } from "@/utils/cli-theme";
+import chalk from "chalk";
 import { Command } from "commander";
 import inquirer from "inquirer";
 
@@ -61,9 +62,7 @@ export const embedCommand = new Command("embed")
             if (scope === "project") {
                 // Check if we're in a TENEX project
                 if (!(await fileSystem.directoryExists(baseDir))) {
-                    logger.error(
-                        "No .tenex directory found. Make sure you're in a TENEX project directory."
-                    );
+                    console.log(chalk.red("❌ No .tenex directory found. Make sure you're in a TENEX project directory."));
                     process.exitCode = 1;
                     return;
                 }
@@ -81,9 +80,7 @@ export const embedCommand = new Command("embed")
             // Load configured providers from providers.json
             const providersConfig = await configService.loadTenexProviders(configService.getGlobalPath());
             if (Object.keys(providersConfig.providers).length === 0) {
-                logger.error(
-                    "No providers configured. Run `tenex setup providers` before configuring embeddings."
-                );
+                console.log(chalk.red("❌ No providers configured. Run `tenex setup providers` before configuring embeddings."));
                 process.exitCode = 1;
                 return;
             }
@@ -112,6 +109,7 @@ export const embedCommand = new Command("embed")
                     message: "Select embedding provider:",
                     choices: providerChoices,
                     default: existing?.provider || "local",
+                    theme: inquirerTheme,
                 },
             ]);
 
@@ -136,6 +134,7 @@ export const embedCommand = new Command("embed")
                         message: `Select ${displayName} embedding model:`,
                         choices: modelChoices,
                         default: existing?.provider === provider ? existing?.model : modelChoices[0]?.value,
+                        theme: inquirerTheme,
                     },
                 ]);
 
@@ -145,6 +144,7 @@ export const embedCommand = new Command("embed")
                             type: "input",
                             name: "customModel",
                             message: "Enter model ID:",
+                            theme: inquirerTheme,
                             validate: (input: string) =>
                                 input.trim().length > 0 || "Model ID cannot be empty",
                         },
@@ -160,6 +160,7 @@ export const embedCommand = new Command("embed")
                         type: "select",
                         name: "model",
                         message: "Select local embedding model:",
+                        theme: inquirerTheme,
                         choices: [
                             {
                                 name: "all-MiniLM-L6-v2 (default, fast, good for general use)",
@@ -189,6 +190,7 @@ export const embedCommand = new Command("embed")
                             name: "customModel",
                             message:
                                 "Enter HuggingFace model ID (e.g., sentence-transformers/all-MiniLM-L6-v2):",
+                            theme: inquirerTheme,
                             validate: (input: string) =>
                                 input.trim().length > 0 || "Model ID cannot be empty",
                         },
@@ -210,11 +212,9 @@ export const embedCommand = new Command("embed")
                 projectPath: scope === "project" ? projectPath : undefined,
             });
 
-            logger.info(
-                `✅ Embedding configuration saved to ${scope} config\n` +
-                    `   Provider: ${provider}\n` +
-                    `   Model: ${model}`
-            );
+            console.log("\n" + chalk.green("✓") + chalk.bold(` Embedding configuration saved to ${scope} config`));
+            console.log(chalk.gray(`   Provider: ${provider}`));
+            console.log(chalk.gray(`   Model: ${model}`));
         } catch (error: unknown) {
             // Handle SIGINT (Ctrl+C) gracefully
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -222,7 +222,7 @@ export const embedCommand = new Command("embed")
                 return;
             }
 
-            logger.error(`Failed to configure embedding model: ${error}`);
+            console.log(chalk.red(`❌ Failed to configure embedding model: ${error}`));
             process.exitCode = 1;
         }
     });

package/src/commands/setup/global-system-prompt.ts

@@ -1,6 +1,8 @@
 import * as fileSystem from "@/lib/fs";
 import { config as configService } from "@/services/ConfigService";
+import { amber, amberBold } from "@/utils/cli-theme";
 import { logger } from "@/utils/logger";
+import chalk from "chalk";
 import { Command } from "commander";
 import { spawn } from "node:child_process";
 import * as fs from "node:fs/promises";
@@ -88,12 +90,12 @@ export const globalSystemPromptCommand = new Command("global-system-prompt")
                 const enabled = existingConfig.globalSystemPrompt?.enabled !== false;
 
                 if (!content || content.trim().length === 0) {
-                    logger.info("No global system prompt configured.");
+                    console.log(chalk.gray("No global system prompt configured."));
                 } else {
-                    logger.info(`Global System Prompt (${enabled ? "enabled" : "disabled"}):`);
-                    logger.info("─".repeat(50));
+                    console.log(amberBold(`Global System Prompt (${enabled ? "enabled" : "disabled"}):`));
+                    console.log(amber("─".repeat(50)));
                     console.log(content);
-                    logger.info("─".repeat(50));
+                    console.log(amber("─".repeat(50)));
                 }
                 return;
             }
@@ -108,7 +110,7 @@ export const globalSystemPromptCommand = new Command("global-system-prompt")
                     },
                 };
                 await configService.saveGlobalConfig(newConfig);
-                logger.info("Global system prompt disabled.");
+                console.log(chalk.green("✓") + chalk.bold(" Global system prompt disabled."));
                 return;
             }
 
@@ -122,7 +124,7 @@ export const globalSystemPromptCommand = new Command("global-system-prompt")
                     },
                 };
                 await configService.saveGlobalConfig(newConfig);
-                logger.info("Global system prompt enabled.");
+                console.log(chalk.green("✓") + chalk.bold(" Global system prompt enabled."));
                 return;
             }
 
@@ -157,10 +159,8 @@ ${CONTENT_DELIMITER}
 
             await fs.writeFile(tempFile, templateContent, "utf-8");
 
-            logger.info(
-                "Opening editor to configure global system prompt...\n" +
-                    `(Using editor: ${getEditor()})\n`
-            );
+            console.log(amberBold("Opening editor to configure global system prompt..."));
+            console.log(chalk.gray(`(Using editor: ${getEditor()})\n`));
 
             // Open editor and wait for it to close - use try/finally for cleanup
             let editedContent: string;
@@ -202,13 +202,11 @@ ${CONTENT_DELIMITER}
             await configService.saveGlobalConfig(newConfig);
 
             if (cleanedContent.length === 0) {
-                logger.info("Global system prompt cleared (no content).");
+                console.log(chalk.green("✓") + chalk.bold(" Global system prompt cleared (no content)."));
             } else {
-                logger.info(
-                    "Global system prompt saved successfully!\n" +
-                        `Content length: ${cleanedContent.length} characters\n\n` +
-                        "This prompt will be added to all agents' system prompts."
-                );
+                console.log(chalk.green("✓") + chalk.bold(" Global system prompt saved successfully!"));
+                console.log(chalk.gray(`Content length: ${cleanedContent.length} characters`));
+                console.log(chalk.gray("\nThis prompt will be added to all agents' system prompts."));
             }
         } catch (error: unknown) {
             // Handle SIGINT (Ctrl+C) gracefully
@@ -217,7 +215,7 @@ ${CONTENT_DELIMITER}
                 return;
             }
 
-            logger.error(`Failed to configure global system prompt: ${error}`);
+            console.log(chalk.red(`❌ Failed to configure global system prompt: ${error}`));
             process.exitCode = 1;
         }
     });