bloby-bot 0.69.5 → 0.70.0

package/README.md

@@ -133,7 +133,7 @@ workspace/
   PULSE.json           Periodic wake-up config (interval, quiet hours)
   CRONS.json           Scheduled tasks with cron expressions
   memory/              Daily notes (YYYY-MM-DD.md files, append-only)
-  skills/              Plugin directories with .claude-plugin/plugin.json
+  skills/              Skill folders (SKILL.md with name+description frontmatter)
   MCP.json             MCP server configuration (optional)
   files/               Attachment storage (audio, images, documents)
 ```
@@ -193,9 +193,9 @@ When a cron or pulse fires:
 
 ---
 
-## Skills & Plugins
+## Skills
 
-The agent auto-discovers skills in `workspace/skills/`. Each skill is a folder containing `.claude-plugin/plugin.json`. These are loaded as tool plugins when the agent starts a query.
+The agent auto-discovers skills in `workspace/skills/`. Each skill is a folder containing a `SKILL.md` whose YAML frontmatter carries `name` (= folder name) and `description`. All three harnesses surface that metadata in context and load the body on demand: the Claude harness mirrors skills into `workspace/.claude/skills` and enables them via the Agent SDK's `skills` option, the Codex harness mirrors them into `workspace/.codex/skills` and primes them via `skills/list`, and the Pi harness injects a name+description index into the system prompt (see `supervisor/harnesses/skills.ts`).
 
 MCP servers can be configured in `workspace/MCP.json`. The agent loads them at query time and logs which servers are active.
 
@@ -568,7 +568,7 @@ workspace/
   PULSE.json                        Periodic wake-up configuration
   CRONS.json                        Scheduled task definitions
   memory/                           Daily notes (YYYY-MM-DD.md)
-  skills/                           Plugin directories (.claude-plugin/plugin.json)
+  skills/                           Skill folders (SKILL.md with frontmatter)
   MCP.json                          MCP server configuration (optional)
   files/                            Uploaded file storage (audio/, images/, documents/)
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.69.5",
+  "version": "0.70.0",
   "releaseNotes": [
     "1. Fix: agent self-update ",
     "1",

package/supervisor/channels/whatsapp.ts

@@ -481,6 +481,7 @@ export class WhatsAppChannel implements ChannelProvider {
       if (connection === 'open') {
         this.connected = true;
         this.reconnectAttempts = 0;
+        this.pairingRetries = 0;
         this.qrData = null;
         this.qrSvg = null;
         this.buildLidMap();
@@ -516,38 +517,40 @@ export class WhatsAppChannel implements ChannelProvider {
           return;
         }
 
-        // Never paired (pair-success sets creds.registered before the post-pairing 515,
-        // so a registered=false close means the pairing window expired unused).
-        if (!state.creds.registered) {
-          if (state.creds.me) {
-            // Phantom identity from an uncompleted pairing-code attempt (Baileys sets
-            // creds.me as a placeholder when the code is requested). Reconnecting would
-            // try to LOG IN with an identity the server never registered → guaranteed
-            // 401 wipe. Reset to a clean unpaired state instead.
-            log.info('[whatsapp] Pairing code expired before confirmation — resetting credentials; connect again to retry');
-            await this.deleteCredentials();
-          } else if (this.pairingRetries < 2) {
-            // Fresh QR windows for a while (the link page is likely still open),
-            // then stop instead of cycling QR codes in the background forever.
+        // restartRequired (515) is the server's reconnect-now handoff. In the QR flow it
+        // arrives right after pair-success, while creds.registered is STILL false (that
+        // flag is only set in the pairing-code flow, messages-recv link_code_pairing_ref)
+        // — so it MUST be handled before any unpaired/phantom logic, or a successful
+        // scan gets thrown away. Backoff guards a pathological repeated-515 loop.
+        if (statusCode === DisconnectReason.restartRequired) {
+          const delay = Math.min(1000 * 2 ** this.reconnectAttempts++, 60_000);
+          log.info(`[whatsapp] Restart required (normal after pairing) — reconnecting in ${delay}ms...`);
+          this.emitStatus();
+          this.scheduleReconnect(delay);
+          return;
+        }
+
+        // Pure QR wait expired without anyone claiming an identity — regenerate a fresh
+        // QR a couple of times (the link page is likely still open), then stop instead
+        // of cycling QR codes in the background forever.
+        if (!state.creds.registered && !state.creds.me) {
+          if (this.pairingRetries < 2) {
             this.pairingRetries++;
             log.info(`[whatsapp] QR expired — generating a fresh one (retry ${this.pairingRetries}/2)`);
             this.emitStatus();
             this.scheduleReconnect(2000);
-            return;
           } else {
             log.info('[whatsapp] Pairing window closed without a scan — connect again to retry');
+            this.emitStatus();
           }
-          this.emitStatus();
           return;
         }
 
-        // restartRequired (515) is the normal post-pairing handoff — reconnect right
-        // away, but only the first time (a repeated-515 loop is a known Baileys failure
-        // mode; let it back off). Everything else backs off 5s → 60s so an offline
-        // network doesn't hot-loop.
-        const fastRestart = statusCode === DisconnectReason.restartRequired && this.reconnectAttempts === 0;
-        const delay = fastRestart ? 1000 : Math.min(5000 * 2 ** this.reconnectAttempts, 60_000);
-        this.reconnectAttempts++;
+        // Anything else reconnects with backoff (5s → 60s). This includes the
+        // me-set-but-unregistered states: a real post-pairing identity completes its
+        // login on reconnect, and a stale pairing-code placeholder gets a 401 from the
+        // server — which lands in the loggedOut branch above and wipes it cleanly.
+        const delay = Math.min(5000 * 2 ** this.reconnectAttempts++, 60_000);
         log.info(`[whatsapp] Reconnecting in ${Math.round(delay / 1000)}s...`);
         this.emitStatus();
         this.scheduleReconnect(delay);

package/supervisor/chat/bloby-main.tsx

@@ -631,7 +631,7 @@ function BlobyApp() {
           <div className="absolute inset-0 z-10 flex items-center justify-center bg-background/70 backdrop-blur-[2px]">
             <span className="flex items-center gap-2 text-[12px] text-muted-foreground bg-white/[0.05] border border-white/[0.08] rounded-full px-3.5 py-1.5 shadow-lg">
               <span className={`h-1.5 w-1.5 rounded-full animate-pulse ${updating ? 'bg-amber-400' : 'bg-red-500'}`} />
-              {updating ? 'Updating — back in a moment…' : 'Offline — waiting for connection…'}
+              {updating ? 'Morphy is Updating…' : 'Morphy is Offline'}
             </span>
           </div>
         )}

package/supervisor/harnesses/claude.ts

@@ -20,6 +20,7 @@ import { getClaudeAccessToken } from '../../worker/claude-auth.js';
 import { assembleSystemPrompt } from '../../worker/prompts/prompt-assembler.js';
 import { buildAgents } from '../agents/index.js';
 import { preWarm, claimWarmup, discardWarmup } from '../cli-warmup.js';
+import { mirrorSkillsInto } from './skills.js';
 
 // ── Types ──────────────────────────────────────────────────────────────────
 
@@ -128,6 +129,20 @@ function formatConversationHistory(messages: RecentMessage[]): string {
   return messages.map((m) => `${m.role}: ${m.content}`).join('\n\n');
 }
 
+// The Agent SDK discovers project-scope skills under `<cwd>/.claude/skills`
+// (name+description listed in context, body lazy-loaded via the Skill tool).
+// Bloby keeps the canonical skills in `workspace/skills/<name>`, so we mirror
+// each one into `.claude/skills/<name>` as a symlink — same single-source
+// pattern as the codex harness's `.codex/skills` mirror. The returned names
+// feed the `skills` option as an explicit allowlist: only Bloby's workspace
+// skills are enabled, so the human's personal `~/.claude/skills` never leak
+// into the agent and the option hash stays deterministic for the pre-warmer.
+const CLAUDE_SKILLS_ROOT = path.join(WORKSPACE_DIR, '.claude', 'skills');
+
+function syncClaudeSkills(): string[] {
+  return mirrorSkillsInto(CLAUDE_SKILLS_ROOT, 'claude');
+}
+
 /** Load MCP server config from workspace/MCP.json */
 function loadMcpServers(): Record<string, any> | undefined {
   try {
@@ -210,6 +225,7 @@ async function buildConversationOptions(
 
   const agents = buildAgents();
   const mcpServers = loadMcpServers();
+  const skills = syncClaudeSkills();
 
   return {
     model,
@@ -224,6 +240,7 @@ async function buildConversationOptions(
     systemPrompt,
     mcpServers,
     agents,
+    skills,
     agentProgressSummaries: true,
     // Auto-compaction: the live conversation is a single long-lived query() whose
     // context grows every turn (messages + tool results + sub-agent transcripts).
@@ -294,6 +311,8 @@ export async function startConversation(
   if (baseOptions.mcpServers) {
     log.info(`[conversation] MCP servers: ${Object.keys(baseOptions.mcpServers).join(', ')}`);
   }
+  const skillNames = Array.isArray(baseOptions.skills) ? baseOptions.skills : [];
+  log.info(`[conversation] Skills: ${skillNames.length ? skillNames.join(', ') : 'none'}`);
 
   // Try to claim a pre-warmed subprocess — its abortController is the one
   // baked into the warm query and must be reused for end/abort to reach it.
@@ -667,6 +686,10 @@ export async function startBlobyAgentQuery(
         maxTurns: effectiveMaxTurns,
         abortController,
         systemPrompt: enrichedPrompt,
+        // Customer-facing runs (supportPrompt) get no skills — SCRIPT.md alone
+        // governs that persona and the listing would just leak ops docs into
+        // customer context. Owner runs (pulse/cron) get the full workspace set.
+        skills: supportPrompt ? [] : syncClaudeSkills(),
         mcpServers,
         stderr: (chunk: string) => { stderrBuf += chunk; },
         env: {
@@ -781,6 +804,7 @@ export async function runAgentQuery(req: AgentQueryRequest): Promise<AgentQueryR
         maxTurns,
         abortController,
         systemPrompt: systemPrompt as any,
+        skills: syncClaudeSkills(),
         ...(req.sessionId ? { resume: req.sessionId } : {}),
         stderr: (chunk: string) => { stderrBuf += chunk; },
         env: {

package/supervisor/harnesses/codex.ts

@@ -35,6 +35,7 @@ import { WORKSPACE_DIR } from '../../shared/paths.js';
 import type { SavedFile } from '../file-saver.js';
 import { getCodexAccessToken } from '../../worker/codex-auth.js';
 import { assembleSystemPrompt } from '../../worker/prompts/prompt-assembler.js';
+import { mirrorSkillsInto } from './skills.js';
 import type { OnAgentMessage, RecentMessage, AgentAttachment, AgentQueryRequest, AgentQueryResult } from './types.js';
 export type { RecentMessage, AgentAttachment };
 
@@ -771,7 +772,6 @@ async function spawnAndInitialize(
   }
 }
 
-const SKILLS_DIR = path.join(WORKSPACE_DIR, 'skills');
 // Codex discovers "repo"-scope skills under `<cwd>/.codex/skills` (verified
 // against 0.135.0 — a bare `<cwd>/skills` is NOT scanned, and `skills/list`
 // has no extra-root param). Bloby keeps the canonical skills in
@@ -780,33 +780,8 @@ const SKILLS_DIR = path.join(WORKSPACE_DIR, 'skills');
 // (Each SKILL.md needs YAML frontmatter or codex rejects it — see SKILL_FORMAT_MIGRATION.md.)
 const CODEX_SKILLS_ROOT = path.join(WORKSPACE_DIR, '.codex', 'skills');
 
-/** Mirror workspace/skills/<name> → workspace/.codex/skills/<name> as symlinks (idempotent). */
-function syncCodexSkillRoot(): void {
-  let names: string[] = [];
-  try {
-    names = fs.readdirSync(SKILLS_DIR, { withFileTypes: true })
-      .filter((e) => e.isDirectory() || e.isSymbolicLink())
-      .map((e) => e.name);
-  } catch {
-    return; // no skills dir — nothing to mirror
-  }
-  try { fs.mkdirSync(CODEX_SKILLS_ROOT, { recursive: true }); } catch {}
-  for (const name of names) {
-    const target = path.join(SKILLS_DIR, name);
-    const link = path.join(CODEX_SKILLS_ROOT, name);
-    try {
-      const cur = fs.existsSync(link) ? fs.realpathSync(link) : null;
-      if (cur === fs.realpathSync(target)) continue; // already correct
-      try { fs.rmSync(link, { recursive: true, force: true }); } catch {}
-      fs.symlinkSync(target, link, 'dir');
-    } catch (err: any) {
-      log.warn(`[codex] could not mirror skill "${name}" into .codex/skills: ${err.message}`);
-    }
-  }
-}
-
 function primeWorkspaceSkills(rpc: CodexRpc): void {
-  syncCodexSkillRoot();
+  mirrorSkillsInto(CODEX_SKILLS_ROOT, 'codex');
   rpc.request('skills/list', {
     cwds: [WORKSPACE_DIR],
     forceReload: true,

package/supervisor/harnesses/pi/index.ts

@@ -24,6 +24,7 @@ import type {
 } from '../types.js';
 export type { RecentMessage, AgentAttachment };
 
+import { buildSkillsIndex } from '../skills.js';
 import { createAsyncQueue, type AsyncQueue } from './async-queue.js';
 import { createPiSession, type PiSessionEvent } from './session.js';
 import { getPiSubProvider } from './sub-providers.js';
@@ -110,6 +111,11 @@ async function buildSystemPrompt(
   const basePrompt = await assembleSystemPrompt(names?.botName, names?.humanName, 'pi');
   let systemPrompt = basePrompt;
   systemPrompt += LIVE_CONVERSATION_HINT;
+  // Pi has no native skill machinery (Claude's SDK and Codex discover skills
+  // themselves), so inject the name+description index here — the agent reads
+  // skills/<name>/SKILL.md on demand. Customer-facing supportPrompt runs skip
+  // this builder entirely, so they never see the index.
+  systemPrompt += buildSkillsIndex();
   systemPrompt += `\n\n---\n# Your Memory Files\n\n## MYSELF.md\n${memoryFiles.myself}\n\n## MYHUMAN.md\n${memoryFiles.myhuman}\n\n## MEMORY.md\n${memoryFiles.memory}\n\n---\n# Your Config Files\n\n## PULSE.json\n${memoryFiles.pulse}\n\n## CRONS.json\n${memoryFiles.crons}`;
 
   try {

package/supervisor/harnesses/skills.ts

@@ -0,0 +1,133 @@
+/**
+ * Shared skill plumbing for all three harnesses.
+ *
+ * Canonical on-disk layout (single source of truth):
+ *   workspace/skills/<name>/SKILL.md — YAML frontmatter with `name` (= folder
+ *   name) and `description`. See SKILL_FORMAT_MIGRATION.md.
+ *
+ * Each harness consumes that one layout its own way:
+ *   - claude: mirrored into `workspace/.claude/skills` (the Agent SDK's
+ *     project-skill discovery root) and enabled via the `skills` option —
+ *     the SDK then lists name+description in context and lazy-loads bodies
+ *     through its native Skill tool.
+ *   - codex:  mirrored into `workspace/.codex/skills` (codex's repo-scope
+ *     root) and primed via `skills/list` — codex's own router takes over.
+ *   - pi:     no native skill machinery, so `buildSkillsIndex()` appends a
+ *     name+description index to the system prompt and the agent reads
+ *     `skills/<name>/SKILL.md` on demand (hermes-style progressive
+ *     disclosure: metadata always in context, body only when used).
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { log } from '../../shared/logger.js';
+import { WORKSPACE_DIR } from '../../shared/paths.js';
+
+export const SKILLS_DIR = path.join(WORKSPACE_DIR, 'skills');
+
+/** Sorted names of installed skill folders (dirs or symlinks under skills/). */
+export function listSkillNames(): string[] {
+  try {
+    return fs.readdirSync(SKILLS_DIR, { withFileTypes: true })
+      .filter((e) => (e.isDirectory() || e.isSymbolicLink()) && !e.name.startsWith('.'))
+      .map((e) => e.name)
+      .sort();
+  } catch {
+    return []; // no skills dir — nothing installed
+  }
+}
+
+/**
+ * Mirror workspace/skills/<name> → <mirrorRoot>/<name> as symlinks
+ * (idempotent), and prune symlinks for skills that were uninstalled.
+ * Returns the sorted list of mirrored skill names.
+ *
+ * Only symlinks are ever pruned — a real directory someone dropped into the
+ * mirror root is left alone.
+ */
+export function mirrorSkillsInto(mirrorRoot: string, label: string): string[] {
+  const names = listSkillNames();
+  if (names.length) {
+    try { fs.mkdirSync(mirrorRoot, { recursive: true }); } catch {}
+  }
+
+  const mirrored: string[] = [];
+  for (const name of names) {
+    const target = path.join(SKILLS_DIR, name);
+    const link = path.join(mirrorRoot, name);
+    try {
+      const cur = fs.existsSync(link) ? fs.realpathSync(link) : null;
+      if (cur !== fs.realpathSync(target)) {
+        try { fs.rmSync(link, { recursive: true, force: true }); } catch {}
+        fs.symlinkSync(target, link, 'dir');
+      }
+      mirrored.push(name);
+    } catch (err: any) {
+      log.warn(`[${label}] could not mirror skill "${name}" into ${path.basename(path.dirname(mirrorRoot))}/skills: ${err.message}`);
+    }
+  }
+
+  // Prune stale symlinks (skill uninstalled) so dead links never reach the harness.
+  try {
+    for (const entry of fs.readdirSync(mirrorRoot, { withFileTypes: true })) {
+      if (!entry.isSymbolicLink() || names.includes(entry.name)) continue;
+      try { fs.unlinkSync(path.join(mirrorRoot, entry.name)); } catch {}
+    }
+  } catch {}
+
+  return mirrored;
+}
+
+/**
+ * Parse `name` and `description` from a SKILL.md YAML frontmatter block.
+ * Handles plain, quoted, and folded/literal (`>-`, `|`) scalar styles —
+ * enough for the two mandated keys without pulling in a YAML dependency.
+ */
+export function parseSkillFrontmatter(skillMdPath: string): { name?: string; description?: string } {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(skillMdPath, 'utf-8');
+  } catch {
+    return {};
+  }
+  if (!raw.startsWith('---')) return {};
+  const end = raw.indexOf('\n---', 3);
+  if (end === -1) return {};
+  const lines = raw.slice(raw.indexOf('\n') + 1, end).split('\n');
+
+  const out: Record<string, string> = {};
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/^(name|description):\s*(.*)$/);
+    if (!m) continue;
+    let value = m[2].trim();
+    if (/^[>|][+-]?$/.test(value)) {
+      // Block scalar — collect indented continuation lines, fold with spaces.
+      const parts: string[] = [];
+      while (i + 1 < lines.length && (/^\s+\S/.test(lines[i + 1]) || lines[i + 1].trim() === '')) {
+        i++;
+        if (lines[i].trim()) parts.push(lines[i].trim());
+      }
+      value = parts.join(' ');
+    } else if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1).replace(/\\"/g, '"');
+    }
+    out[m[1]] = value;
+  }
+  return out;
+}
+
+/**
+ * Compact installed-skills index for system-prompt injection (pi harness).
+ * One name+description line per skill — the body stays on disk until the
+ * agent actually opens it. Returns '' when no skills are installed.
+ */
+export function buildSkillsIndex(): string {
+  const entries: string[] = [];
+  for (const name of listSkillNames()) {
+    const fm = parseSkillFrontmatter(path.join(SKILLS_DIR, name, 'SKILL.md'));
+    const description = fm.description || '(no description — open the SKILL.md)';
+    entries.push(`- **${fm.name || name}** — ${description}`);
+  }
+  if (!entries.length) return '';
+  return `\n\n---\n# Installed Skills\n\nScan this list on every request. When a request matches a skill — even partially — read \`skills/<name>/SKILL.md\` before acting and follow it.\n\n${entries.join('\n')}`;
+}