@loicngr/kobo 1.6.8 → 1.6.9

package/AGENTS.md

@@ -96,15 +96,18 @@ src/
 
 | Table | Purpose |
 |---|---|
-| `workspaces` | the unit of work — id, name, project_path, source_branch, working_branch, status, notion_url, model, dev_server_status, `archived_at`, timestamps |
+| `workspaces` | the unit of work — id, name, project_path, source_branch, working_branch, status, notion_url, model, dev_server_status, `archived_at`, `auto_loop`, `auto_loop_ready`, `no_progress_streak`, timestamps |
 | `tasks` | workspace sub-items — title, status, `is_acceptance_criterion`, sort_order; CASCADE DELETE on workspace |
 | `agent_sessions` | Claude Code CLI invocations — pid, `claude_session_id`, status, started_at, ended_at, `name` |
 | `ws_events` | persisted WebSocket events for replay on reconnect — type, payload, session_id, created_at |
+| `pending_wakeups` | one-row-per-workspace scheduler for the `ScheduleWakeup` tool — target_at (ISO UTC), prompt, reason; CASCADE DELETE on workspace |
 
 `status` enum: `created | extracting | brainstorming | executing | completed | idle | error | quota`. Transitions are validated in `updateWorkspaceStatus` against `VALID_TRANSITIONS`.
 
 `archived_at` is **orthogonal** to `status` — archiving is a visibility flag, not a lifecycle state. Unarchive restores the exact pre-archive `status`.
 
+`auto_loop` (bool, default 0), `auto_loop_ready` (bool, default 0) and `no_progress_streak` (int, default 0) drive the auto-loop feature: when `auto_loop=1`, `session:ended` triggers `auto-loop-service.onSessionEnded` which either spawns the next iteration via a fresh `startAgent(resume=false)`, disables with `reason='completed'` (no pending tasks), or disables with `reason='stall'` (3 consecutive sessions without a task completed). Archive + delete both auto-disable.
+
 ## Database migrations
 
 **The project is in production**. Every schema change MUST ship as an incremental migration that preserves existing data. Never drop-and-recreate, never rely on `initSchema` alone to patch running databases.

package/README.md

@@ -30,6 +30,9 @@ Think of it as an apprentice's hall: you hand out missions, each apprentice sets
 - **Resizable right drawer** — drag-to-resize horizontally and vertically, with tab state and split ratio persisted to localStorage
 - **Soft interrupt** — pause an agent mid-execution (SIGINT, like pressing Escape in Claude Code) without killing the process; the agent stops the current tool and waits for the next message
 - **Archive instead of delete** — soft-remove workspaces without losing the worktree, branches, or history; unarchive restores the exact pre-archive state
+- **Auto-loop mode** — opt-in, per-workspace: when enabled, Kōbō spawns a fresh Claude session for the next pending task after every `session:ended`, walking through the task list until all are `done`. Stops automatically on error, on stall (3 consecutive sessions with no task completed), or when the user clicks Stop. A grooming step (`/kobo-prep-autoloop`) ensures tasks are atomic before the loop runs; Notion-imported workspaces with both todos and acceptance criteria are auto-unlocked
+- **Quota-aware retry backoff** — when a Claude rate limit is hit mid-session, Kōbō schedules the retry at the actual reset time reported by the API (via `rate_limit.info.buckets[].resetsAt`), falling back to a 15 → 30 → 60 → 180 → 300 min ladder only when the reset info is missing or implausible
+- **Scheduled wakeups** — the `ScheduleWakeup` tool is honoured server-side: Kōbō persists the wakeup in SQLite, rehydrates on restart, and respawns the agent with `--resume` at the target time
 
 ## Tech stack
 

package/dist/mcp-server/kobo-tasks-handlers.js

@@ -18,6 +18,22 @@ export function listTasksHandler(db, workspaceId) {
         .all(workspaceId);
     return rows.map(rowToDto);
 }
+/**
+ * Flip the workspace's `auto_loop_ready` flag. Called at the end of a
+ * `/kobo-prep-autoloop` grooming session to unlock the auto-loop toggle.
+ *
+ * The DB write itself happens here; the caller in kobo-tasks-server.ts
+ * also fires a notify-autoloop-ready POST so the backend emits
+ * `autoloop:ready-flipped` over WebSocket and any live frontend refreshes.
+ */
+export function markAutoLoopReadyHandler(db, workspaceId) {
+    const row = db.prepare('SELECT id FROM workspaces WHERE id = ?').get(workspaceId);
+    if (!row) {
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    }
+    db.prepare('UPDATE workspaces SET auto_loop_ready = 1 WHERE id = ?').run(workspaceId);
+    return { ok: true };
+}
 /** Set a task's status to "done" and return the updated task. */
 export function markTaskDoneHandler(db, workspaceId, taskId) {
     const now = new Date().toISOString();
@@ -136,7 +152,7 @@ export function getSettingsHandler(settingsPath, projectPath) {
 /** Fetch workspace metadata from the database, computing the worktree path from project_path and working_branch. */
 export function getWorkspaceInfoHandler(db, workspaceId) {
     const row = db
-        .prepare('SELECT id, name, project_path, source_branch, working_branch, status, notion_url, notion_page_id, model, dev_server_status, has_unread, created_at, updated_at FROM workspaces WHERE id = ?')
+        .prepare('SELECT id, name, project_path, source_branch, working_branch, status, notion_url, notion_page_id, model, dev_server_status, has_unread, auto_loop, auto_loop_ready, created_at, updated_at FROM workspaces WHERE id = ?')
         .get(workspaceId);
     if (!row) {
         throw new Error(`Workspace '${workspaceId}' not found`);
@@ -154,6 +170,8 @@ export function getWorkspaceInfoHandler(db, workspaceId) {
         notionPageId: row.notion_page_id,
         devServerStatus: row.dev_server_status,
         hasUnread: row.has_unread === 1,
+        autoLoop: row.auto_loop === 1,
+        autoLoopReady: row.auto_loop_ready === 1,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };

package/dist/mcp-server/kobo-tasks-server.js

@@ -5,7 +5,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import Database from 'better-sqlite3';
-import { createTaskHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, logThoughtHandler, markTaskDoneHandler, readDocumentHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
+import { createTaskHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, logThoughtHandler, markAutoLoopReadyHandler, markTaskDoneHandler, readDocumentHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
 const workspaceId = process.env.KOBO_WORKSPACE_ID;
 const dbPath = process.env.KOBO_DB_PATH;
 const settingsPath = process.env.KOBO_SETTINGS_PATH;
@@ -52,6 +52,22 @@ async function notifyTasksUpdated() {
         console.error('[kobo-tasks-server] notify-updated failed:', err);
     }
 }
+/**
+ * Fire-and-forget POST that lands on `/auto-loop-ready`, which itself emits
+ * the `autoloop:ready-flipped` WS event so the frontend's toggle unlocks
+ * immediately after the grooming session completes. The handler already
+ * flipped the DB flag; this call is ONLY for the event emission + the
+ * (harmless) idempotent second write.
+ */
+async function notifyAutoLoopReady() {
+    try {
+        const url = `${backendUrl}/api/workspaces/${workspaceId}/auto-loop-ready`;
+        await fetch(url, { method: 'POST' });
+    }
+    catch (err) {
+        console.error('[kobo-tasks-server] notify-autoloop-ready failed:', err);
+    }
+}
 /** Generic HTTP request to the Kobo backend, returning parsed JSON or null. */
 async function backendRequest(method, pathname, body) {
     const url = `${backendUrl}${pathname}`;
@@ -87,6 +103,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ['task_id'],
             },
         },
+        {
+            name: 'mark_auto_loop_ready',
+            description: 'CALL ONLY at the end of a `/kobo-prep-autoloop` grooming session, once all tasks look atomic and implementable in one session. Flips a flag on the workspace that unlocks the auto-loop toggle in the UI. Do NOT call during normal sessions.',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
         {
             name: 'create_task',
             description: 'CALL WHEN you discover follow-up work that was not in the original list and needs to stick around (e.g. "refactor this helper later", "add a test for edge case"). Appends at the end of the list. Do not use it for ephemeral internal notes — prefer log_thought for those.',
@@ -296,6 +317,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             void notifyBackend(taskId);
             return ok(result);
         }
+        if (name === 'mark_auto_loop_ready') {
+            const result = markAutoLoopReadyHandler(db, workspaceId);
+            void notifyAutoLoopReady();
+            return ok(result);
+        }
         if (name === 'create_task') {
             const title = a.title;
             if (!title)

package/dist/server/db/migrations.js

@@ -101,6 +101,17 @@ export const migrations = [
         )`).run();
         },
     },
+    {
+        version: 12,
+        name: 'add-auto-loop-columns',
+        migrate: (db) => {
+            db.transaction(() => {
+                db.prepare('ALTER TABLE workspaces ADD COLUMN auto_loop INTEGER NOT NULL DEFAULT 0').run();
+                db.prepare('ALTER TABLE workspaces ADD COLUMN auto_loop_ready INTEGER NOT NULL DEFAULT 0').run();
+                db.prepare('ALTER TABLE workspaces ADD COLUMN no_progress_streak INTEGER NOT NULL DEFAULT 0').run();
+            })();
+        },
+    },
 ];
 /** Current schema version — always equals the highest migration version. */
 export const SCHEMA_VERSION = migrations.length > 0 ? migrations[migrations.length - 1].version : 1;

package/dist/server/db/schema.js

@@ -19,6 +19,9 @@ export function initSchema(db) {
       favorited_at TEXT,
       tags TEXT NOT NULL DEFAULT '[]',
       engine TEXT NOT NULL DEFAULT 'claude-code',
+      auto_loop INTEGER NOT NULL DEFAULT 0,
+      auto_loop_ready INTEGER NOT NULL DEFAULT 0,
+      no_progress_streak INTEGER NOT NULL DEFAULT 0,
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
     );

package/dist/server/index.js

@@ -21,6 +21,7 @@ import settingsRouter from './routes/settings.js';
 import templatesRouter from './routes/templates.js';
 import workspacesRouter from './routes/workspaces.js';
 import { getAvailableSkills, reconcileOrphanSessions, sendMessage, setBackendPort, startAgent, startWatchdog, stopAgent, stopWatchdog, } from './services/agent/orchestrator.js';
+import * as autoLoopService from './services/auto-loop-service.js';
 import { runContentMigrationIfNeeded } from './services/content-migration-service.js';
 import { createDailyDbBackupIfNeeded } from './services/db-backup-service.js';
 import { startDevServer, stopDevServer } from './services/dev-server-service.js';
@@ -59,6 +60,7 @@ initProcessCleanup();
 reconcileOrphanSessions();
 startWatchdog();
 wakeupService.rehydrate();
+autoLoopService.rehydrate();
 startPrWatcher();
 // Create Hono app
 const app = new Hono();

package/dist/server/routes/workspaces.js

@@ -4,10 +4,12 @@ const execFileAsync = promisify(execFileCb);
 import fs from 'node:fs';
 import path from 'node:path';
 import { Hono } from 'hono';
+import { AUTO_LOOP_GROOMING_STEPS, AUTO_LOOP_HARD_RULES } from '../../shared/auto-loop-prompts.js';
 import { getDb } from '../db/index.js';
 import { migrationGuard } from '../middleware/migration-guard.js';
 import { listEngines } from '../services/agent/engines/registry.js';
 import * as agentManager from '../services/agent/orchestrator.js';
+import * as autoLoopService from '../services/auto-loop-service.js';
 import * as devServerService from '../services/dev-server-service.js';
 import * as notionService from '../services/notion-service.js';
 import { renderPrTemplate } from '../services/pr-template-service.js';
@@ -453,7 +455,23 @@ app.post('/', migrationGuard, async (c) => {
                 brainstormPrompt += `\n# Git conventions\nIMPORTANT: Before any git operation (commit, branch, rebase, merge, push), read and apply the conventions defined in \`.ai/.git-conventions.md\`. They are project-specific and override any default behavior. Re-read this file if you're unsure or if context was compacted.\n`;
             }
             brainstormPrompt += `\nIMPORTANT: Start by reading CLAUDE.md and/or AGENTS.md at the project root if they exist — they contain project conventions and instructions you must follow.`;
-            brainstormPrompt += `\n\nThen brainstorm the implementation approach. Explore the codebase to understand the existing structure. Ask clarifying questions if needed. When you're done brainstorming and have a clear plan, create a plan file and proceed with implementation. Once you have completed the brainstorming phase, output [BRAINSTORM_COMPLETE] on its own line.`;
+            if (body.autoLoop === true) {
+                // Auto-loop is armed — brainstorm must end with task seeding + mark-ready,
+                // NOT with implementation. The auto-loop will drive implementation after.
+                // The grooming steps + hard rules are shared with the PREP_AUTOLOOP_PROMPT
+                // sent by the "Prepare for auto-loop" button (src/shared/auto-loop-prompts.ts).
+                brainstormPrompt += `\n\nThen brainstorm the implementation approach. Explore the codebase to understand the existing structure. Ask clarifying questions if needed. When you have a clear plan, create a plan file.
+
+Auto-loop mode is active for this workspace. After the plan is ready, DO NOT implement anything. Instead:
+
+${AUTO_LOOP_GROOMING_STEPS}
+5. Output [BRAINSTORM_COMPLETE] on its own line and end your turn cleanly.
+
+${AUTO_LOOP_HARD_RULES}`;
+            }
+            else {
+                brainstormPrompt += `\n\nThen brainstorm the implementation approach. Explore the codebase to understand the existing structure. Ask clarifying questions if needed. When you're done brainstorming and have a clear plan, create a plan file and proceed with implementation. Once you have completed the brainstorming phase, output [BRAINSTORM_COMPLETE] on its own line.`;
+            }
             try {
                 const agent = agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, workspace.model, false, workspace.permissionMode, undefined, workspace.reasoningEffort);
                 // Persist the initial prompt in the feed so it's visible in the chat,
@@ -471,6 +489,22 @@ app.post('/', migrationGuard, async (c) => {
                 }
             }
         }
+        // Apply the auto-loop checkbox from CreatePage. Notion-imported workspaces
+        // with both todos AND gherkin features auto-unlock `auto_loop_ready=1` —
+        // they're considered good enough to drive the loop without grooming.
+        if (body.autoLoop === true) {
+            const notionProducedTasks = body.notionUrl !== undefined &&
+                notionContent != null &&
+                notionContent.todos.length > 0 &&
+                notionContent.gherkinFeatures.length > 0;
+            const db = getDb();
+            db.prepare('UPDATE workspaces SET auto_loop = 1, auto_loop_ready = ? WHERE id = ?').run(notionProducedTasks ? 1 : 0, workspace.id);
+            // Emit events so the frontend refreshes autoLoopStates without F5.
+            wsService.emitEphemeral(workspace.id, 'autoloop:enabled', {});
+            if (notionProducedTasks) {
+                wsService.emitEphemeral(workspace.id, 'autoloop:ready-flipped', {});
+            }
+        }
         // Return created workspace with tasks
         const workspaceWithTasks = workspaceService.getWorkspaceWithTasks(workspace.id);
         return c.json(workspaceWithTasks, 201);
@@ -531,6 +565,81 @@ app.get('/pr-states', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/workspaces/auto-loop-states — batch snapshot keyed by workspace id.
+// Used by the drawer + Pinia store. Static path — must be BEFORE /:id.
+app.get('/auto-loop-states', (c) => {
+    try {
+        const db = getDb();
+        const rows = db
+            .prepare('SELECT id, auto_loop, auto_loop_ready, no_progress_streak FROM workspaces WHERE archived_at IS NULL')
+            .all();
+        const out = {};
+        for (const r of rows) {
+            out[r.id] = {
+                auto_loop: r.auto_loop === 1,
+                auto_loop_ready: r.auto_loop_ready === 1,
+                no_progress_streak: r.no_progress_streak,
+            };
+        }
+        return c.json(out);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// GET /api/workspaces/:id/auto-loop — current auto-loop status for one workspace.
+app.get('/:id/auto-loop', (c) => {
+    try {
+        return c.json(autoLoopService.getStatus(c.req.param('id')));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// POST /api/workspaces/:id/auto-loop — enable the loop (user toggle ON).
+app.post('/:id/auto-loop', (c) => {
+    try {
+        autoLoopService.enable(c.req.param('id'));
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 400);
+    }
+});
+// DELETE /api/workspaces/:id/auto-loop — disable the loop (user toggle OFF).
+app.delete('/:id/auto-loop', (c) => {
+    try {
+        autoLoopService.disable(c.req.param('id'), 'user-action');
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// POST /api/workspaces/:id/auto-loop-ready — force auto_loop_ready=true.
+// Used by the "Force ready (skip grooming)" UI button AND by the MCP tool
+// `kobo__mark_auto_loop_ready` at the end of a grooming session. Emits a
+// WS event so any live frontend refreshes the toggle state immediately.
+app.post('/:id/auto-loop-ready', (c) => {
+    try {
+        const id = c.req.param('id');
+        const ws = workspaceService.getWorkspace(id);
+        if (!ws)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        workspaceService.setAutoLoopReady(id, true);
+        wsService.emitEphemeral(id, 'autoloop:ready-flipped', {});
+        autoLoopService.onAutoLoopReadySet(id);
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // GET /api/workspaces/:id/pending-wakeup — returns the pending wakeup or null.
 app.get('/:id/pending-wakeup', (c) => {
     try {
@@ -747,6 +856,9 @@ app.get('/:id/events', (c) => {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
         const before = c.req.query('before'); // event ID cursor
+        // optional: scope to a session view. Session views also include
+        // workspace-level rows where session_id IS NULL (legacy/pre-session items).
+        const session = c.req.query('session');
         const limit = Math.min(parseInt(c.req.query('limit') ?? '100', 10) || 100, 500);
         const db = getDb();
         let rows;
@@ -756,18 +868,29 @@ app.get('/:id/events', (c) => {
             if (!cursorRow) {
                 return c.json({ events: [], hasMore: false });
             }
-            rows = db
-                .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND rowid < ? ORDER BY rowid DESC LIMIT ?')
-                .all(id, cursorRow.rowid, limit);
+            rows = session
+                ? db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) AND rowid < ? ORDER BY rowid DESC LIMIT ?')
+                    .all(id, session, cursorRow.rowid, limit)
+                : db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND rowid < ? ORDER BY rowid DESC LIMIT ?')
+                    .all(id, cursorRow.rowid, limit);
         }
         else {
-            // No cursor — return the oldest events
-            rows = db
-                .prepare('SELECT * FROM ws_events WHERE workspace_id = ? ORDER BY rowid ASC LIMIT ?')
-                .all(id, limit);
-        }
-        // Reverse to chronological order (we queried DESC for "before" pagination)
-        if (before)
+            // No cursor — return events. When filtering by session, we want the
+            // MOST RECENT events of that session first (so the feed renders from
+            // the end), reversed to chronological order below.
+            rows = session
+                ? db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) ORDER BY rowid DESC LIMIT ?')
+                    .all(id, session, limit)
+                : db
+                    .prepare('SELECT * FROM ws_events WHERE workspace_id = ? ORDER BY rowid ASC LIMIT ?')
+                    .all(id, limit);
+        }
+        // Reverse to chronological order (we queried DESC for "before" pagination,
+        // or for the "session + no cursor" case where we fetched the newest first).
+        if (before || session)
             rows.reverse();
         const events = rows.map((row) => {
             let parsedPayload;
@@ -788,13 +911,25 @@ app.get('/:id/events', (c) => {
         });
         // Check if there are more older events beyond what we returned
         let hasMore = false;
-        if (before && rows.length > 0) {
-            const firstRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ?').get(rows[0].id);
-            if (firstRow) {
-                const older = db
-                    .prepare('SELECT COUNT(*) as c FROM ws_events WHERE workspace_id = ? AND rowid < ?')
-                    .get(id, firstRow.rowid);
-                hasMore = older.c > 0;
+        if (rows.length > 0) {
+            if (before) {
+                const firstRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ?').get(rows[0].id);
+                if (firstRow) {
+                    const older = session
+                        ? db
+                            .prepare('SELECT COUNT(*) as c FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL) AND rowid < ?')
+                            .get(id, session, firstRow.rowid)
+                        : db
+                            .prepare('SELECT COUNT(*) as c FROM ws_events WHERE workspace_id = ? AND rowid < ?')
+                            .get(id, firstRow.rowid);
+                    hasMore = older.c > 0;
+                }
+            }
+            else if (session) {
+                const total = db
+                    .prepare('SELECT COUNT(*) as c FROM ws_events WHERE workspace_id = ? AND (session_id = ? OR session_id IS NULL)')
+                    .get(id, session);
+                hasMore = total.c > rows.length;
             }
         }
         return c.json({ events, hasMore });

package/dist/server/services/agent/engines/claude-code/engine.js

@@ -70,9 +70,14 @@ export function createClaudeCodeEngine() {
                     lower.includes('rate_limit_exceeded') ||
                     (lower.includes('429') && lower.includes('rate')) ||
                     lower.includes('quota exceeded');
+                const isResumeFailed = lower.includes('no conversation found with session id');
                 if (isQuota) {
                     onEvent({ kind: 'error', category: 'quota', message: line });
                 }
+                else if (isResumeFailed) {
+                    onEvent({ kind: 'error', category: 'resume_failed', message: line });
+                    console.warn(`[claude-engine stderr] ${line}`);
+                }
                 else if (line.trim().length > 0 && !isBenignStderr(line)) {
                     console.warn(`[claude-engine stderr] ${line}`);
                 }

package/dist/server/services/agent/engines/claude-code/stream-parser.js

@@ -26,6 +26,161 @@ function makeBucket(id, source) {
     const details = used !== undefined && limit !== undefined ? `${String(used)} / ${String(limit)}` : undefined;
     return { id, label, usedPct: Math.max(0, Math.min(100, usedPct)), resetsAt, details };
 }
+// ── Text-based quota detection ────────────────────────────────────────────────
+// When the `claude -p` CLI hits a rate limit mid-turn, it often does NOT emit
+// a structured `rate_limit_event` nor an error on stderr — it just writes a
+// plain-text message like:
+//     "You've hit your limit · resets 1:20pm (Europe/Paris)"
+// and exits cleanly. Without the pattern below we'd see `session:ended` with
+// `reason: 'completed'` and the auto-loop would spawn the next iteration
+// immediately, only to hit the same wall again, N times, until stall kicks in.
+//
+// The regex captures the reset time (e.g. "1:20pm") and the timezone in
+// parentheses (e.g. "Europe/Paris") so we can convert to an ISO 8601
+// timestamp and feed handleQuota the same way a structured event would.
+const QUOTA_TEXT_PATTERN = /you(?:'ve|\s+have)\s+hit\s+your\s+limit[^.\n]*?resets\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:\(([^)]+)\))?/i;
+function extractZonedDateTimeParts(date, timeZone) {
+    try {
+        const formatter = new Intl.DateTimeFormat('en-CA', {
+            timeZone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false,
+        });
+        const parts = formatter.formatToParts(date);
+        const read = (type) => {
+            const value = parts.find((part) => part.type === type)?.value;
+            if (!value)
+                return null;
+            const parsed = Number.parseInt(value, 10);
+            return Number.isNaN(parsed) ? null : parsed;
+        };
+        const year = read('year');
+        const month = read('month');
+        const day = read('day');
+        const hour = read('hour');
+        const minute = read('minute');
+        const second = read('second');
+        if ([year, month, day, hour, minute, second].some((value) => value === null))
+            return null;
+        return {
+            year: year,
+            month: month,
+            day: day,
+            hour: hour,
+            minute: minute,
+            second: second,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function dateTimePartsToUtcMs(parts) {
+    return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second, 0);
+}
+function zonedDateTimeToUtc(parts, timeZone) {
+    let guess = new Date(dateTimePartsToUtcMs(parts));
+    for (let i = 0; i < 4; i += 1) {
+        const observed = extractZonedDateTimeParts(guess, timeZone);
+        if (!observed)
+            return undefined;
+        const diffMs = dateTimePartsToUtcMs(parts) - dateTimePartsToUtcMs(observed);
+        if (diffMs === 0)
+            return guess.toISOString();
+        guess = new Date(guess.getTime() + diffMs);
+    }
+    const observed = extractZonedDateTimeParts(guess, timeZone);
+    if (observed &&
+        observed.year === parts.year &&
+        observed.month === parts.month &&
+        observed.day === parts.day &&
+        observed.hour === parts.hour &&
+        observed.minute === parts.minute) {
+        return guess.toISOString();
+    }
+    return undefined;
+}
+/**
+ * Parse the time string Claude outputs (e.g. "1:20pm" + "Europe/Paris")
+ * into an ISO 8601 UTC timestamp. Returns `undefined` if anything looks
+ * off so handleQuota falls back to its ladder.
+ */
+function parseQuotaResetsAt(hourStr, minuteStr, ampm, tz, now = new Date()) {
+    const hour24 = (() => {
+        const h = Number.parseInt(hourStr, 10);
+        if (Number.isNaN(h) || h < 0 || h > 23)
+            return null;
+        if (!ampm)
+            return h;
+        const pm = ampm.toLowerCase() === 'pm';
+        if (h === 12)
+            return pm ? 12 : 0;
+        return pm ? h + 12 : h;
+    })();
+    if (hour24 === null)
+        return undefined;
+    const minute = minuteStr ? Number.parseInt(minuteStr, 10) : 0;
+    if (Number.isNaN(minute) || minute < 0 || minute > 59)
+        return undefined;
+    if (tz) {
+        const zonedNow = extractZonedDateTimeParts(now, tz);
+        if (zonedNow) {
+            const targetDate = new Date(Date.UTC(zonedNow.year, zonedNow.month - 1, zonedNow.day));
+            const nowInZoneMs = dateTimePartsToUtcMs(zonedNow);
+            const targetTodayMs = Date.UTC(zonedNow.year, zonedNow.month - 1, zonedNow.day, hour24, minute, 0, 0);
+            if (targetTodayMs < nowInZoneMs - 60_000) {
+                targetDate.setUTCDate(targetDate.getUTCDate() + 1);
+            }
+            const zonedIso = zonedDateTimeToUtc({
+                year: targetDate.getUTCFullYear(),
+                month: targetDate.getUTCMonth() + 1,
+                day: targetDate.getUTCDate(),
+                hour: hour24,
+                minute,
+                second: 0,
+            }, tz);
+            if (zonedIso)
+                return zonedIso;
+        }
+    }
+    // Fallback for missing/invalid timezone names: interpret the wall-clock time
+    // in the local machine timezone so quota handling still works on plain
+    // "resets 11am" messages.
+    const target = new Date(now);
+    target.setHours(hour24, minute, 0, 0);
+    if (target.getTime() < now.getTime() - 60_000) {
+        target.setDate(target.getDate() + 1);
+    }
+    return target.toISOString();
+}
+/**
+ * Scan a text block for a quota announcement. Returns synthetic
+ * `rate_limit` + `error { category: 'quota' }` events when the pattern
+ * matches, otherwise `null`. The caller pushes both events into the
+ * stream so handleQuota picks up the reset time and schedules the
+ * retry at the parsed moment.
+ */
+function extractQuotaFromText(text) {
+    const match = QUOTA_TEXT_PATTERN.exec(text);
+    if (!match)
+        return null;
+    const [, hourStr, minuteStr, ampm, tz] = match;
+    const resetsAt = parseQuotaResetsAt(hourStr, minuteStr, ampm, tz);
+    const bucket = {
+        id: 'text-detected',
+        usedPct: 100,
+        resetsAt,
+    };
+    return {
+        error: { kind: 'error', category: 'quota', message: match[0] },
+        rateLimit: { kind: 'rate_limit', info: { buckets: [bucket] } },
+    };
+}
 function normalizeRateLimitInfo(info) {
     const buckets = [];
     if (typeof info.rateLimitType === 'string') {
@@ -149,6 +304,13 @@ export function parseClaudeLine(line, state) {
             if (blockType === 'text' && typeof block.text === 'string') {
                 events.push({ kind: 'message:text', messageId, text: block.text, streaming: true });
                 msgState.sawText = true;
+                // Synthesise quota events when the CLI reports the limit in prose.
+                // See extractQuotaFromText above for why this is needed in `-p` mode.
+                const synth = extractQuotaFromText(block.text);
+                if (synth) {
+                    events.push(synth.rateLimit);
+                    events.push(synth.error);
+                }
             }
             if (blockType === 'tool_use') {
                 events.push({