@loicngr/kobo 1.6.8 → 1.6.10

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

@@ -21,6 +21,7 @@ export function createClaudeCodeEngine() {
                 effort: options.effort,
                 permissionMode: options.permissionMode ?? 'auto-accept',
                 skipPermissions: options.settings.dangerouslySkipPermissions ?? true,
+                permissionProfile: options.permissionProfile,
                 resumeFromEngineSessionId: options.resumeFromEngineSessionId,
                 mcpConfigPath,
             });
@@ -70,9 +71,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({

package/dist/server/services/agent/orchestrator.js

@@ -3,6 +3,7 @@ import { nanoid } from 'nanoid';
 import { getDb } from '../../db/index.js';
 import { ensureKoboHome, getCompiledMcpServerPath, getDbPath, getKoboHome, getMcpServerSourcePath, getSettingsPath, getSkillsPath, } from '../../utils/paths.js';
 import { unregisterProcess } from '../../utils/process-tracker.js';
+import * as autoLoopService from '../auto-loop-service.js';
 import { getEffectiveSettings } from '../settings-service.js';
 import * as wakeupService from '../wakeup-service.js';
 import { emitEphemeral } from '../websocket-service.js';
@@ -33,6 +34,8 @@ let availableSkills = (() => {
 })();
 /** workspaceId -> retry count (for quota backoff) */
 const retryCounts = new Map();
+/** Tracks workspaces where the current session failed due to a stale --resume session ID. */
+const resumeFailedSet = new Set();
 /** workspaceId -> backoff timer */
 const backoffTimers = new Map();
 // ── Watchdog ──────────────────────────────────────────────────────────────────
@@ -251,8 +254,33 @@ function reuseOrCreateFreshSession(workspaceId, existingSessionId) {
     return agentSessionId;
 }
 // ── Event handler ─────────────────────────────────────────────────────────────
+/**
+ * Snapshot of the `tasks` done-count at `session:started`, read back and
+ * cleared at `session:ended` to compute the per-session delta. Used by
+ * `auto-loop-service.onSessionEnded` for stall detection.
+ */
+const tasksDoneSnapshot = new Map();
+function getDoneTaskCount(workspaceId) {
+    const db = getDb();
+    const row = db
+        .prepare('SELECT COUNT(*) AS c FROM tasks WHERE workspace_id = ? AND status = ?')
+        .get(workspaceId, 'done');
+    return row.c;
+}
+/** Clear the in-memory done-count snapshot for a workspace (called on delete). */
+export function forgetTasksDoneSnapshot(workspaceId) {
+    tasksDoneSnapshot.delete(workspaceId);
+}
 function handleEvent(workspaceId, agentSessionId, ev) {
     routeEvent(workspaceId, agentSessionId, ev);
+    if (ev.kind === 'rate_limit') {
+        latestRateLimitInfo.set(workspaceId, ev.info);
+    }
+    // Snapshot the done-count at session start so the session:ended hook below
+    // can compute a delta for auto-loop stall detection.
+    if (ev.kind === 'session:started') {
+        tasksDoneSnapshot.set(workspaceId, getDoneTaskCount(workspaceId));
+    }
     if (ev.kind === 'tool:call' && ev.name === 'ScheduleWakeup') {
         const input = ev.input;
         const delay = typeof input?.delaySeconds === 'number' ? input.delaySeconds : 0;
@@ -274,7 +302,10 @@ function handleEvent(workspaceId, agentSessionId, ev) {
     }
     if (ev.kind === 'session:brainstorm-complete') {
         try {
-            updateWorkspaceStatus(workspaceId, 'executing');
+            const ws = getWs(workspaceId);
+            if (ws && ws.status !== 'executing') {
+                updateWorkspaceStatus(workspaceId, 'executing');
+            }
         }
         catch (err) {
             console.error('[orchestrator] Failed to transition to executing:', err);
@@ -283,8 +314,31 @@ function handleEvent(workspaceId, agentSessionId, ev) {
     if (ev.kind === 'error' && ev.category === 'quota') {
         handleQuota(workspaceId, agentSessionId);
     }
+    if (ev.kind === 'error' && ev.category === 'resume_failed') {
+        resumeFailedSet.add(workspaceId);
+        clearStaleEngineSessionId(workspaceId);
+    }
     if (ev.kind === 'session:ended') {
-        onSessionEnded(workspaceId, agentSessionId, ev.exitCode);
+        // Pop the resume_failed flag before any cleanup so both onSessionEnded paths see it.
+        const isResumeFailed = resumeFailedSet.delete(workspaceId);
+        // Compute the auto-loop done-delta BEFORE the internal cleanup because
+        // onSessionEnded(internal) may throw / trigger follow-ups; also read the
+        // snapshot FIRST so a later re-entry can't overwrite it.
+        const before = tasksDoneSnapshot.get(workspaceId) ?? getDoneTaskCount(workspaceId);
+        const after = getDoneTaskCount(workspaceId);
+        const delta = Math.max(0, after - before);
+        tasksDoneSnapshot.delete(workspaceId);
+        // Internal cleanup REMOVES the controller from the map. This must run
+        // BEFORE autoLoopService.onSessionEnded → spawnNextIteration → startAgent,
+        // otherwise startAgent throws "Agent already running" because the
+        // just-ended controller is still in the map.
+        onSessionEnded(workspaceId, agentSessionId, ev.exitCode, isResumeFailed);
+        // When a resume failed the session exited with an error but there's
+        // nothing wrong with the workspace — the stale session ID has been cleared
+        // and the next iteration will start fresh. Treat it as 'completed' so
+        // auto-loop continues without disabling.
+        const effectiveReason = isResumeFailed ? 'completed' : ev.reason;
+        autoLoopService.onSessionEnded(workspaceId, effectiveReason, delta);
     }
     if (ev.kind === 'session:started' && ev.engineSessionId) {
         sessionIds.set(workspaceId, ev.engineSessionId);
@@ -312,7 +366,9 @@ function handleEvent(workspaceId, agentSessionId, ev) {
         }
     }
 }
-function onSessionEnded(workspaceId, agentSessionId, exitCode) {
+function onSessionEnded(workspaceId, agentSessionId, exitCode, resumeFailed = false) {
+    const currentWorkspace = getWs(workspaceId);
+    const preserveQuotaBackoff = currentWorkspace?.status === 'quota';
     const ctrl = controllers.get(workspaceId);
     const wasStopping = ctrl?.status === 'stopping';
     // Identity-preserving cleanup: only remove the controller if the map still
@@ -322,7 +378,9 @@ function onSessionEnded(workspaceId, agentSessionId, exitCode) {
         controllers.delete(workspaceId);
     }
     unregisterProcess(workspaceId);
-    retryCounts.delete(workspaceId);
+    if (!preserveQuotaBackoff) {
+        retryCounts.delete(workspaceId);
+    }
     // Update the agent_sessions row
     try {
         const db = getDb();
@@ -336,13 +394,27 @@ function onSessionEnded(workspaceId, agentSessionId, exitCode) {
         // the "stopped" status. No legacy emit needed.
         return;
     }
-    // Clear any pending backoff timer on non-stopping exits
-    const pendingBackoff = backoffTimers.get(workspaceId);
-    if (pendingBackoff) {
-        clearTimeout(pendingBackoff);
-        backoffTimers.delete(workspaceId);
+    // When the session hit quota, handleQuota() already transitioned the
+    // workspace to `quota` and armed the retry timer. Keep that timer alive
+    // and preserve the `quota` status so auto-loop can resume after reset.
+    if (!preserveQuotaBackoff) {
+        const pendingBackoff = backoffTimers.get(workspaceId);
+        if (pendingBackoff) {
+            clearTimeout(pendingBackoff);
+            backoffTimers.delete(workspaceId);
+        }
+    }
+    if (preserveQuotaBackoff) {
+        try {
+            markWorkspaceUnread(workspaceId);
+            emitEphemeral(workspaceId, 'workspace:unread', { hasUnread: true });
+        }
+        catch {
+            // best-effort
+        }
+        return;
     }
-    if (exitCode !== null && exitCode !== 0) {
+    if (exitCode !== null && exitCode !== 0 && !resumeFailed) {
         try {
             updateWorkspaceStatus(workspaceId, 'error');
         }
@@ -408,6 +480,10 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         model,
         effort: reasoningEffort,
         permissionMode,
+        // Propagate the workspace's permission_profile to the engine (bypass vs
+        // strict). Defaults to 'bypass' — the pre-existing behavior — when the
+        // column is missing (fresh boot before migration landed) or unknown.
+        permissionProfile: ws?.permissionProfile === 'strict' ? 'strict' : 'bypass',
         resumeFromEngineSessionId,
         backendUrl: `http://127.0.0.1:${backendPort}`,
         koboHome: (() => {
@@ -517,12 +593,81 @@ export function getRunningCount() {
     return controllers.size;
 }
 /** Kobo built-in slash commands injected into the skill list (without leading /). */
-const KOBO_COMMANDS = ['kobo-check-progress'];
+const KOBO_COMMANDS = ['kobo-check-progress', 'kobo-prep-autoloop'];
 /** Cached list of slash commands discovered from the last agent init, plus Kobo built-ins. */
 export function getAvailableSkills() {
     return [...KOBO_COMMANDS, ...availableSkills];
 }
 // ── Quota handling ────────────────────────────────────────────────────────────
+/**
+ * Last `rate_limit.info` received per workspace. Used by handleQuota to
+ * schedule the backoff at the actual reset time instead of a hardcoded
+ * exponential. In-memory only — rebuilt on the next rate_limit event after
+ * a server restart.
+ */
+const latestRateLimitInfo = new Map();
+/** Clear the rate-limit info cache for a workspace (called on deleteWorkspace). */
+export function forgetRateLimitInfo(workspaceId) {
+    latestRateLimitInfo.delete(workspaceId);
+}
+/**
+ * Null out the engine_session_id on all agent_sessions rows for a workspace
+ * and clear the in-memory sessionIds cache. Called when a --resume attempt
+ * fails ("No conversation found with session ID") so that the next startAgent
+ * call starts a fresh conversation instead of retrying the stale ID.
+ */
+function clearStaleEngineSessionId(workspaceId) {
+    try {
+        const db = getDb();
+        db.prepare('UPDATE agent_sessions SET engine_session_id = NULL WHERE workspace_id = ?').run(workspaceId);
+        sessionIds.delete(workspaceId);
+    }
+    catch (err) {
+        console.error('[orchestrator] Failed to clear stale engine session ID:', err);
+    }
+}
+const QUOTA_SAFETY_MARGIN_MS = 30_000;
+const QUOTA_MAX_BACKOFF_MS = 24 * 60 * 60 * 1000;
+const QUOTA_SATURATION_THRESHOLD_PCT = 95;
+/**
+ * Fallback backoff ladder (in minutes) used when the `rate_limit` info
+ * isn't usable. Indexed by `retryCount`; anything past the last entry
+ * clamps to the final value (5 h) — long enough to cross a weekly
+ * bucket reset if the rate_limit info truly never arrives.
+ */
+const QUOTA_FALLBACK_LADDER_MINUTES = [15, 30, 60, 180, 300];
+/**
+ * Compute the delay before retrying a workspace hit by quota.
+ *
+ * Prefers the `resetsAt` of the saturated bucket with the furthest-future
+ * reset (a tighter bucket will unlock by then anyway). Falls back to a
+ * fixed ladder (15 → 30 → 60 → 180 → 300 min) whenever the rate_limit
+ * info is missing, malformed, or implausible.
+ */
+export function computeQuotaBackoffMs(workspaceId, retryCount) {
+    const info = latestRateLimitInfo.get(workspaceId);
+    if (info?.buckets?.length) {
+        const candidates = info.buckets
+            .filter((b) => b.usedPct >= QUOTA_SATURATION_THRESHOLD_PCT && typeof b.resetsAt === 'string')
+            .map((b) => ({ resetsAt: b.resetsAt, ts: new Date(b.resetsAt).getTime() }))
+            .filter((x) => !Number.isNaN(x.ts))
+            .sort((a, b) => b.ts - a.ts);
+        const chosen = candidates[0];
+        if (chosen) {
+            const delta = chosen.ts - Date.now() + QUOTA_SAFETY_MARGIN_MS;
+            if (delta > 0 && delta <= QUOTA_MAX_BACKOFF_MS) {
+                return { delayMs: delta, resetsAt: chosen.resetsAt, source: 'rate_limit_info' };
+            }
+        }
+    }
+    const idx = Math.min(Math.max(0, retryCount), QUOTA_FALLBACK_LADDER_MINUTES.length - 1);
+    const backoffMinutes = QUOTA_FALLBACK_LADDER_MINUTES[idx];
+    return { delayMs: backoffMinutes * 60 * 1000, source: 'exponential_fallback' };
+}
+/** @internal Test-only. */
+export function _test_setRateLimitInfo(workspaceId, info) {
+    latestRateLimitInfo.set(workspaceId, info);
+}
 function handleQuota(workspaceId, _agentSessionId) {
     try {
         updateWorkspaceStatus(workspaceId, 'quota');
@@ -533,16 +678,19 @@ function handleQuota(workspaceId, _agentSessionId) {
     // The quota state is already signalled by the `error { category: 'quota' }`
     // AgentEvent that triggered this handler. No legacy `agent:status { quota }`
     // emit needed.
-    // 15min first, then 30min, then 60min cap
+    // Prefer the actual resetsAt from the last rate_limit event; fall back to
+    // the 15/30/60min exponential schedule when that info isn't usable.
     const retryCount = retryCounts.get(workspaceId) ?? 0;
-    const backoffMinutes = Math.min(15 * 2 ** retryCount, 60);
-    const backoffMs = backoffMinutes * 60 * 1000;
+    const { delayMs, resetsAt, source } = computeQuotaBackoffMs(workspaceId, retryCount);
+    const backoffMs = delayMs;
     retryCounts.set(workspaceId, retryCount + 1);
     // Surface the backoff schedule as an ephemeral event so the UI can display
     // retry count / wait time without polluting the persistent event log.
     emitEphemeral(workspaceId, 'agent:quota-backoff', {
         retryCount: retryCount + 1,
-        backoffMinutes,
+        backoffMinutes: Math.round(delayMs / 60_000),
+        resetsAt,
+        source,
     });
     const timer = setTimeout(() => {
         backoffTimers.delete(workspaceId);
@@ -552,8 +700,13 @@ function handleQuota(workspaceId, _agentSessionId) {
                 return;
             }
             try {
-                const freshWorkingDir = `${freshWs.projectPath}/.worktrees/${freshWs.workingBranch}`;
-                startAgent(workspaceId, freshWorkingDir, 'Continue the previous task where you left off.', undefined, true);
+                if (freshWs.autoLoop) {
+                    autoLoopService.onQuotaBackoffExpired(workspaceId);
+                }
+                else {
+                    const freshWorkingDir = `${freshWs.projectPath}/.worktrees/${freshWs.workingBranch}`;
+                    startAgent(workspaceId, freshWorkingDir, 'Continue the previous task where you left off.', undefined, true);
+                }
             }
             catch (err) {
                 console.error(`[orchestrator] Quota retry for workspace '${workspaceId}' failed:`, err);
@@ -597,4 +750,4 @@ export function _runWatchdogForTest() {
     runWatchdog();
 }
 /** Test-only export. Not part of the public module API. */
-export const __test__ = { handleEvent };
+export const __test__ = { handleEvent, handleQuota };