qiksy 1.1.2 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qiksy",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "Qiksy \u2014 one local engine for every Qiksy tool (Work Finder, Travel Assistant, Client Finder). Runs on your own Claude; nothing leaves your machine.",
   "type": "module",
   "bin": {

package/tools/client-finder/vendor/lib/agent.mjs

@@ -11,6 +11,7 @@
 import { spawnClaude } from './spawn-claude.mjs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { classifyClaudeError } from './claude-errors.mjs';
 
 export const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -92,6 +93,7 @@ export function runClaude({
     child.on('close', () => activeChildren.delete(child));
 
     let resultText = '';
+    let errSubtype = null;
     let errText = '';
     let costUsd = null;
     let settled = false;
@@ -112,7 +114,7 @@ export function runClaude({
       } catch {
         /* already dead */
       }
-      finish({ ok: false, error: `timeout after ${Math.round(timeoutMs / 1000)}s` });
+      finish({ ok: false, error: `timeout after ${Math.round(timeoutMs / 1000)}s`, code: 'timeout' });
     }, timeoutMs);
 
     if (signal) {
@@ -122,7 +124,7 @@ export function runClaude({
         } catch {
           /* already dead */
         }
-        finish({ ok: false, error: 'cancelled' });
+        finish({ ok: false, error: 'cancelled', code: 'cancelled' });
       };
       if (signal.aborted) onAbort();
       else signal.addEventListener('abort', onAbort, { once: true });
@@ -165,7 +167,7 @@ export function runClaude({
         } else if (ev.type === 'result') {
           resultText = ev.result || '';
           costUsd = ev.total_cost_usd ?? null;
-          if (ev.is_error) errText = resultText || ev.subtype || 'agent error';
+          if (ev.is_error) { errText = resultText || ev.subtype || 'agent error'; errSubtype = ev.subtype || null; }
         }
       }
     });
@@ -173,10 +175,19 @@ export function runClaude({
       errText += chunk;
     });
 
-    child.on('error', (err) => finish({ ok: false, error: `spawn failed: ${err.message}` }));
+    child.on('error', (err) => {
+      const c = classifyClaudeError(err.message, { subtype: errSubtype });
+      finish({ ok: false, error: `spawn failed: ${err.message}`, code: c.code, resetAt: c.resetAt });
+    });
     child.on('close', (code) => {
       if (code === 0 && resultText) finish({ ok: true, result: resultText });
-      else finish({ ok: false, error: (errText || `claude exited with code ${code}`).slice(0, 2000) });
+      else {
+        /* Name the failure so the app can say something useful — a spent usage limit
+           is not a crash, and used to look exactly like one. */
+        const raw = errText || `claude exited with code ${code}`;
+        const c = classifyClaudeError(raw, { exitCode: code, subtype: errSubtype });
+        finish({ ok: false, error: raw.slice(0, 2000), code: c.code, resetAt: c.resetAt });
+      }
     });
   });
 }

package/tools/client-finder/vendor/lib/claude-errors.mjs

@@ -0,0 +1,73 @@
+/**
+ * What went wrong with Claude — as a CODE, not a sentence.
+ *
+ * Until now every failure came back as raw CLI stderr and was shown to the person
+ * verbatim: "your 5-hour limit is up" and "the flag is wrong" arrived looking exactly
+ * the same, which reads as "the product is broken" (owner ask 2026-07-26). The apps
+ * cannot say anything useful about a state they cannot name, so this names them.
+ *
+ * The matching is deliberately loose — several phrasings per state, and the CLI's
+ * wording changes between versions. A miss falls through to 'unknown', which the UI
+ * still handles; a WRONG match would be worse, so each pattern is anchored on words
+ * that only appear for that one condition.
+ *
+ * Kept byte-identical across the three backends, like spawn-claude.mjs.
+ */
+
+/** @typedef {'limit-reached'|'credit-exhausted'|'not-authenticated'|'model-unavailable'|'overloaded'|'context-too-long'|'cli-missing'|'network'|'cancelled'|'timeout'|'unknown'} ClaudeErrorCode */
+
+const PATTERNS = [
+  // The 5-hour / weekly subscription window. The CLI prints a reset time with it, which
+  // is the single most useful thing we can pass on.
+  { code: 'limit-reached', re: /(usage|rate)\s*limit\s*(reached|exceeded)|limit\s*reached\s*[·|-]|you'?ve\s*(hit|reached)\s*your\s*.*limit|resets?\s+at\s+\d|rate_limit_error|\b429\b/i },
+  // Pay-as-you-go balance, not a subscription window — a different fix for the person.
+  { code: 'credit-exhausted', re: /credit\s*balance\s*is\s*too\s*low|insufficient\s*(credit|funds|balance)|billing.*required|purchase\s*more\s*credits/i },
+  { code: 'not-authenticated', re: /not\s*(logged\s*in|authenticated|signed\s*in)|please\s*(run\s*)?\/?login|authentication_error|invalid\s*api\s*key|oauth.*(expired|invalid)|session\s*expired|unauthoriz/i },
+  /* The real CLI wording, captured 2026-07-26: "There's an issue with the selected
+     model (…). It may not exist or you may not have access to it." — note "may not",
+     which the first version of this pattern missed. */
+  { code: 'model-unavailable', re: /issue\s*with\s*the\s*selected\s*model|model.*(not\s*(found|available|supported)|(may\s*not|does\s*not)\s*exist)|not_found_error.*model|(no|not\s*have)\s*access\s*to\s*(it|.*model)/i },
+  { code: 'overloaded', re: /overloaded_error|overloaded|server\s*is\s*busy|\b529\b|temporarily\s*unavailable/i },
+  { code: 'context-too-long', re: /prompt\s*is\s*too\s*long|context.*(too\s*long|length\s*exceeded)|maximum\s*context/i },
+  { code: 'cli-missing', re: /spawn\s+claude\s+ENOENT|command\s*not\s*found.*claude|claude:\s*not\s*found/i },
+  { code: 'network', re: /ENOTFOUND|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|network\s*error|fetch\s*failed/i },
+];
+
+/**
+ * Classify a failure from the CLI.
+ * @param {string} text  stderr / result text, whatever we captured
+ * @param {{ exitCode?: number|null, subtype?: string|null }} [meta]
+ * @returns {{ code: ClaudeErrorCode, resetAt: string|null, raw: string }}
+ */
+export function classifyClaudeError(text, meta = {}) {
+  const raw = String(text || '').slice(0, 4000);
+  // The runner's own outcomes are already unambiguous — never re-guess them from text.
+  if (/^cancelled$|^отменено$|^скасовано$/i.test(raw.trim())) return { code: 'cancelled', resetAt: null, raw };
+  if (/^timeout after \d+s/i.test(raw.trim())) return { code: 'timeout', resetAt: null, raw };
+
+  for (const { code, re } of PATTERNS) {
+    if (re.test(raw)) return { code, resetAt: code === 'limit-reached' ? extractReset(raw) : null, raw };
+  }
+  // stream-json carries a machine-readable cause we used to throw away.
+  const sub = String(meta.subtype || '');
+  if (/max_turns/i.test(sub)) return { code: 'unknown', resetAt: null, raw };
+  return { code: 'unknown', resetAt: null, raw };
+}
+
+/**
+ * The reset time the CLI prints with a limit message ("resets at 3pm", an ISO stamp, or
+ * a unix seconds value). Returned verbatim-ish so the UI can show "try again after …";
+ * null when nothing parseable is there, and the UI then just says the limit is up.
+ */
+function extractReset(text) {
+  const iso = text.match(/\b(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?)/);
+  if (iso) return iso[1];
+  const unix = text.match(/resets?\s*(?:at)?\s*[:=]?\s*(\d{10})\b/i);
+  if (unix) return new Date(Number(unix[1]) * 1000).toISOString();
+  const clock = text.match(/resets?\s*at\s*([0-9]{1,2}(?::[0-9]{2})?\s*(?:am|pm)?(?:\s*\([^)]+\))?)/i);
+  if (clock) return clock[1].trim();
+  return null;
+}
+
+/** True when waiting is the fix — the caller may want to retry later rather than shout. */
+export const isTransient = (code) => code === 'overloaded' || code === 'network' || code === 'limit-reached';

package/tools/travel/vendor/lib/agent.mjs

@@ -6,6 +6,7 @@
 import { spawnClaude } from './spawn-claude.mjs';
 import { resolve } from 'node:path';
 import { ROOT } from './store.mjs';
+import { classifyClaudeError } from './claude-errors.mjs';
 
 // Все живые дочерние агенты: убиваем при остановке сервера, чтобы
 // осиротевшие claude-процессы не дожигали токены в пустоту.
@@ -99,6 +100,7 @@ export function runClaude({
     child.on('close', () => activeChildren.delete(child));
 
     let resultText = '';
+    let errSubtype = null;
     let errText = '';
     let costUsd = null;
     let settled = false;
@@ -115,13 +117,13 @@ export function runClaude({
 
     const timer = setTimeout(() => {
       try { child.kill('SIGKILL'); } catch { /* already dead */ }
-      finish({ ok: false, error: `timeout after ${Math.round(timeoutMs / 1000)}s` });
+      finish({ ok: false, error: `timeout after ${Math.round(timeoutMs / 1000)}s`, code: 'timeout' });
     }, timeoutMs);
 
     if (signal) {
       const onAbort = () => {
         try { child.kill('SIGKILL'); } catch { /* already dead */ }
-        finish({ ok: false, error: 'отменено' });
+        finish({ ok: false, error: 'отменено', code: 'cancelled' });
       };
       if (signal.aborted) onAbort();
       else signal.addEventListener('abort', onAbort, { once: true });
@@ -155,16 +157,25 @@ export function runClaude({
         } else if (ev.type === 'result') {
           resultText = ev.result || '';
           costUsd = ev.total_cost_usd ?? null;
-          if (ev.is_error) errText = resultText || ev.subtype || 'agent error';
+          if (ev.is_error) { errText = resultText || ev.subtype || 'agent error'; errSubtype = ev.subtype || null; }
         }
       }
     });
     child.stderr.on('data', chunk => { errText += chunk; });
 
-    child.on('error', err => finish({ ok: false, error: `spawn failed: ${err.message}` }));
+    child.on('error', (err) => {
+      const c = classifyClaudeError(err.message, { subtype: errSubtype });
+      finish({ ok: false, error: `spawn failed: ${err.message}`, code: c.code, resetAt: c.resetAt });
+    });
     child.on('close', code => {
       if (code === 0 && resultText) finish({ ok: true, result: resultText });
-      else finish({ ok: false, error: (errText || `claude exited with code ${code}`).slice(0, 2000) });
+      else {
+        /* Name the failure so the app can say something useful — a spent usage limit
+           is not a crash, and used to look exactly like one. */
+        const raw = errText || `claude exited with code ${code}`;
+        const c = classifyClaudeError(raw, { exitCode: code, subtype: errSubtype });
+        finish({ ok: false, error: raw.slice(0, 2000), code: c.code, resetAt: c.resetAt });
+      }
     });
   });
 }

package/tools/travel/vendor/lib/claude-errors.mjs

@@ -0,0 +1,73 @@
+/**
+ * What went wrong with Claude — as a CODE, not a sentence.
+ *
+ * Until now every failure came back as raw CLI stderr and was shown to the person
+ * verbatim: "your 5-hour limit is up" and "the flag is wrong" arrived looking exactly
+ * the same, which reads as "the product is broken" (owner ask 2026-07-26). The apps
+ * cannot say anything useful about a state they cannot name, so this names them.
+ *
+ * The matching is deliberately loose — several phrasings per state, and the CLI's
+ * wording changes between versions. A miss falls through to 'unknown', which the UI
+ * still handles; a WRONG match would be worse, so each pattern is anchored on words
+ * that only appear for that one condition.
+ *
+ * Kept byte-identical across the three backends, like spawn-claude.mjs.
+ */
+
+/** @typedef {'limit-reached'|'credit-exhausted'|'not-authenticated'|'model-unavailable'|'overloaded'|'context-too-long'|'cli-missing'|'network'|'cancelled'|'timeout'|'unknown'} ClaudeErrorCode */
+
+const PATTERNS = [
+  // The 5-hour / weekly subscription window. The CLI prints a reset time with it, which
+  // is the single most useful thing we can pass on.
+  { code: 'limit-reached', re: /(usage|rate)\s*limit\s*(reached|exceeded)|limit\s*reached\s*[·|-]|you'?ve\s*(hit|reached)\s*your\s*.*limit|resets?\s+at\s+\d|rate_limit_error|\b429\b/i },
+  // Pay-as-you-go balance, not a subscription window — a different fix for the person.
+  { code: 'credit-exhausted', re: /credit\s*balance\s*is\s*too\s*low|insufficient\s*(credit|funds|balance)|billing.*required|purchase\s*more\s*credits/i },
+  { code: 'not-authenticated', re: /not\s*(logged\s*in|authenticated|signed\s*in)|please\s*(run\s*)?\/?login|authentication_error|invalid\s*api\s*key|oauth.*(expired|invalid)|session\s*expired|unauthoriz/i },
+  /* The real CLI wording, captured 2026-07-26: "There's an issue with the selected
+     model (…). It may not exist or you may not have access to it." — note "may not",
+     which the first version of this pattern missed. */
+  { code: 'model-unavailable', re: /issue\s*with\s*the\s*selected\s*model|model.*(not\s*(found|available|supported)|(may\s*not|does\s*not)\s*exist)|not_found_error.*model|(no|not\s*have)\s*access\s*to\s*(it|.*model)/i },
+  { code: 'overloaded', re: /overloaded_error|overloaded|server\s*is\s*busy|\b529\b|temporarily\s*unavailable/i },
+  { code: 'context-too-long', re: /prompt\s*is\s*too\s*long|context.*(too\s*long|length\s*exceeded)|maximum\s*context/i },
+  { code: 'cli-missing', re: /spawn\s+claude\s+ENOENT|command\s*not\s*found.*claude|claude:\s*not\s*found/i },
+  { code: 'network', re: /ENOTFOUND|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|network\s*error|fetch\s*failed/i },
+];
+
+/**
+ * Classify a failure from the CLI.
+ * @param {string} text  stderr / result text, whatever we captured
+ * @param {{ exitCode?: number|null, subtype?: string|null }} [meta]
+ * @returns {{ code: ClaudeErrorCode, resetAt: string|null, raw: string }}
+ */
+export function classifyClaudeError(text, meta = {}) {
+  const raw = String(text || '').slice(0, 4000);
+  // The runner's own outcomes are already unambiguous — never re-guess them from text.
+  if (/^cancelled$|^отменено$|^скасовано$/i.test(raw.trim())) return { code: 'cancelled', resetAt: null, raw };
+  if (/^timeout after \d+s/i.test(raw.trim())) return { code: 'timeout', resetAt: null, raw };
+
+  for (const { code, re } of PATTERNS) {
+    if (re.test(raw)) return { code, resetAt: code === 'limit-reached' ? extractReset(raw) : null, raw };
+  }
+  // stream-json carries a machine-readable cause we used to throw away.
+  const sub = String(meta.subtype || '');
+  if (/max_turns/i.test(sub)) return { code: 'unknown', resetAt: null, raw };
+  return { code: 'unknown', resetAt: null, raw };
+}
+
+/**
+ * The reset time the CLI prints with a limit message ("resets at 3pm", an ISO stamp, or
+ * a unix seconds value). Returned verbatim-ish so the UI can show "try again after …";
+ * null when nothing parseable is there, and the UI then just says the limit is up.
+ */
+function extractReset(text) {
+  const iso = text.match(/\b(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?)/);
+  if (iso) return iso[1];
+  const unix = text.match(/resets?\s*(?:at)?\s*[:=]?\s*(\d{10})\b/i);
+  if (unix) return new Date(Number(unix[1]) * 1000).toISOString();
+  const clock = text.match(/resets?\s*at\s*([0-9]{1,2}(?::[0-9]{2})?\s*(?:am|pm)?(?:\s*\([^)]+\))?)/i);
+  if (clock) return clock[1].trim();
+  return null;
+}
+
+/** True when waiting is the fix — the caller may want to retry later rather than shout. */
+export const isTransient = (code) => code === 'overloaded' || code === 'network' || code === 'limit-reached';

package/tools/work-finder/vendor/lib/agent.mjs

@@ -5,6 +5,7 @@
 import { spawnClaude } from './spawn-claude.mjs';
 import { resolve } from 'node:path';
 import { ROOT } from './store.mjs';
+import { classifyClaudeError } from './claude-errors.mjs';
 
 // Все живые дочерние агенты: убиваем при остановке сервера, чтобы
 // осиротевшие claude-процессы не дожигали токены в пустоту.
@@ -71,6 +72,7 @@ export function runClaude({
     child.on('close', () => activeChildren.delete(child));
 
     let resultText = '';
+    let errSubtype = null;
     let errText = '';
     let costUsd = null;
     let settled = false;
@@ -87,13 +89,13 @@ export function runClaude({
 
     const timer = setTimeout(() => {
       try { child.kill('SIGKILL'); } catch { /* already dead */ }
-      finish({ ok: false, error: `timeout after ${Math.round(timeoutMs / 1000)}s` });
+      finish({ ok: false, error: `timeout after ${Math.round(timeoutMs / 1000)}s`, code: 'timeout' });
     }, timeoutMs);
 
     if (signal) {
       const onAbort = () => {
         try { child.kill('SIGKILL'); } catch { /* already dead */ }
-        finish({ ok: false, error: 'отменено' });
+        finish({ ok: false, error: 'отменено', code: 'cancelled' });
       };
       if (signal.aborted) onAbort();
       else signal.addEventListener('abort', onAbort, { once: true });
@@ -126,16 +128,25 @@ export function runClaude({
         } else if (ev.type === 'result') {
           resultText = ev.result || '';
           costUsd = ev.total_cost_usd ?? null;
-          if (ev.is_error) errText = resultText || ev.subtype || 'agent error';
+          if (ev.is_error) { errText = resultText || ev.subtype || 'agent error'; errSubtype = ev.subtype || null; }
         }
       }
     });
     child.stderr.on('data', chunk => { errText += chunk; });
 
-    child.on('error', err => finish({ ok: false, error: `spawn failed: ${err.message}` }));
+    child.on('error', err => {
+      const c = classifyClaudeError(err.message, { subtype: errSubtype });
+      finish({ ok: false, error: `spawn failed: ${err.message}`, code: c.code, resetAt: c.resetAt });
+    });
     child.on('close', code => {
       if (code === 0 && resultText) finish({ ok: true, result: resultText });
-      else finish({ ok: false, error: (errText || `claude exited with code ${code}`).slice(0, 2000) });
+      else {
+        /* Name the failure. "Your 5-hour limit is up" and "a flag is wrong" used to
+           arrive identical — raw stderr — which reads as a broken product. */
+        const raw = errText || `claude exited with code ${code}`;
+        const c = classifyClaudeError(raw, { exitCode: code, subtype: errSubtype });
+        finish({ ok: false, error: raw.slice(0, 2000), code: c.code, resetAt: c.resetAt });
+      }
     });
   });
 }

package/tools/work-finder/vendor/lib/claude-errors.mjs

@@ -0,0 +1,73 @@
+/**
+ * What went wrong with Claude — as a CODE, not a sentence.
+ *
+ * Until now every failure came back as raw CLI stderr and was shown to the person
+ * verbatim: "your 5-hour limit is up" and "the flag is wrong" arrived looking exactly
+ * the same, which reads as "the product is broken" (owner ask 2026-07-26). The apps
+ * cannot say anything useful about a state they cannot name, so this names them.
+ *
+ * The matching is deliberately loose — several phrasings per state, and the CLI's
+ * wording changes between versions. A miss falls through to 'unknown', which the UI
+ * still handles; a WRONG match would be worse, so each pattern is anchored on words
+ * that only appear for that one condition.
+ *
+ * Kept byte-identical across the three backends, like spawn-claude.mjs.
+ */
+
+/** @typedef {'limit-reached'|'credit-exhausted'|'not-authenticated'|'model-unavailable'|'overloaded'|'context-too-long'|'cli-missing'|'network'|'cancelled'|'timeout'|'unknown'} ClaudeErrorCode */
+
+const PATTERNS = [
+  // The 5-hour / weekly subscription window. The CLI prints a reset time with it, which
+  // is the single most useful thing we can pass on.
+  { code: 'limit-reached', re: /(usage|rate)\s*limit\s*(reached|exceeded)|limit\s*reached\s*[·|-]|you'?ve\s*(hit|reached)\s*your\s*.*limit|resets?\s+at\s+\d|rate_limit_error|\b429\b/i },
+  // Pay-as-you-go balance, not a subscription window — a different fix for the person.
+  { code: 'credit-exhausted', re: /credit\s*balance\s*is\s*too\s*low|insufficient\s*(credit|funds|balance)|billing.*required|purchase\s*more\s*credits/i },
+  { code: 'not-authenticated', re: /not\s*(logged\s*in|authenticated|signed\s*in)|please\s*(run\s*)?\/?login|authentication_error|invalid\s*api\s*key|oauth.*(expired|invalid)|session\s*expired|unauthoriz/i },
+  /* The real CLI wording, captured 2026-07-26: "There's an issue with the selected
+     model (…). It may not exist or you may not have access to it." — note "may not",
+     which the first version of this pattern missed. */
+  { code: 'model-unavailable', re: /issue\s*with\s*the\s*selected\s*model|model.*(not\s*(found|available|supported)|(may\s*not|does\s*not)\s*exist)|not_found_error.*model|(no|not\s*have)\s*access\s*to\s*(it|.*model)/i },
+  { code: 'overloaded', re: /overloaded_error|overloaded|server\s*is\s*busy|\b529\b|temporarily\s*unavailable/i },
+  { code: 'context-too-long', re: /prompt\s*is\s*too\s*long|context.*(too\s*long|length\s*exceeded)|maximum\s*context/i },
+  { code: 'cli-missing', re: /spawn\s+claude\s+ENOENT|command\s*not\s*found.*claude|claude:\s*not\s*found/i },
+  { code: 'network', re: /ENOTFOUND|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|network\s*error|fetch\s*failed/i },
+];
+
+/**
+ * Classify a failure from the CLI.
+ * @param {string} text  stderr / result text, whatever we captured
+ * @param {{ exitCode?: number|null, subtype?: string|null }} [meta]
+ * @returns {{ code: ClaudeErrorCode, resetAt: string|null, raw: string }}
+ */
+export function classifyClaudeError(text, meta = {}) {
+  const raw = String(text || '').slice(0, 4000);
+  // The runner's own outcomes are already unambiguous — never re-guess them from text.
+  if (/^cancelled$|^отменено$|^скасовано$/i.test(raw.trim())) return { code: 'cancelled', resetAt: null, raw };
+  if (/^timeout after \d+s/i.test(raw.trim())) return { code: 'timeout', resetAt: null, raw };
+
+  for (const { code, re } of PATTERNS) {
+    if (re.test(raw)) return { code, resetAt: code === 'limit-reached' ? extractReset(raw) : null, raw };
+  }
+  // stream-json carries a machine-readable cause we used to throw away.
+  const sub = String(meta.subtype || '');
+  if (/max_turns/i.test(sub)) return { code: 'unknown', resetAt: null, raw };
+  return { code: 'unknown', resetAt: null, raw };
+}
+
+/**
+ * The reset time the CLI prints with a limit message ("resets at 3pm", an ISO stamp, or
+ * a unix seconds value). Returned verbatim-ish so the UI can show "try again after …";
+ * null when nothing parseable is there, and the UI then just says the limit is up.
+ */
+function extractReset(text) {
+  const iso = text.match(/\b(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?)/);
+  if (iso) return iso[1];
+  const unix = text.match(/resets?\s*(?:at)?\s*[:=]?\s*(\d{10})\b/i);
+  if (unix) return new Date(Number(unix[1]) * 1000).toISOString();
+  const clock = text.match(/resets?\s*at\s*([0-9]{1,2}(?::[0-9]{2})?\s*(?:am|pm)?(?:\s*\([^)]+\))?)/i);
+  if (clock) return clock[1].trim();
+  return null;
+}
+
+/** True when waiting is the fix — the caller may want to retry later rather than shout. */
+export const isTransient = (code) => code === 'overloaded' || code === 'network' || code === 'limit-reached';

package/tools/work-finder/vendor/lib/jobs.mjs

@@ -20,7 +20,12 @@ const MAX_CONCURRENT = 2;
 let running = 0;
 const queue = [];
 
-export function createJob(type, label, work) {
+/** Set by the server: called when a job dies because Claude's limit is spent. */
+let onLimit = null;
+export function setLimitHandler(fn) { onLimit = fn; }
+
+/** @param {object} [opts] `retry` describes how to run this again (see resume-later). */
+export function createJob(type, label, work, opts = {}) {
   const job = {
     id: uid(),
     type,
@@ -31,6 +36,7 @@ export function createJob(type, label, work) {
     error: null,
     createdAt: Date.now(),
     finishedAt: null,
+    retry: opts.retry || null,
   };
   jobs.set(job.id, job);
   queue.push({ job, work });
@@ -65,7 +71,18 @@ function pump() {
         } else {
           job.status = 'error';
           job.error = String(err?.message || err).slice(0, 2000);
+          /* WHAT kind of failure — the app cannot say anything useful about a state it
+             cannot name, and "your limit is up" used to look exactly like a crash. */
+          if (err?.claudeCode) job.claudeCode = err.claudeCode;
+          if (err?.resetAt) job.resetAt = err.resetAt;
           jobLog(job, `✗ ${job.error}`);
+          /* A usage limit is the one failure worth picking up later — the owner of the
+             machine may be asleep. jobs.mjs does not know HOW to re-run anything, so it
+             hands the job's own descriptor to whoever registered a handler. */
+          if (job.claudeCode === 'limit-reached' && job.retry && onLimit) {
+            try { onLimit(job.retry, { code: job.claudeCode, resetAt: job.resetAt }); }
+            catch { /* never let bookkeeping break the job's own failure path */ }
+          }
         }
       })
       .finally(() => {

package/tools/work-finder/vendor/lib/resume-later.mjs

@@ -0,0 +1,133 @@
+/**
+ * Pick the work back up when Claude's limit lifts.
+ *
+ * Hitting a usage limit is the ONE failure where the right answer is not "tell the
+ * person to try again" — they may be asleep, and the run was already paid for in
+ * attention. So a search stopped by a limit is remembered and re-run on its own; the
+ * person comes back to finished results instead of a red line (owner ask 2026-07-26).
+ *
+ * Deliberately conservative:
+ *  · only 'limit-reached' is retried. A wrong model or an empty résumé will fail again
+ *    at any hour, and a retry loop on those is just noise.
+ *  · at most MAX_TRIES attempts, spaced out — a limit that keeps re-hitting means the
+ *    account is genuinely spent, not that we should hammer it.
+ *  · the queue lives in the db, so closing the laptop does not lose it.
+ *  · the person can cancel it, and cancelling means cancelled.
+ */
+
+const MAX_TRIES = 3;
+const MIN_WAIT_MS = 10 * 60 * 1000; // never sooner than 10 min, even if reset says now
+const FALLBACK_WAIT_MS = 60 * 60 * 1000; // no parseable reset time → try in an hour
+const TICK_MS = 60 * 1000;
+
+/** ISO / unix / "3pm (Europe/Kyiv)" → epoch ms, or null when it cannot be trusted. */
+function resetToEpoch(resetAt) {
+  if (!resetAt) return null;
+  const s = String(resetAt).trim();
+  const asDate = Date.parse(s);
+  if (!Number.isNaN(asDate)) return asDate;
+  // "3pm", "3:30 pm (Europe/Kyiv)" — a wall-clock hint with no date. Read it as the
+  // NEXT occurrence of that hour in this machine's own timezone, which is where the
+  // person is sitting.
+  const m = s.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+  if (!m) return null;
+  let h = Number(m[1]);
+  const min = Number(m[2] || 0);
+  const ap = (m[3] || '').toLowerCase();
+  if (ap === 'pm' && h < 12) h += 12;
+  if (ap === 'am' && h === 12) h = 0;
+  const d = new Date();
+  d.setHours(h, min, 0, 0);
+  if (d.getTime() <= Date.now()) d.setDate(d.getDate() + 1);
+  return d.getTime();
+}
+
+/**
+ * @param {object} opts
+ * @param {() => object} opts.getDb        current db (we persist into db.deferred)
+ * @param {(db: object) => void} opts.save
+ * @param {(entry: object) => void} opts.run  re-runs one entry; throws if it cannot
+ * @param {(entry: object, msg: string) => void} [opts.note]
+ */
+export function createResumeQueue({ getDb, save, run, note }) {
+  let timer = null;
+
+  const list = () => {
+    const db = getDb();
+    if (!Array.isArray(db.deferred)) db.deferred = [];
+    return db.deferred;
+  };
+
+  /** Remember a run to pick up later. Returns the entry, or null if not retryable. */
+  function defer(descriptor, { code, resetAt } = {}) {
+    if (code !== 'limit-reached' || !descriptor) return null;
+    const db = getDb();
+    const q = list();
+    // One pending entry per thing — a limit hit during a 5-role sweep must not queue
+    // the same role five times.
+    const key = JSON.stringify(descriptor);
+    const existing = q.find((e) => JSON.stringify(e.descriptor) === key);
+    const tries = (existing?.tries || 0) + 1;
+    if (tries > MAX_TRIES) {
+      if (existing) q.splice(q.indexOf(existing), 1);
+      save(db);
+      return null;
+    }
+    const base = resetToEpoch(resetAt);
+    const wait = base ? Math.max(base - Date.now(), MIN_WAIT_MS) : FALLBACK_WAIT_MS * tries;
+    const entry = existing || { id: 'df_' + Math.random().toString(36).slice(2, 10), descriptor, createdAt: Date.now() };
+    entry.tries = tries;
+    entry.resumeAt = Date.now() + wait;
+    entry.reason = 'limit-reached';
+    if (!existing) q.push(entry);
+    save(db);
+    note?.(entry, `отложено до ${new Date(entry.resumeAt).toLocaleString()}`);
+    return entry;
+  }
+
+  function cancel(id) {
+    const db = getDb();
+    const q = list();
+    const i = q.findIndex((e) => e.id === id);
+    if (i < 0) return false;
+    q.splice(i, 1);
+    save(db);
+    return true;
+  }
+
+  function due(now = Date.now()) {
+    return list().filter((e) => e.resumeAt <= now);
+  }
+
+  async function tick() {
+    const ready = due();
+    if (!ready.length) return;
+    const db = getDb();
+    for (const entry of ready) {
+      // Take it out FIRST: a re-run that hits the limit again will re-add itself with a
+      // longer wait, and a crash must not leave an entry that fires every minute.
+      const q = list();
+      const i = q.findIndex((e) => e.id === entry.id);
+      if (i >= 0) q.splice(i, 1);
+      save(db);
+      try {
+        await run(entry);
+        note?.(entry, 'возобновлено');
+      } catch (e) {
+        note?.(entry, `не удалось возобновить: ${e?.message || e}`);
+      }
+    }
+  }
+
+  function start() {
+    if (timer) return;
+    timer = setInterval(() => void tick(), TICK_MS);
+    timer.unref?.();
+  }
+  function stop() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  }
+
+  return { defer, cancel, list, due, tick, start, stop };
+}

package/tools/work-finder/vendor/server.mjs

@@ -16,7 +16,7 @@ import { spawn } from 'node:child_process';
 import { load, save, uid, ROOT, DATA_DIR } from './lib/store.mjs';
 import { runClaude, extractJson } from './lib/agent.mjs';
 import { searchPrompt, coverLetterPrompt, autoApplyPrompt, importResumePrompt, leadsSearchPrompt, pitchPrompt, buildFromStoryPrompt } from './lib/prompts.mjs';
-import { createJob, jobLog, listJobs, getJob, cancelJob, cancelActiveByLabel, jobEvents } from './lib/jobs.mjs';
+import { createJob, jobLog, listJobs, getJob, cancelJob, cancelActiveByLabel, jobEvents, setLimitHandler } from './lib/jobs.mjs';
 import { ensureBrowser } from './scripts/launch-browser.mjs';
 import { PLANS, SELF_SETTABLE_PLANS } from './lib/plans.mjs';
 import { verifyLicense, licensePlanId, RECHECK_MS } from './lib/license.mjs';
@@ -24,6 +24,7 @@ import { ROLE_CATALOG, SENIORITY, LOCATIONS, detectRoles } from './lib/catalog.m
 import { checkMany, checkVacancyUrl } from './lib/linkcheck.mjs';
 import { probeEngine, startLogin, submitLoginCode } from './lib/engine.mjs';
 import { normalizeLinkedin } from './lib/linkedin.mjs';
+import { createResumeQueue } from './lib/resume-later.mjs';
 
 const PORT = Number(process.env.WF_PORT) || 5544;
 const PUBLIC_DIR = resolve(ROOT, 'public');
@@ -131,6 +132,23 @@ function createSearchRun(targets) {
 // (та же логика, что в purgeHistory). Остальное — нетронутая находка, шум, уходит.
 const isTouched = (v) => v.status !== 'new' || !!v.coverLetter || !!v.applyResult || !!v.pinned;
 
+/* A search stopped by Claude's usage limit comes back on its own — see
+   lib/resume-later.mjs for why only this one failure is retried. */
+const resumeQueue = createResumeQueue({
+  getDb: () => db,
+  save: (d) => save(d),
+  note: (entry, msg) => console.log(`[resume] ${entry.descriptor?.kind || '?'} ${msg}`),
+  run: (entry) => {
+    const d = entry.descriptor || {};
+    if (d.kind !== 'search') throw new Error('unknown descriptor');
+    const position = db.positions.find((p) => p.id === d.positionId);
+    if (!position) throw new Error('роль удалена');
+    startSearch(position, null);
+  },
+});
+resumeQueue.start();
+setLimitHandler((descriptor, info) => resumeQueue.defer(descriptor, info));
+
 function startSearch(position, run = null) {
   const profile = db.profiles.find(p => p.id === position.profileId) || db.profiles[0];
   return createJob('search', `Поиск: ${position.title}`, async (job, signal) => {
@@ -249,11 +267,11 @@ function startSearch(position, run = null) {
         jobLog(job, `⚠ ${res.error} — но ${added} вакансий уже добавлено по ходу поиска`);
         return { found: added, added, dead, sweeps: wave, costUsd: cost, truncated: true };
       }
-      throw new Error(res.error);
+      throw Object.assign(new Error(res.error), { claudeCode: res.code, resetAt: res.resetAt });
     }
     jobLog(job, `✓ добавлено: ${added}${dead ? `, отброшено битых ссылок: ${dead}` : ''} — волн: ${wave}`);
     return { found: added, added, dead, sweeps: wave, costUsd: cost };
-  });
+  }, { retry: { kind: 'search', positionId: position.id } });
 }
 
 function startCoverLetter(vacancy) {
@@ -267,7 +285,7 @@ function startCoverLetter(vacancy) {
       signal,
       onEvent: line => jobLog(job, line),
     });
-    if (!res.ok) throw new Error(res.error);
+    if (!res.ok) throw Object.assign(new Error(res.error), { claudeCode: res.code, resetAt: res.resetAt });
     vacancy.coverLetter = res.result.trim();
     if (vacancy.status === 'new') vacancy.status = 'prepared';
     save(db);
@@ -292,7 +310,7 @@ function startAutoApply(vacancy) {
       signal,
       onEvent: line => jobLog(job, line),
     });
-    if (!res.ok) throw new Error(res.error);
+    if (!res.ok) throw Object.assign(new Error(res.error), { claudeCode: res.code, resetAt: res.resetAt });
     const outcome = extractJson(res.result) || { status: 'unknown', details: res.result.slice(0, 1000) };
     vacancy.applyResult = { ...outcome, at: Date.now() };
     if (outcome.status === 'submitted') vacancy.status = 'sent';
@@ -315,7 +333,7 @@ function startLeadsSearch() {
       signal,
       onEvent: line => jobLog(job, line),
     });
-    if (!res.ok) throw new Error(res.error);
+    if (!res.ok) throw Object.assign(new Error(res.error), { claudeCode: res.code, resetAt: res.resetAt });
     const items = extractJson(res.result);
     if (!Array.isArray(items)) throw new Error('agent returned no JSON array: ' + res.result.slice(0, 300));
     let added = 0;
@@ -343,7 +361,7 @@ function startPitch(lead) {
       signal,
       onEvent: line => jobLog(job, line),
     });
-    if (!res.ok) throw new Error(res.error);
+    if (!res.ok) throw Object.assign(new Error(res.error), { claudeCode: res.code, resetAt: res.resetAt });
     lead.pitch = res.result.trim();
     if (lead.status === 'new') lead.status = 'ready';
     save(db);
@@ -365,7 +383,7 @@ function startOnboard(profile, { linkedin, resumeText, roles = [], seniority = '
     if (resumeText?.trim()) {
       jobLog(job, 'структурирую вставленное резюме…');
       const res = await runClaude({ prompt: importResumePrompt(resumeText), model: db.settings.model, signal, onEvent: l => jobLog(job, l) });
-      if (!res.ok) throw new Error(res.error);
+      if (!res.ok) throw Object.assign(new Error(res.error), { claudeCode: res.code, resetAt: res.resetAt });
       profile.resume = res.result.trim();
       importCost = res.costUsd || 0;
     } else if (linkedin) {
@@ -380,7 +398,7 @@ function startOnboard(profile, { linkedin, resumeText, roles = [], seniority = '
       });
       jobLog(job, 'структурирую резюме через Claude…');
       const res = await runClaude({ prompt: importResumePrompt(readFileSync(rawPath, 'utf8')), model: db.settings.model, signal, onEvent: l => jobLog(job, l) });
-      if (!res.ok) throw new Error(res.error);
+      if (!res.ok) throw Object.assign(new Error(res.error), { claudeCode: res.code, resetAt: res.resetAt });
       profile.resume = res.result.trim();
       profile.linkedin = linkedin;
       importCost = res.costUsd || 0;
@@ -437,7 +455,7 @@ function startLinkedinImport(profile, url) {
       signal,
       onEvent: line => jobLog(job, line),
     });
-    if (!res.ok) throw new Error(res.error);
+    if (!res.ok) throw Object.assign(new Error(res.error), { claudeCode: res.code, resetAt: res.resetAt });
     profile.resume = res.result.trim();
     profile.linkedin = url;
     save(db);
@@ -627,7 +645,7 @@ export const requestHandler = async (req, res) => {
 
     if (req.method === 'GET' && path === '/api/state') {
       return json(res, 200, {
-        ...db, browserAlive, jobs: listJobs(), billing: billingInfo(),
+        ...db, browserAlive, jobs: listJobs(), billing: billingInfo(), deferred: resumeQueue.list(),
         catalog: ROLE_CATALOG.map(({ id, group, title, keywords }) => ({ id, group, title, keywords })),
         seniority: SENIORITY, locations: LOCATIONS,
       });
@@ -844,6 +862,12 @@ export const requestHandler = async (req, res) => {
        localStorage. That key cannot exist any more — API_KEY_LOGIN is off and there is
        no field to enter one — so all three were dead for every user while the fourth,
        which comes through here, worked. Same route for all of them now. */
+    /* "Do not bother, I will run it myself" — a promise the product makes must be
+       cancellable, or it is just something happening to you. */
+    if (req.method === 'DELETE' && seg[1] === 'deferred' && seg[2]) {
+      const ok = resumeQueue.cancel(seg[2]);
+      return json(res, ok ? 200 : 404, ok ? { ok: true } : { error: 'no such entry' });
+    }
     if (req.method === 'POST' && path === '/api/builder/text') {
       const b = await readBody(req);
       const prompt = (b.prompt || '').trim();