@a5c-ai/babysitter-breakpoints 0.0.29 → 0.0.30

package/README.md

@@ -52,11 +52,6 @@ Wait for release:
 breakpoints breakpoint wait <id> --interval 3
 ```
 
-Install the babysitter-breakpoint skill:
-```bash
-breakpoints install-skill --target codex --scope global
-```
-
 ## Configuration
 Environment variables:
 - `PORT` (default 3185)
@@ -115,22 +110,72 @@ breakpoint payload.
 ## Web UI
 Open `http://localhost:3184` and provide the human token in the UI.
 
-## Install the babysitter-breakpoint skill
+## Telegram Extension
+
+The Telegram extension allows you to receive breakpoint notifications and interact with them via Telegram.
+
+### Setup
+1. Create a Telegram bot via [@BotFather](https://t.me/botfather)
+2. Get your bot token
+3. Configure the extension:
 ```bash
-breakpoints install-skill
+breakpoints extension enable telegram --token <bot-token> --username <your-username>
 ```
-Defaults to global Codex install. Options:
-```bash
-breakpoints install-skill --target codex --scope global
-breakpoints install-skill --target codex --scope local
-breakpoints install-skill --target claude --scope global
-breakpoints install-skill --target claude --scope local
-breakpoints install-skill --target cursor --scope global
-breakpoints install-skill --target cursor --scope local
+
+### Features
+
+**Automatic Notifications:**
+- Receive notification when a new breakpoint is created
+- Get notified when a breakpoint is released
+
+**Connection:**
+Send any slash command (e.g., `/start`) to your bot to connect. The bot will:
+- Confirm connection
+- Show all waiting breakpoints with titles, IDs, run IDs, and questions
+- Provide instructions for interacting with breakpoints
+
+**Commands:**
+- `list` (or `ls`, `waiting`) - Show all waiting breakpoints
+- `preview <number>` (or `show <number>`) - View full details of a breakpoint
+- `file <number>` - Download a context file by its number
+- `file <path>` - Download a context file by its path
+- `raw <path>` - View file inline with syntax highlighting (if short enough)
+
+**Releasing Breakpoints:**
+- Reply to any breakpoint message to release it
+- Send the breakpoint ID to release it
+- Send any text message to release the most recent breakpoint
+
+**Example Workflow:**
 ```
-Global targets use `CODEX_HOME` or `~/.codex` for Codex, and `~/.claude` or `~/.cursor` for Claude/Cursor. Local installs write to `.codex/skills`, `.claude/skills`, or `.cursor/skills` under the package root. Restart the app after install.
+You: /start
+Bot: Telegram connected. I will notify you about breakpoints here.
+
+     🔔 You have 2 waiting breakpoints:
+
+     1. Approve refactoring plan
+        ID: abc-123
+        Run: run-20260120-refactor
+        Created: 5 mins ago
+        Question: Should I proceed with this refactoring?
 
-When installed from npm, the skill is bundled at `.codex/skills/babysitter-breakpoint/` inside the package and copied to the target location by `breakpoints install-skill`.
+     2. Review API changes
+        ID: def-456
+        Run: run-20260120-api
+        Created: 2 mins ago
+        Question: Are these API changes acceptable?
+
+You: preview 1
+Bot: [Shows full details including all context files]
+
+You: file 1
+Bot: [Sends the first context file as document]
+
+You: Looks good, proceed!
+Bot: ✅ Breakpoint released
+     ID: abc-123
+     Feedback: Looks good, proceed!
+```
 
 ## Breakpoint CLI (agent-friendly)
 Create a breakpoint:

package/bin/breakpoints.js

@@ -9,7 +9,6 @@ function usage() {
   console.log(`Usage:
   breakpoints start
   breakpoints run
-  breakpoints install-skill [--source <path>] [--target codex|claude|cursor] [--scope local|global]
   breakpoints breakpoint create --question <text> [--run-id <id>] [--title <title>] [--agent-id <id>] [--tag <tag>] [--ttl <seconds>] [--file <path,format,language,label>]
   breakpoints breakpoint status <id>
   breakpoints breakpoint show <id>
@@ -169,61 +168,6 @@ function runSystem() {
   runCommand("node", [runner], { cwd: repoRoot, env });
 }
 
-function installSkill(sourcePath) {
-  const skillSource =
-    sourcePath ||
-    path.join(__dirname, "..", ".codex", "skills", "babysitter-breakpoint");
-  const homeDir = process.env.HOME || process.env.USERPROFILE;
-  if (!homeDir) {
-    console.error("HOME is not set.");
-    process.exitCode = 1;
-    return;
-  }
-  const dest = resolveSkillDest(skillSource);
-  if (fs.existsSync(dest)) {
-    console.error(`Destination already exists: ${dest}`);
-    process.exitCode = 1;
-    return;
-  }
-  fs.mkdirSync(path.dirname(dest), { recursive: true });
-  fs.cpSync(skillSource, dest, { recursive: true });
-  console.log("Installed babysitter-breakpoint skill.");
-}
-
-function resolveSkillDest(skillSource) {
-  const flags = parseFlags(process.argv.slice(2));
-  const target = String(flags.target || "codex");
-  const scope = String(flags.scope || "global");
-  const repoRoot = path.join(__dirname, "..");
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const skillName = path.basename(skillSource);
-
-  if (scope === "local") {
-    if (target === "codex") {
-      return path.join(repoRoot, ".codex", "skills", skillName);
-    }
-    if (target === "claude") {
-      return path.join(repoRoot, ".claude", "skills", skillName);
-    }
-    if (target === "cursor") {
-      return path.join(repoRoot, ".cursor", "skills", skillName);
-    }
-  }
-
-  if (target === "codex") {
-    const codexHome = process.env.CODEX_HOME || path.join(homeDir, ".codex");
-    return path.join(codexHome, "skills", skillName);
-  }
-  if (target === "claude") {
-    return path.join(homeDir, ".claude", "skills", skillName);
-  }
-  if (target === "cursor") {
-    return path.join(homeDir, ".cursor", "skills", skillName);
-  }
-
-  throw new Error(`Unknown target: ${target}`);
-}
-
 const args = process.argv.slice(2);
 const cmd = args[0];
 
@@ -237,13 +181,6 @@ if (cmd === "start" || cmd === "run") {
   return;
 }
 
-if (cmd === "install-skill") {
-  const sourceIndex = args.indexOf("--source");
-  const sourcePath = sourceIndex >= 0 ? args[sourceIndex + 1] : undefined;
-  installSkill(sourcePath);
-  return;
-}
-
 if (cmd === "breakpoint") {
   const flags = parseFlags(args.slice(1));
   const subcmd = flags._[0];

package/extensions/index.js

@@ -24,7 +24,11 @@ async function dispatch(event, db, breakpoint) {
     if (!extension || typeof extension[event] !== "function") {
       continue;
     }
-    await extension[event](db, breakpoint, cfg.config);
+    try {
+      await extension[event](db, breakpoint, cfg.config);
+    } catch (err) {
+      console.error(`[extensions] error in ${cfg.name}.${event}:`, err.message);
+    }
   }
 }
 
@@ -35,7 +39,11 @@ async function poll(db) {
     if (!extension || typeof extension.poll !== "function") {
       continue;
     }
-    await extension.poll(db, cfg.config);
+    try {
+      await extension.poll(db, cfg.config);
+    } catch (err) {
+      console.error(`[extensions] error in ${cfg.name}.poll:`, err.message);
+    }
   }
 }
 

package/extensions/telegram.js

@@ -9,10 +9,15 @@ function apiBase(token) {
   return `https://api.telegram.org/bot${token}`;
 }
 
-function callTelegram(url) {
+function callTelegram(url, options = {}) {
+  const { timeout = 15000, retries = 3, retryDelay = 1000 } = options;
+
   return new Promise((resolve, reject) => {
-    https
-      .get(url, (res) => {
+    let attempt = 0;
+
+    const makeRequest = () => {
+      attempt++;
+      const req = https.get(url, { timeout, family: 4 }, (res) => {
         let data = "";
         res.on("data", (chunk) => {
           data += chunk;
@@ -24,8 +29,40 @@ function callTelegram(url) {
             reject(err);
           }
         });
-      })
-      .on("error", reject);
+      });
+
+      req.on("timeout", () => {
+        req.destroy();
+        handleError(new Error(`Request timeout after ${timeout}ms`));
+      });
+
+      req.on("error", (err) => {
+        handleError(err);
+      });
+    };
+
+    const handleError = (err) => {
+      const isRetryable =
+        err.code === "ETIMEDOUT" ||
+        err.code === "ECONNRESET" ||
+        err.code === "ENOTFOUND" ||
+        err.code === "EAI_AGAIN";
+
+      if (isRetryable && attempt < retries) {
+        const delay = retryDelay * Math.pow(2, attempt - 1);
+        if (process.env.TELEGRAM_DEBUG === "1") {
+          console.log(`[telegram] retry ${attempt}/${retries} after ${delay}ms: ${err.message}`);
+        }
+        setTimeout(makeRequest, delay);
+      } else {
+        if (process.env.TELEGRAM_DEBUG === "1") {
+          console.log(`[telegram] request failed after ${attempt} attempts: ${err.message}`);
+        }
+        reject(err);
+      }
+    };
+
+    makeRequest();
   });
 }
 
@@ -37,7 +74,8 @@ async function sendMessage(token, chatId, text, parseMode) {
   return callTelegram(url);
 }
 
-async function sendDocument(token, chatId, filename, content) {
+async function sendDocument(token, chatId, filename, content, options = {}) {
+  const { timeout = 30000, retries = 3, retryDelay = 1000 } = options;
   const boundary = `----bp-${Date.now()}`;
   const payload = [
     `--${boundary}`,
@@ -53,30 +91,71 @@ async function sendDocument(token, chatId, filename, content) {
     "",
   ].join("\r\n");
   const url = `${apiBase(token)}/sendDocument`;
+
   return new Promise((resolve, reject) => {
-    const req = https.request(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": `multipart/form-data; boundary=${boundary}`,
-        "Content-Length": Buffer.byteLength(payload),
-      },
-    });
-    req.on("response", (res) => {
-      let data = "";
-      res.on("data", (chunk) => {
-        data += chunk;
+    let attempt = 0;
+
+    const makeRequest = () => {
+      attempt++;
+      const req = https.request(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": `multipart/form-data; boundary=${boundary}`,
+          "Content-Length": Buffer.byteLength(payload),
+        },
+        timeout,
+        family: 4,
       });
-      res.on("end", () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch (err) {
-          reject(err);
-        }
+
+      req.on("response", (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (err) {
+            reject(err);
+          }
+        });
       });
-    });
-    req.on("error", reject);
-    req.write(payload);
-    req.end();
+
+      req.on("timeout", () => {
+        req.destroy();
+        handleError(new Error(`Request timeout after ${timeout}ms`));
+      });
+
+      req.on("error", (err) => {
+        handleError(err);
+      });
+
+      req.write(payload);
+      req.end();
+    };
+
+    const handleError = (err) => {
+      const isRetryable =
+        err.code === "ETIMEDOUT" ||
+        err.code === "ECONNRESET" ||
+        err.code === "ENOTFOUND" ||
+        err.code === "EAI_AGAIN";
+
+      if (isRetryable && attempt < retries) {
+        const delay = retryDelay * Math.pow(2, attempt - 1);
+        if (process.env.TELEGRAM_DEBUG === "1") {
+          console.log(`[telegram] retry ${attempt}/${retries} after ${delay}ms: ${err.message}`);
+        }
+        setTimeout(makeRequest, delay);
+      } else {
+        if (process.env.TELEGRAM_DEBUG === "1") {
+          console.log(`[telegram] request failed after ${attempt} attempts: ${err.message}`);
+        }
+        reject(err);
+      }
+    };
+
+    makeRequest();
   });
 }
 
@@ -338,7 +417,15 @@ async function poll(db, config) {
   if (process.env.TELEGRAM_DEBUG === "1") {
     console.log(`[telegram] requesting updates offset=${offset}`);
   }
-  const response = await callTelegram(url);
+
+  let response;
+  try {
+    response = await callTelegram(url, { timeout: 15000, retries: 2 });
+  } catch (err) {
+    console.error(`[telegram] poll error: ${err.message}`);
+    return;
+  }
+
   if (!response.ok) {
     if (process.env.TELEGRAM_DEBUG === "1") {
       console.log(
@@ -391,6 +478,80 @@ async function poll(db, config) {
       await persistUser(db, config, message.chat.id, message.from.id);
     }
     const trimmed = message.text.trim();
+
+    // Handle list command to show waiting breakpoints
+    const listMatch = trimmed.match(/^(list|ls|waiting)$/i);
+    if (listMatch) {
+      const { all } = require("../api/db");
+      const waitingBreakpoints = await all(
+        db,
+        "SELECT id, title, created_at, run_id, payload FROM breakpoints WHERE status = ? ORDER BY created_at DESC",
+        ["waiting"]
+      );
+
+      if (waitingBreakpoints.length === 0) {
+        if (message.chat?.id) {
+          await sendMessage(
+            config.token,
+            message.chat.id,
+            "✅ No waiting breakpoints."
+          );
+        }
+        continue;
+      }
+
+      const messages = [
+        `🔔 ${waitingBreakpoints.length} waiting breakpoint${waitingBreakpoints.length === 1 ? '' : 's'}:`,
+        ""
+      ];
+
+      for (let i = 0; i < waitingBreakpoints.length; i++) {
+        const bp = waitingBreakpoints[i];
+        const title = bp.title || "Untitled";
+        const runId = bp.run_id || "unknown";
+        const age = Math.floor((Date.now() - new Date(bp.created_at).getTime()) / 1000 / 60);
+        const ageStr = age < 1 ? "just now" : age === 1 ? "1 min ago" : `${age} mins ago`;
+
+        messages.push(`${i + 1}. ${title}`);
+        messages.push(`   ID: ${bp.id}`);
+        messages.push(`   Run: ${runId}`);
+        messages.push(`   Created: ${ageStr}`);
+
+        // Extract question from payload if available
+        try {
+          const payload = JSON.parse(bp.payload);
+          if (payload?.question) {
+            const question = payload.question.length > 100
+              ? `${payload.question.substring(0, 100)}...`
+              : payload.question;
+            messages.push(`   Question: ${question}`);
+          }
+        } catch {
+          // Ignore JSON parse errors
+        }
+
+        if (i < waitingBreakpoints.length - 1) {
+          messages.push("");
+        }
+      }
+
+      messages.push("");
+      messages.push("━━━━━━━━━━━━━━━━━");
+      messages.push("Commands:");
+      messages.push("• preview <number> - View full details");
+      messages.push("• file <number> - View context file");
+      messages.push("• Reply or send ID/text to release");
+
+      if (message.chat?.id) {
+        await sendMessage(
+          config.token,
+          message.chat.id,
+          messages.join("\n")
+        );
+      }
+      continue;
+    }
+
     if (trimmed.startsWith("/")) {
       if (message.chat?.id && message.from?.id) {
         rememberUser(
@@ -401,10 +562,67 @@ async function poll(db, config) {
         );
         await persistUser(db, config, message.chat.id, message.from.id);
         if (config.token) {
+          // Query for existing waiting breakpoints
+          const { all } = require("../api/db");
+          const waitingBreakpoints = await all(
+            db,
+            "SELECT id, title, created_at, run_id, payload FROM breakpoints WHERE status = ? ORDER BY created_at DESC",
+            ["waiting"]
+          );
+
+          // Build connection message with waiting breakpoints
+          const messages = [
+            "Telegram connected. I will notify you about breakpoints here."
+          ];
+
+          if (waitingBreakpoints.length > 0) {
+            messages.push("");
+            messages.push(`🔔 You have ${waitingBreakpoints.length} waiting breakpoint${waitingBreakpoints.length === 1 ? '' : 's'}:`);
+            messages.push("");
+
+            for (let i = 0; i < waitingBreakpoints.length; i++) {
+              const bp = waitingBreakpoints[i];
+              const title = bp.title || "Untitled";
+              const runId = bp.run_id || "unknown";
+              const age = Math.floor((Date.now() - new Date(bp.created_at).getTime()) / 1000 / 60);
+              const ageStr = age < 1 ? "just now" : age === 1 ? "1 min ago" : `${age} mins ago`;
+
+              messages.push(`${i + 1}. ${title}`);
+              messages.push(`   ID: ${bp.id}`);
+              messages.push(`   Run: ${runId}`);
+              messages.push(`   Created: ${ageStr}`);
+
+              // Extract question from payload if available
+              try {
+                const payload = JSON.parse(bp.payload);
+                if (payload?.question) {
+                  const question = payload.question.length > 100
+                    ? `${payload.question.substring(0, 100)}...`
+                    : payload.question;
+                  messages.push(`   Question: ${question}`);
+                }
+              } catch {
+                // Ignore JSON parse errors
+              }
+
+              if (i < waitingBreakpoints.length - 1) {
+                messages.push("");
+              }
+            }
+
+            messages.push("");
+            messages.push("━━━━━━━━━━━━━━━━━");
+            messages.push("Commands:");
+            messages.push("• list - Show waiting breakpoints");
+            messages.push("• preview <number> - View full details");
+            messages.push("• file <number> - View context file");
+            messages.push("• Reply or send ID/text to release");
+          }
+
           await sendMessage(
             config.token,
             message.chat.id,
-            "Telegram connected. I will notify you about breakpoints here."
+            messages.join("\n")
           );
         }
       }
@@ -413,6 +631,79 @@ async function poll(db, config) {
       }
       continue;
     }
+    // Handle preview/show command to display full breakpoint details by list number
+    const previewMatch = trimmed.match(/^(preview|show)\s+(\d+)$/i);
+    if (previewMatch) {
+      const listNumber = parseInt(previewMatch[2], 10);
+      const { all } = require("../api/db");
+      const waitingBreakpoints = await all(
+        db,
+        "SELECT id, title, created_at, run_id, payload FROM breakpoints WHERE status = ? ORDER BY created_at DESC",
+        ["waiting"]
+      );
+
+      if (listNumber < 1 || listNumber > waitingBreakpoints.length) {
+        if (message.chat?.id) {
+          await sendMessage(
+            config.token,
+            message.chat.id,
+            `Invalid number. Please use a number between 1 and ${waitingBreakpoints.length}.`
+          );
+        }
+        continue;
+      }
+
+      const bp = waitingBreakpoints[listNumber - 1];
+      let payload;
+      try {
+        payload = JSON.parse(bp.payload);
+      } catch {
+        payload = {};
+      }
+
+      const title = bp.title || "Untitled";
+      const question = payload?.question || "No question provided.";
+      const files = payload?.context?.files || [];
+      const fileLines = files.length
+        ? files
+            .map((file, index) => {
+              const format = file.format || "code";
+              const label = file.label || file.path || "unknown";
+              return `${index + 1}. ${label} (${format})`;
+            })
+            .join("\n")
+        : "None";
+
+      const age = Math.floor((Date.now() - new Date(bp.created_at).getTime()) / 1000 / 60);
+      const ageStr = age < 1 ? "just now" : age === 1 ? "1 min ago" : `${age} mins ago`;
+
+      const previewText = [
+        `🟠 Breakpoint #${listNumber} Details`,
+        "",
+        `Title: ${title}`,
+        `ID: ${bp.id}`,
+        `Run: ${bp.run_id || "unknown"}`,
+        `Created: ${ageStr}`,
+        "",
+        "Question:",
+        question,
+        "",
+        "Context files:",
+        fileLines,
+        "",
+        "━━━━━━━━━━━━━━━━━",
+        "To interact:",
+        `• View file: file ${bp.id} <path>`,
+        "• View file by number: file 1, file 2, etc.",
+        `• Release: Reply to this message or send: ${bp.id}`,
+      ].join("\n");
+
+      if (message.chat?.id) {
+        await sendMessage(config.token, message.chat.id, previewText);
+      }
+      continue;
+    }
+
     const fileMatch = trimmed.match(/^(file|raw)\s+(.+)$/i);
     if (fileMatch) {
       const mode = fileMatch[1].toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a5c-ai/babysitter-breakpoints",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "private": false,
   "type": "commonjs",
   "bin": {

package/web/app.js

@@ -488,17 +488,14 @@ notifySelect.addEventListener("change", async () => {
     if (Notification.permission !== "granted") {
       await Notification.requestPermission();
     }
-  }
-  updateNotifyStatus();
-});
-
-notifySelect.addEventListener("change", () => {
-  if ("Notification" in window) {
+    updateNotifyStatus();
     if (Notification.permission === "granted") {
       new Notification("Desktop alerts enabled", {
         body: "You will be notified of new waiting breakpoints.",
       });
     }
+  } else {
+    updateNotifyStatus();
   }
 });
 

package/web/styles.css

@@ -429,3 +429,174 @@ pre {
     grid-template-columns: 1fr;
   }
 }
+
+@media (max-width: 768px) {
+  .page {
+    padding: 24px 16px 48px;
+  }
+
+  .hero {
+    padding: 20px;
+  }
+
+  h1 {
+    font-size: clamp(24px, 5vw, 36px);
+  }
+
+  .controls {
+    grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+    gap: 12px;
+  }
+
+  .stats {
+    grid-template-columns: repeat(2, 1fr);
+  }
+
+  .extension-fields {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (max-width: 640px) {
+  .page {
+    padding: 16px 12px 32px;
+  }
+
+  .hero {
+    flex-direction: column;
+    padding: 16px;
+    gap: 16px;
+  }
+
+  .token-panel {
+    width: 100%;
+    min-width: 100%;
+  }
+
+  h1 {
+    font-size: clamp(22px, 6vw, 32px);
+    margin: 6px 0;
+  }
+
+  .subtitle {
+    font-size: 14px;
+  }
+
+  .controls {
+    grid-template-columns: 1fr;
+    gap: 10px;
+    margin: 16px 0;
+  }
+
+  .stats {
+    grid-template-columns: 1fr 1fr;
+    gap: 10px;
+    margin-bottom: 16px;
+  }
+
+  .stat-card {
+    padding: 12px;
+  }
+
+  .stat-label {
+    font-size: 10px;
+  }
+
+  .stat-value {
+    font-size: 20px;
+  }
+
+  .layout {
+    gap: 16px;
+  }
+
+  .list,
+  .detail {
+    padding: 16px;
+    min-height: 300px;
+  }
+
+  .section-title {
+    font-size: 14px;
+    margin-bottom: 10px;
+  }
+
+  .breakpoint-card {
+    padding: 10px;
+    gap: 4px;
+    font-size: 14px;
+  }
+
+  .detail-header {
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 8px;
+  }
+
+  .detail-header h2 {
+    font-size: 18px;
+  }
+
+  .detail-meta {
+    font-size: 12px;
+  }
+
+  pre {
+    padding: 10px;
+    font-size: 11px;
+  }
+
+  .feedback-actions {
+    flex-direction: column;
+  }
+
+  .feedback-actions input,
+  .feedback-actions button {
+    width: 100%;
+  }
+
+  button {
+    padding: 10px 12px;
+    font-size: 14px;
+  }
+
+  .context-layout {
+    gap: 10px;
+  }
+
+  .context-item {
+    padding: 6px;
+    font-size: 12px;
+  }
+
+  .context-viewer {
+    padding: 10px;
+    min-height: 150px;
+  }
+
+  .context-render {
+    font-size: 13px;
+  }
+
+  .extensions {
+    padding: 16px;
+    margin-top: 16px;
+  }
+
+  .extension-card {
+    padding: 12px;
+  }
+
+  .extension-fields {
+    grid-template-columns: 1fr;
+    gap: 10px;
+  }
+
+  .extension-actions {
+    flex-direction: column;
+  }
+
+  .extension-actions button {
+    width: 100%;
+  }
+}

package/worker/worker.js

@@ -37,14 +37,35 @@ async function loop() {
     // eslint-disable-next-line no-console
     console.log("[telegram] debug enabled");
   }
+
+  let consecutiveErrors = 0;
+  const MAX_CONSECUTIVE_ERRORS = 10;
+
   while (true) {
-    await runOnce();
+    try {
+      await runOnce();
+      consecutiveErrors = 0;
+    } catch (err) {
+      consecutiveErrors++;
+      // eslint-disable-next-line no-console
+      console.error(`[worker] error in runOnce (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}):`, err.message);
+
+      if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+        // eslint-disable-next-line no-console
+        console.error(`[worker] too many consecutive errors, exiting`);
+        process.exitCode = 1;
+        break;
+      }
+
+      const backoffDelay = Math.min(1000 * Math.pow(2, consecutiveErrors - 1), 30000);
+      // eslint-disable-next-line no-console
+      console.log(`[worker] backing off for ${backoffDelay}ms before retry`);
+      await new Promise((resolve) => setTimeout(resolve, backoffDelay));
+      continue;
+    }
+
     await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
   }
 }
 
-loop().catch((err) => {
-  // eslint-disable-next-line no-console
-  console.error(err);
-  process.exitCode = 1;
-});
+loop();

package/.codex/skills/babysitter-breakpoint/SKILL.md

@@ -1,35 +0,0 @@
----
-name: babysitter-breakpoint
-description: Use the breakpoint API to communicate with users during babysitter runs (post breakpoints, poll for release, fetch feedback, and read context files). Trigger whenever a babysitter workflow needs approval, input, or status updates via breakpoints.
----
-
-# babysitter-breakpoint
-
-Use this skill to handle all user communication via the `breakpoints` CLI. Do
-not prompt the user directly. Always post a breakpoint and poll until it is
-released, then fetch feedback and continue.
-
-## Workflow
-
-1. Create a breakpoint with the required payload and `payload.context.files`.
-2. Poll `breakpoints breakpoint wait <id> --interval 3` until `released`.
-3. Apply feedback from the printed details and continue.
-
-## Payload structure
-
-Always include a `context.files` array for referenced files:
-
-```json
-{
-  "context": {
-    "runId": "run-...",
-    "files": [
-      { "path": ".a5c/runs/<runId>/artifacts/process.md", "format": "markdown" },
-      { "path": ".a5c/runs/<runId>/inputs.json", "format": "code", "language": "json" },
-      { "path": ".a5c/runs/<runId>/code/main.js", "format": "code", "language": "javascript" }
-    ]
-  }
-}
-```
-
-See `references/breakpoint-api.md` for curl examples and endpoints.

package/.codex/skills/babysitter-breakpoint/references/breakpoint-api.md

@@ -1,57 +0,0 @@
-# Breakpoint CLI + API
-
-Use the `breakpoints` CLI to communicate with the user. The CLI wraps the local
-API. Never prompt directly.
-
-## Base URL
-- Default: `http://localhost:3000`
-- Override with `BREAKPOINT_API_URL` if set.
-
-## Auth
-- Agent token: `AGENT_TOKEN`
-- Human token: `HUMAN_TOKEN`
-- Use `Authorization: Bearer <token>` when set.
-
-## Create a breakpoint (agent)
-```bash
-breakpoints breakpoint create \
-  --question "Approve process + inputs + main.js?" \
-  --run-id run-... \
-  --title "Approval needed" \
-  --file ".a5c/runs/<runId>/artifacts/process.md,markdown" \
-  --file ".a5c/runs/<runId>/inputs.json,code,json" \
-  --file ".a5c/runs/<runId>/code/main.js,code,javascript"
-```
-
-## Poll for status
-```bash
-breakpoints breakpoint status <id>
-```
-
-## Fetch full details (including feedback)
-```bash
-breakpoints breakpoint show <id>
-```
-
-## Wait for release (prints details)
-```bash
-breakpoints breakpoint wait <id> --interval 3
-```
-
-## Fetch context file content (API)
-```bash
-curl -s "$BREAKPOINT_API_URL/api/breakpoints/<id>/context?path=path/to/file"
-```
-
-## Release with feedback (human)
-```bash
-curl -s -X POST "$BREAKPOINT_API_URL/api/breakpoints/<id>/feedback" \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer $HUMAN_TOKEN" \
-  -d '{"author":"reviewer","comment":"approved","release":true}'
-```
-
-## Notes
-- Poll every 2-10 seconds.
-- Continue orchestration only after `status` becomes `released` and feedback is retrieved.
-- Context files must be listed in the breakpoint payload and use allowlisted extensions.