polish: rewrite all 7 ambiguous notifications for humans

1. Watchdog: "no_improvement" → "hasn't improved after 350 uses"
2. New proposal: "Tool: exec, 347x" → "Your agent used exec 347 times"
3. Sub-pattern: "Native Tool Sub-Pattern" → "Your agent ran exec in docker domain"
4. Expired: "No response in 7 days" → "No action taken — automatically removed"
5. Revalidation: "targets native tool" → "exec is built-in, doesn't need a skill"
6. Blocked: "BLOCKED: credential leak" → "Failed security validation"
7. Upgrade blocked: same as #6

Every notification answers: what happened, why, what to do.

Author: Ace Autonomous

index.ts

@@ -128,10 +128,11 @@ async function validateAndDeploy(skillName: string): Promise<{ ok: boolean; mess
       if (result.errors.some((e: string) => e.startsWith("BLOCKED:"))) {
         fs.rmSync(path.join(SKILLS_DIR, skillName), { recursive: true, force: true });
         const blockReasons = result.errors.filter((e: string) => e.startsWith("BLOCKED:")).join("; ");
-        notify(`Blocked: ${skillName} — ${blockReasons}`);
+        notify(`🚫 ${bold("Skill blocked")}  ${mono(skillName)}\n\nFailed security validation — not deployed.\n${blockReasons.replace(/BLOCKED:\s*/g, "")}`);
         return { ok: false, message: `Skill '${skillName}' blocked by validator: ${blockReasons}` };
       }
-      notify(`Deploying ${skillName} with warnings: ${result.errors.join("; ")}`);
+      notify(`⚠️ ${bold("Deployed with warnings")}  ${mono(skillName)}\n\n${result.errors.join("\n")}`);
+
     }
   } catch (err) { fs.rmSync(path.join(SKILLS_DIR, skillName), { recursive: true, force: true }); return { ok: false, message: `Skill '${skillName}' rejected: validator failed to load — ${(err as Error).message}` }; }
 
@@ -695,7 +696,8 @@ function buildPlugin() {
                   if (valResult.errors.some((e: string) => e.startsWith("BLOCKED:"))) {
                     const blockReasons = valResult.errors.filter((e: string) => e.startsWith("BLOCKED:")).join("; ");
                     fs.rmSync(upgradeDir, { recursive: true, force: true });
-                    notify(`Upgrade blocked: ${upgradeName} — ${blockReasons}`);
+                    notify(`🚫 ${bold("Upgrade blocked")}  ${mono(upgradeName)}\n\nFailed security validation — old skill preserved.\n${blockReasons.replace(/BLOCKED:\s*/g, "")}`);
+
                     return { text: `Upgrade '${upgradeName}' blocked by validator: ${blockReasons}` };
                   }
                 }

src/pattern/analyze-native.ts

@@ -17,6 +17,7 @@
 import * as fsSync from "fs";
 import { appendJsonl } from "./store.js";
 import { notify } from "../notify.js";
+import { bold, mono } from "../notify-format.js";
 import { writeProposal } from "../skill/generator.js";
 import { validateSkillMd } from "../skill/validator.js";
 import { generateSkillWithLLm } from "../skill/llm-generator.js";
@@ -234,12 +235,11 @@ export async function handleNativeToolCandidate(
       const summary = descMatch ? descMatch[1].slice(0, 120) : canonicalName;
 
       notify(
-        `Native Tool Sub-Pattern Proposal\n` +
-        `${canonicalName}\n` +
-        `Tool: ${key} (${sp.domain} domain)\n` +
-        `${sp.entries.length}x, ${Math.round(spSuccessRate * 100)}% success, ${spSessions.size} sessions\n` +
-        `Summary: ${summary}\n` +
-        `Use: /forge approve ${canonicalName}  or  /forge reject ${canonicalName}`
+        `📋 ${bold("New Skill Proposal")}\n\n` +
+        `${bold(canonicalName)}\n` +
+        `Your agent ran ${mono(key)} in the ${sp.domain} domain ${sp.entries.length} times across ${spSessions.size} session${spSessions.size !== 1 ? "s" : ""} (${Math.round(spSuccessRate * 100)}% success)\n` +
+        (summary ? `\n${summary}` : "") + `\n\n` +
+        `${mono("/forge preview " + canonicalName)}\n${mono("/forge approve " + canonicalName)}\n${mono("/forge reject " + canonicalName)}`
       ).catch(err => console.error("[aceforge] notify error:", err));
 
       console.log(`[aceforge] sub-pattern proposal written: ${canonicalName}`);

src/pattern/analyze.ts

@@ -371,13 +371,12 @@ export async function analyzePatterns(): Promise<void> {
       : "";
 
     notify(
-      `New Skill Proposal\n` +
-      `${skillName}\n` +
-      `Tool: ${key}\n` +
-      `${entries.length}x, ${Math.round(successRate * 100)}% success, ${sessions.size} sessions\n` +
-      `Summary: ${summary}` +
-      notesSuffix + `\n` +
-      `Use: /forge approve ${skillName}  or  /forge reject ${skillName}`
+      `📋 ${bold("New Skill Proposal")}\n\n` +
+      `${bold(skillName)}\n` +
+      `Your agent used ${mono(key)} ${entries.length} times across ${sessions.size} session${sessions.size !== 1 ? "s" : ""} (${Math.round(successRate * 100)}% success)\n` +
+      (summary ? `\n${summary}` : "") +
+      (notesSuffix ? `\n${notesSuffix}` : "") + `\n\n` +
+      `${mono("/forge preview " + skillName)}\n${mono("/forge approve " + skillName)}\n${mono("/forge reject " + skillName)}`
     ).catch(err => console.error("[aceforge] notify error:", err));
   }
 
@@ -401,17 +400,19 @@ export async function analyzePatterns(): Promise<void> {
     const { runEffectivenessWatchdog } = await import("../skill/lifecycle.js");
     const watchdogAlerts = runEffectivenessWatchdog();
     if (watchdogAlerts.length > 0) {
-      const alertText = watchdogAlerts.map((a: any) =>
-        `${a.skill}: ${a.reason === "no_improvement"
-          ? `no improvement after ${a.activations} activations (${Math.round(a.successRate * 100)}% vs ${Math.round(a.baselineRate * 100)}% baseline)`
-          : `degraded to ${Math.round(a.successRate * 100)}% success over ${a.activations} activations`}`
-      ).join("\n");
-      console.warn(`[aceforge] watchdog alerts:\n${alertText}`);
+      const alertLines = watchdogAlerts.map((a: any) => {
+        if (a.reason === "no_improvement") {
+          return `${bold(a.skill)} hasn't improved after ${a.activations} uses — still at ${Math.round(a.successRate * 100)}% (was ${Math.round(a.baselineRate * 100)}% at deploy)`;
+        } else {
+          return `${bold(a.skill)} is declining — down to ${Math.round(a.successRate * 100)}% success over ${a.activations} uses`;
+        }
+      }).join("\n\n");
+      console.warn(`[aceforge] watchdog alerts:\n${alertLines}`);
       notify(
-        `Skill Effectiveness Alert\n` +
-        `${watchdogAlerts.length} skill(s) flagged for review:\n` +
-        alertText + `\n` +
-        `Consider: /forge retire <name> or wait for evolution cycle`
+        `📉 ${bold("Underperforming Skills")}\n\n` +
+        alertLines + `\n\n` +
+        `You can retire them or let the next evolution cycle attempt a fix:\n` +
+        mono("/forge retire <skill-name>")
       ).catch(err => console.error("[aceforge] notify error:", err));
     }
   } catch (err) {

src/skill/lifecycle.ts

@@ -338,7 +338,7 @@ export function expireOldProposals(notifyFn?: (msg: string) => Promise<void>): v
     fsSync.rmSync(propDir, { recursive: true, force: true });
     console.log(`[aceforge] proposal expired: ${name}`);
     if (notifyFn) {
-      notifyFn(`Proposal expired: ${name}\nNo response in 7 days.`);
+      notifyFn(`🗑️ Proposal expired · ${name}\n\nNo action taken in 7 days — automatically removed.`);
     }
   }
 }
@@ -590,7 +590,7 @@ export function revalidateProposals(
       removed.push(name);
       console.log(`[aceforge] revalidation: removed '${name}' — targets native tool '${prefix}'`);
       if (notifyFn) {
-        notifyFn(`Proposal removed: ${name}\nReason: targets native OpenClaw tool '${prefix}'`);
+        notifyFn(`🧹 Stale proposal cleaned up · ${name}\n\n${prefix} is a built-in OpenClaw tool that doesn't need a skill.`);
       }
       continue;
     }
@@ -610,7 +610,7 @@ export function revalidateProposals(
         removed.push(name);
         console.log(`[aceforge] revalidation: removed '${name}' — duplicates deployed skill '${duplicateSkill}'`);
         if (notifyFn) {
-          notifyFn(`Proposal removed: ${name}\nReason: duplicates deployed skill '${duplicateSkill}'`);
+          notifyFn(`🧹 Stale proposal cleaned up · ${name}\n\nAlready covered by deployed skill ${duplicateSkill}.`);
         }
       }
     }