feat: complete Milestone 4 (self-improve loop and telegram polish)

Author: Splash Agent

bots/telegram.ts

@@ -10,9 +10,10 @@
  *   - Uses character.md persona if present
  */
 
-import { Telegraf } from "telegraf";
+import { Telegraf, Markup } from "telegraf";
 import pc from "picocolors";
 import { runChatTask, getAlpClaw, chunkText } from "./lib/chat-agent.js";
+import { readGlobalConfig, writeGlobalConfig } from "@alpclaw/config";
 
 const MAX_MSG = 3800;
 
@@ -49,6 +50,64 @@ async function main() {
   console.log(pc.dim("─".repeat(60)));
   console.log(pc.dim("Waiting for messages... (Ctrl+C to stop)\n"));
 
+  bot.command("mode", async (ctx) => {
+    try {
+      const cfg = readGlobalConfig();
+      const currentMode = cfg.safety?.mode || "permissive";
+      
+      const keyboard = Markup.inlineKeyboard([
+        Markup.button.callback(currentMode === "permissive" ? "✅ Permissive" : "Permissive", "mode:permissive"),
+        Markup.button.callback(currentMode === "strict" ? "✅ Strict" : "Strict", "mode:strict"),
+      ]);
+      
+      await ctx.reply("Select safety mode:", keyboard);
+    } catch (e: any) {
+      await ctx.reply("⚠️ Failed to load modes. Please try again.");
+    }
+  });
+
+  bot.command("provider", async (ctx) => {
+    try {
+      const alpclaw = await getAlpClaw();
+      const providers = alpclaw.router.listProviders();
+      const current = readGlobalConfig().providers?.default || "openrouter";
+      
+      const buttons = providers.map(p => [
+        Markup.button.callback(current === p.name ? `✅ ${p.name}` : p.name, `provider:${p.name}`)
+      ]);
+      
+      await ctx.reply("Select default provider:", Markup.inlineKeyboard(buttons));
+    } catch (e: any) {
+      await ctx.reply("⚠️ Failed to load providers. Please try again.");
+    }
+  });
+
+  bot.on("callback_query", async (ctx) => {
+    try {
+      const cb = ctx.callbackQuery as any;
+      if (!cb.data) return;
+      
+      const [action, value] = cb.data.split(":");
+      const cfg = readGlobalConfig();
+      
+      if (action === "mode") {
+        cfg.safety = cfg.safety || { mode: "permissive" };
+        cfg.safety.mode = value as "permissive" | "strict";
+        writeGlobalConfig(cfg);
+        await ctx.editMessageText(`✅ Safety mode set to ${value}.`);
+      } else if (action === "provider") {
+        cfg.providers = cfg.providers || { default: value, apiKeys: {} };
+        cfg.providers.default = value;
+        writeGlobalConfig(cfg);
+        await ctx.editMessageText(`✅ Provider set to ${value}.`);
+      }
+      
+      await ctx.answerCbQuery();
+    } catch (e: any) {
+       await ctx.answerCbQuery("Error updating config.").catch(() => null);
+    }
+  });
+
   bot.on("text", async (ctx) => {
     const text = ctx.message.text;
     const from = ctx.message.from;
@@ -65,7 +124,25 @@ async function main() {
     });
 
     const startMs = Date.now();
-    const { reply, success } = await runChatTask(text);
+    let reply = "";
+    let success = false;
+    let attempts = 0;
+    const maxAttempts = 2;
+    
+    while (attempts < maxAttempts) {
+      attempts++;
+      const res = await runChatTask(text);
+      reply = res.reply;
+      success = res.success;
+      if (success || attempts >= maxAttempts) break;
+      console.log(`${ts()} ${pc.yellow("⚠ RETRY")} Attempt ${attempts} failed, retrying...`);
+    }
+
+    if (!success) {
+       // Friendly error wrapper — hide stack trace from user
+       reply = "⚠️ I encountered an internal error while processing your request. Please check the terminal logs or try again later.";
+    }
+
     const elapsed = ((Date.now() - startMs) / 1000).toFixed(1);
 
     const pieces = chunkText(reply, MAX_MSG);

examples/cli.ts

@@ -108,6 +108,9 @@ async function main() {
     case "dashboard":
       await launchTui();
       return;
+    case "self-improve":
+      await runSelfImprove();
+      return;
     case "_worker":
       // internal: spawned by background runs to execute a pre-allocated run id
       if (args[1] && args[2]) {
@@ -153,7 +156,7 @@ function printHelp(): void {
       `  ${pc.cyan("Config")} ${pc.dim("│")} config list/get/set, providers list/test`,
       `  ${pc.cyan("Skills")} ${pc.dim("│")} skills list, skills enable/disable, skills suggest`,
       `  ${pc.cyan("Runs  ")} ${pc.dim("│")} runs list/logs/stop/retry`,
-      `  ${pc.cyan("System")} ${pc.dim("│")} doctor, update, auth, init`,
+      `  ${pc.cyan("System")} ${pc.dim("│")} doctor, update, auth, init, self-improve`,
       "",
       pc.dim(`  Config: ${globalConfigPath()}`),
       pc.dim(`  Env:    SPLASH_* vars work. .env in cwd is read.`),
@@ -635,6 +638,54 @@ async function runFromCli(prompt: string, opts: { background: boolean }): Promis
   await runOneShot(alpclaw, prompt);
 }
 
+// ──────────────────────────────────────────────────────────────────────────
+// Self-Improvement Loop
+// ──────────────────────────────────────────────────────────────────────────
+
+async function runSelfImprove() {
+  console.log(pc.magenta("\n🧠 SPLASH SELF-MODIFICATION ENGINE"));
+  console.log(pc.dim("Analyzing recent sessions to extract learnings...\n"));
+  
+  const { EpisodicMemory } = await import("@alpclaw/memory");
+  const episodic = new EpisodicMemory();
+  const sessions = episodic.getAllSessions();
+  if (sessions.length === 0) {
+    console.log(pc.yellow("No sessions found to learn from."));
+    return;
+  }
+  
+  const latestSessions = sessions.slice(0, 5);
+  let aggregatedLogs = "";
+  for (const s of latestSessions) {
+    const msgs = await episodic.getLastNMessages(s.sessionId, 100);
+    aggregatedLogs += `\n--- SESSION ${s.sessionId} ---\n`;
+    for (const msg of msgs) {
+       aggregatedLogs += `[${msg.role}] ${msg.content}\n`;
+    }
+  }
+  
+  const alpclaw = await buildAgent();
+  const prompt = `You are the core intelligence of Splash. Your goal is to analyze your recent conversation logs, identify mistakes you made, and write rules to prevent them in the future.
+  
+Recent Logs:
+${aggregatedLogs.slice(-10000)}
+
+Output ONLY a list of crisp, actionable rules you should adopt. Do not explain them. Be concise.`;
+
+  console.log(pc.cyan("Analyzing..."));
+  const result = await alpclaw.createAgent({ onPhaseChange: () => {} }).run(prompt);
+  
+  const fs = await import("node:fs");
+  const path = await import("node:path");
+  const { globalConfigDir } = await import("@alpclaw/config");
+  const learningsFile = path.join(globalConfigDir(), "learnings.md");
+  const learnings = `\n## Learnings (${new Date().toISOString()})\n${result.text}\n`;
+  fs.appendFileSync(learningsFile, learnings);
+  
+  console.log(pc.green(`✓ Success! New rules added to ${learningsFile}:\n`));
+  console.log(result.text);
+}
+
 // ──────────────────────────────────────────────────────────────────────────
 // Bots
 // ──────────────────────────────────────────────────────────────────────────

packages/core/src/alpclaw.ts

@@ -49,6 +49,7 @@ import {
   GitHelperSkill,
   LinearTriageSkill,
   NotionSyncSkill,
+  ConfigEditorSkill,
 } from "@alpclaw/skills";
 import { createLogger } from "@alpclaw/utils";
 import { AgentLoop, type AgentLoopCallbacks } from "./agent-loop.js";
@@ -152,6 +153,7 @@ export class AlpClaw {
     this.skills.register(new GitHelperSkill());
     this.skills.register(new LinearTriageSkill());
     this.skills.register(new NotionSyncSkill());
+    this.skills.register(new ConfigEditorSkill());
 
     // ── Safety ─────────────────────────────────────────────────────────────
     this.safety = new SafetyEngine(config.safety.mode, config.safety.blockedPatterns);

packages/memory/src/episodic.ts

@@ -24,6 +24,18 @@ export class EpisodicMemory {
     return path.join(this.baseDir, `${sessionId}.jsonl`);
   }
 
+  public getAllSessions(): { sessionId: string; mtimeMs: number }[] {
+    if (!fs.existsSync(this.baseDir)) return [];
+    const files = fs.readdirSync(this.baseDir).filter((file) => file.endsWith(".jsonl"));
+    return files.map((file) => {
+      const stat = fs.statSync(path.join(this.baseDir, file));
+      return {
+        sessionId: path.basename(file, ".jsonl"),
+        mtimeMs: stat.mtimeMs,
+      };
+    }).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+
   public append(sessionId: string, message: MessageEntry): void {
     const filePath = this.getSessionFile(sessionId);
     const line = JSON.stringify(message) + "\n";

packages/skills/src/built-in/config-editor.ts

@@ -0,0 +1,74 @@
+import { type Result, type SkillManifest, type SkillResult, ok, err, createError } from "@alpclaw/utils";
+import type { Skill, SkillContext } from "../skill.js";
+import { readGlobalConfig, writeGlobalConfig } from "@alpclaw/config";
+
+export class ConfigEditorSkill implements Skill {
+  readonly manifest: SkillManifest = {
+    name: "config-editor",
+    description: "Read or edit the global agent configuration (e.g. ~/.splash/config.json). Use this to persist settings, themes, or provider changes.",
+    version: "1.0.0",
+    tags: ["config", "settings", "preferences", "system"],
+    requiredConnectors: [],
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["read", "update"], description: "The action to perform." },
+        keyPath: { type: "string", description: "Dot-separated path to the config key (e.g. 'safety.mode' or 'cli.style'). Required for 'update'." },
+        value: { type: "string", description: "The new JSON-serializable value. Required for 'update'." }
+      },
+      required: ["action"],
+    },
+  };
+
+  async execute(params: Record<string, unknown>, ctx: SkillContext): Promise<Result<SkillResult>> {
+    const action = String(params.action || "");
+    
+    try {
+      const cfg = readGlobalConfig();
+
+      if (action === "read") {
+        return ok({
+          success: true,
+          output: cfg,
+          summary: "Successfully read global configuration.",
+        });
+      } else if (action === "update") {
+        const keyPath = String(params.keyPath || "");
+        if (!keyPath) return err(createError("validation", "keyPath is required for update"));
+        
+        // Basic dot-notation assignment
+        const keys = keyPath.split(".");
+        let current: any = cfg;
+        for (let i = 0; i < keys.length - 1; i++) {
+          const k = keys[i] as string;
+          if (typeof current[k] !== "object") {
+             current[k] = {};
+          }
+          current = current[k];
+        }
+        
+        let parsedValue = params.value;
+        try {
+           parsedValue = JSON.parse(String(params.value));
+        } catch (e) {
+           // Treat as raw string if it doesn't parse
+        }
+        
+        const lastKey = keys[keys.length - 1] as string;
+        current[lastKey] = parsedValue;
+
+        writeGlobalConfig(cfg);
+
+        return ok({
+          success: true,
+          output: cfg,
+          summary: `Successfully updated config key '${keyPath}' to ${JSON.stringify(parsedValue)}.`,
+        });
+      }
+
+      return err(createError("validation", `Unknown action: ${action}`));
+    } catch (e: any) {
+      return err(createError("skill", String(e.message || e)));
+    }
+  }
+}

packages/skills/src/index.ts

@@ -22,3 +22,4 @@ export { SubagentRunnerSkill } from "./built-in/subagent-runner.js";
 export { GitHelperSkill } from "./built-in/git-helper.js";
 export { LinearTriageSkill } from "./built-in/linear-triage.js";
 export { NotionSyncSkill } from "./built-in/notion-sync.js";
+export { ConfigEditorSkill } from "./built-in/config-editor.js";