@magnusekdahl/parallix 1.2.0 → 1.2.1

package/lib/agents/limit-hit.ts

@@ -0,0 +1,262 @@
+'use strict';
+
+const DEFAULT_FALLBACK_HOURS = 1;
+const SIGINT_SHORT_BLOCK_MINUTES = 15;
+
+const PATTERN_SETS = Object.freeze({
+  claude: [
+    /claude (?:ai )?usage limit reached/i,
+    /\b5-hour limit (?:reached|exceeded)\b/i,
+    /you(?:'|')?ve hit your limit(?:\b|$)/i,
+    /you(?:'|')?ve hit your (?:weekly|daily|monthly|usage) limit/i,
+    /(?:usage|rate)\s*limit (?:has been )?(?:reached|exceeded)/i,
+    /\b429\b[^\n]*?\b(?:rate|usage|quota)\b/i
+  ],
+  codex: [
+    /you(?:'|’)?ve hit your (?:weekly|daily|monthly|usage) limit/i,
+    /\brate[_ ]?limit(?:_| )?(?:exceeded|reached)\b/i,
+    /\bweekly (?:codex )?usage limit\b/i,
+    /\b429\b[^\n]*?\b(?:rate|quota|usage)\b/i,
+    /resource_exhausted/i
+  ],
+
+  custom: [
+    /\b(?:rate|usage|quota)\s*limit\s*(?:reached|exceeded)\b/i,
+    /\b429\b[^\n]*?\b(?:rate|quota|usage)\b/i,
+    /\b429\b/i,
+    /\binsufficient[_ ]quota\b/i
+  ],
+  mistral: [
+    /\bmistral (?:ai )?usage limit reached/i,
+    /\bmistral (?:ai )?quota exceeded/i,
+    /\bmistral (?:ai )?rate limit(?: reached| exceeded)/i,
+    /you(?:'|')?ve hit your (?:mistral|vibe) (?:weekly|daily|monthly|usage) limit/i,
+    /\b429\b[^\n]*?\b(?:rate|quota|usage)\b/i,
+    /\bvibe\b[^\n]*?\b(?:quota exceeded|rate limit exceeded)\b/i,
+    /\bmistral\b[^\n]*?\b(?:quota exceeded|rate limit exceeded)\b/i,
+    /\bresource[_ ]has[_ ]been[_ ]exhausted\b/i,
+    /\bresource_exhausted\b/i
+  ]
+});
+
+function getPatternsForAgent(agent: string) {
+  return PATTERN_SETS[agent as keyof typeof PATTERN_SETS] || [];
+}
+
+function findLimitHitMatch(agent: string, text: string) {
+  const patterns = getPatternsForAgent(agent);
+  for (const pattern of patterns) {
+    const match = pattern.exec(text);
+    if (match) {
+      return { pattern, index: match.index, length: match[0].length };
+    }
+  }
+  return null;
+}
+
+function clipContext(text: string, index: number, length: number) {
+  const before = Math.max(0, index - 200);
+  const after = Math.min(text.length, index + length + 200);
+  return text.slice(before, after);
+}
+
+const ISO_PATTERN = /(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.\d+)?(Z|[+-]\d{2}:?\d{2})?/;
+const TWELVE_HOUR_PATTERN = /\b(\d{1,2})(?::(\d{2}))?\s*(am|pm|AM|PM)\b/;
+const TWENTY_FOUR_HOUR_PATTERN = /\b([01]?\d|2[0-3]):([0-5]\d)\b/;
+const RELATIVE_PATTERN = /\bin\s+(\d+)\s+(hour|hours|minute|minutes|second|seconds)\b/i;
+const RETRY_AFTER_PATTERN = /retry[- ]?after[:\s]+(\d+)\s*(seconds?|s|minutes?|m)?/i;
+const RETRY_AT_DATE_PATTERN = /(?:retry|reset|try again|reset(?:s)? at)[^\n]{0,40}?(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)/i;
+
+function parseIsoOffset(value: string | undefined) {
+  if (!value) {return null;}
+  if (value === 'Z') {return 0;}
+  const m = /([+-])(\d{2}):?(\d{2})/.exec(value);
+  if (!m) {return null;}
+  const sign = m[1] === '-' ? -1 : 1;
+  return sign * (Number(m[2]) * 60 + Number(m[3]));
+}
+
+function parseIso(text: string) {
+  const m = ISO_PATTERN.exec(text);
+  if (!m) {return null;}
+  const [, year, month, day, hour, minute, second, offset] = m;
+  const offsetMinutes = parseIsoOffset(offset);
+  if (offsetMinutes === null) {
+    return new Date(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second || 0), 0);
+  }
+  const utcMs = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second || 0), 0);
+  return new Date(utcMs - offsetMinutes * 60 * 1000);
+}
+
+function parseTwelveHour(text: string, now: Date) {
+  const m = TWELVE_HOUR_PATTERN.exec(text);
+  if (!m) {return null;}
+  let hour = Number(m[1]);
+  const minute = Number(m[2] || 0);
+  const meridiem = m[3].toLowerCase();
+  if (hour < 1 || hour > 12) {return null;}
+  if (meridiem === 'pm' && hour !== 12) {hour += 12;}
+  if (meridiem === 'am' && hour === 12) {hour = 0;}
+  return projectClockTime(now, hour, minute);
+}
+
+function parseTwentyFourHour(text: string, now: Date) {
+  const m = TWENTY_FOUR_HOUR_PATTERN.exec(text);
+  if (!m) {return null;}
+  const hour = Number(m[1]);
+  const minute = Number(m[2]);
+  return projectClockTime(now, hour, minute);
+}
+
+function parseRelative(text: string, now: Date) {
+  const m = RELATIVE_PATTERN.exec(text);
+  if (!m) {return null;}
+  const amount = Number(m[1]);
+  const unit = m[2].toLowerCase();
+  let ms;
+  if (unit.startsWith('hour')) {ms = amount * 60 * 60 * 1000;}
+  else if (unit.startsWith('minute')) {ms = amount * 60 * 1000;}
+  else {ms = amount * 1000;}
+  return new Date(now.getTime() + ms);
+}
+
+function parseRetryAfter(text: string, now: Date) {
+  const m = RETRY_AFTER_PATTERN.exec(text);
+  if (!m) {return null;}
+  const amount = Number(m[1]);
+  const unit = (m[2] || 's').toLowerCase();
+  let ms;
+  if (unit.startsWith('m') && unit !== 's') {ms = amount * 60 * 1000;}
+  else {ms = amount * 1000;}
+  return new Date(now.getTime() + ms);
+}
+
+function parseRetryAtDate(text: string) {
+  const m = RETRY_AT_DATE_PATTERN.exec(text);
+  if (!m) {return null;}
+  return parseIso(m[1]);
+}
+
+function projectClockTime(now: Date, hour: number, minute: number) {
+  const candidate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute, 0, 0);
+  if (candidate.getTime() <= now.getTime()) {
+    candidate.setDate(candidate.getDate() + 1);
+  }
+  return candidate;
+}
+
+function parseResetTime(text: string, now: Date = new Date()) {
+  if (!text) {return null;}
+  return (
+    parseRetryAtDate(text) ||
+    parseIso(text) ||
+    parseTwelveHour(text, now) ||
+    parseTwentyFourHour(text, now) ||
+    parseRelative(text, now) ||
+    parseRetryAfter(text, now)
+  );
+}
+
+function formatBlockUntil(date: Date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hour = String(date.getHours()).padStart(2, '0');
+  return `${year}-${month}-${day} ${hour}`;
+}
+
+function ceilToNextHour(date: Date) {
+  const ceil = new Date(date.getTime());
+  if (ceil.getMinutes() === 0 && ceil.getSeconds() === 0 && ceil.getMilliseconds() === 0) {
+    return ceil;
+  }
+  ceil.setMinutes(0, 0, 0);
+  ceil.setHours(ceil.getHours() + 1);
+  return ceil;
+}
+
+interface DetectLimitHitOptions {
+  agent: string;
+  stdout?: string;
+  stderr?: string;
+  status?: number;
+  signal?: string | null;
+  error?: { code?: string } | null;
+  now?: Date;
+}
+
+function detectLimitHit({
+  agent,
+  stdout = '',
+  stderr = '',
+  status,
+  signal,
+  error,
+  now = new Date()
+}: DetectLimitHitOptions = {} as DetectLimitHitOptions) {
+  if (!agent) {return null;}
+  // Gate detection on a failed launcher invocation. A successful child (exit 0,
+  // no signal, no spawn error) means any limit-hit phrases in the transcript
+  // are quoted text — typically when the agent itself reviewed code, tests, or
+  // logs containing those strings. Treating that as a real limit hit would
+  // wrongly block a healthy agent in agents.local.json.
+  // `status === undefined` means the caller did not pass exit metadata; preserve
+  // the legacy behavior so callers that haven't been updated still get detection.
+  const launcherFailed =
+    error !== null && error !== undefined ||
+    signal !== null && signal !== undefined ||
+    (typeof status === 'number' && status !== 0) ||
+    typeof status === 'undefined';
+  if (!launcherFailed) {return null;}
+
+  const combined = `${stdout || ''}\n${stderr || ''}`;
+  const match = findLimitHitMatch(agent, combined);
+
+  let target;
+  let source;
+
+  if (match) {
+    const context = clipContext(combined, match.index, match.length);
+    const parsed = parseResetTime(context, now);
+
+    if (parsed && !Number.isNaN(parsed.getTime()) && parsed.getTime() > now.getTime()) {
+      target = parsed;
+      source = 'parsed';
+    } else {
+      target = new Date(now.getTime() + DEFAULT_FALLBACK_HOURS * 60 * 60 * 1000);
+      source = 'fallback';
+    }
+  } else if (signal !== null && signal !== undefined) {
+    // Agent was killed by a signal (e.g. SIGINT/Ctrl-C) but no limit-hit
+    // pattern matched. Apply a short-term block so the next invocation
+    // selects a different agent instead of re-picking the same one.
+    target = new Date(now.getTime() + SIGINT_SHORT_BLOCK_MINUTES * 60 * 1000);
+    source = 'sigint';
+  } else {
+    return null;
+  }
+
+  const ceiled = ceilToNextHour(target);
+  return { until: formatBlockUntil(ceiled), source };
+}
+
+export {
+  detectLimitHit,
+  parseResetTime,
+  formatBlockUntil,
+  ceilToNextHour,
+  findLimitHitMatch,
+  clipContext,
+  parseIsoOffset,
+  parseIso,
+  parseTwelveHour,
+  parseTwentyFourHour,
+  parseRelative,
+  parseRetryAfter,
+  parseRetryAtDate,
+  projectClockTime,
+  getPatternsForAgent,
+  PATTERN_SETS,
+  DEFAULT_FALLBACK_HOURS,
+  SIGINT_SHORT_BLOCK_MINUTES
+};

package/lib/agents/mistral-telemetry.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Mistral (Vibe) Telemetry Stub
  *
@@ -15,7 +16,9 @@
  * telemetry once usage-unblocked"), which names the missing evidence and the
  * reason it could not be collected in the task-1285 environment.
  */
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMistralTelemetry = extractMistralTelemetry;
+exports.getMistralProviderModel = getMistralProviderModel;
 /**
  * Attempt to extract telemetry from a mistral launcher result.
  * Since mistral/vibe provides no parseable usage data, always returns null.
@@ -24,10 +27,9 @@
  * @returns {null} Always null — mistral/vibe has no telemetry parser
  */
 function extractMistralTelemetry() {
-  // Mistral Vibe does not emit token usage data. Honest zero.
-  return null;
+    // Mistral Vibe does not emit token usage data. Honest zero.
+    return null;
 }
-
 /**
  * Return the provider/model pair for mistral tasks.
  * Used as fallback when telemetry is null.
@@ -35,10 +37,5 @@ function extractMistralTelemetry() {
  * @returns {{provider: string, model: string}}
  */
 function getMistralProviderModel() {
-  return { provider: 'mistral', model: 'mistral' };
+    return { provider: 'mistral', model: 'mistral' };
 }
-
-module.exports = {
-  extractMistralTelemetry,
-  getMistralProviderModel,
-};

package/lib/agents/mistral-telemetry.ts

@@ -0,0 +1,44 @@
+/**
+ * Mistral (Vibe) Telemetry Stub
+ *
+ * Mistral Vibe in programmatic mode does not output token-usage data to
+ * stdout/stderr, and has no CLI endpoint for querying session usage.
+ * This stub records honest zeros for all token columns so the stats CSV
+ * never contains fabricated data.
+ *
+ * Provider and model fields are set to "mistral" to indicate the agent family.
+ * The actual model is determined at runtime via VIBE_ACTIVE_MODEL env var
+ * but is not captured per-session, so model falls back to "mistral".
+ *
+ * See task-1285 for the full telemetry credibility design. The blocked
+ * verification is tracked as follow-up task-1288 ("Verify vibe/mistral
+ * telemetry once usage-unblocked"), which names the missing evidence and the
+ * reason it could not be collected in the task-1285 environment.
+ */
+
+/**
+ * Attempt to extract telemetry from a mistral launcher result.
+ * Since mistral/vibe provides no parseable usage data, always returns null.
+ *
+ * @param {object} result - The launcher result object
+ * @returns {null} Always null — mistral/vibe has no telemetry parser
+ */
+function extractMistralTelemetry() {
+  // Mistral Vibe does not emit token usage data. Honest zero.
+  return null;
+}
+
+/**
+ * Return the provider/model pair for mistral tasks.
+ * Used as fallback when telemetry is null.
+ *
+ * @returns {{provider: string, model: string}}
+ */
+function getMistralProviderModel() {
+  return { provider: 'mistral', model: 'mistral' };
+}
+
+export {
+  extractMistralTelemetry,
+  getMistralProviderModel,
+};

package/lib/agents/mistral.js

@@ -1,5 +1,10 @@
-const { spawnAndTee } = require('../core/spawn-tee');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMistralInvocation = buildMistralInvocation;
+exports.extractMistralSessionId = extractMistralSessionId;
+exports.resolveMistralCommand = resolveMistralCommand;
+exports.startMistralAgent = startMistralAgent;
+const spawn_tee_js_1 = require("../core/spawn-tee.js");
 // Mistral Vibe in programmatic mode (-p/--prompt) does NOT output a resume
 // hint to stdout/stderr like other agents do. Session IDs are stored in
 // ~/.vibe/logs/session/session_<timestamp>_<short_id>/meta.json with UUID format,
@@ -12,67 +17,44 @@ const { spawnAndTee } = require('../core/spawn-tee');
 // Telemetry: mistral/vibe does not expose token-usage data. See mistral-telemetry.js
 // for the honest-zero stub. Stats hooks in active.js and review-loop.js call
 // recordStageStats which defaults to '0' for tokens when telemetry is null.
-
-
-/** @param {string} stdout */
 function extractMistralSessionId(stdout) {
-  void stdout;
-  // Vibe does not currently emit a resume hint in programmatic mode.
-  // Return null to indicate no resume capability via stdout parsing.
-  return null;
+    void stdout;
+    // Vibe does not currently emit a resume hint in programmatic mode.
+    // Return null to indicate no resume capability via stdout parsing.
+    return null;
 }
-
 function resolveMistralCommand() {
-  return 'vibe';
+    return 'vibe';
 }
-
-/**
- * @param {{ prompt: string, worktree: string, env?: object, resume?: boolean, sessionId?: string | null, model?: string | null }} opts
- */
 function buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model = null }) {
-  void resume;
-  void sessionId;
-  const args = ['--prompt', prompt, '--trust', '--output', 'text'];
-
-  // Vibe programmatic mode does not support --resume flag in the same way
-  // as other agents. The --resume flag exists but requires interactive selection
-  // or a session picker. Since we cannot reliably pass a session ID via
-  // programmatic mode, we do not add resume flags here.
-  // If resume capability is proven in a future version, update this.
-
-  // Vibe has no CLI model flag in programmatic mode; the active model is
-  // selected via the VIBE_ACTIVE_MODEL env var (verified from `vibe --help`).
-  const modelEnv = model ? { VIBE_ACTIVE_MODEL: model } : {};
-
-  return {
-    command: resolveMistralCommand(),
-    args,
-    options: {
-      stdio: 'inherit',
-      cwd: worktree,
-      env: { ...process.env, ...env, ...modelEnv }
-    }
-  };
+    void resume;
+    void sessionId;
+    const args = ['--prompt', prompt, '--trust', '--output', 'text'];
+    // Vibe programmatic mode does not support --resume flag in the same way
+    // as other agents. The --resume flag exists but requires interactive selection
+    // or a session picker. Since we cannot reliably pass a session ID via
+    // programmatic mode, we do not add resume flags here.
+    // If resume capability is proven in a future version, update this.
+    // Vibe has no CLI model flag in programmatic mode; the active model is
+    // selected via the VIBE_ACTIVE_MODEL env var (verified from `vibe --help`).
+    const modelEnv = model ? { VIBE_ACTIVE_MODEL: model } : {};
+    return {
+        command: resolveMistralCommand(),
+        args,
+        options: {
+            stdio: 'inherit',
+            cwd: worktree,
+            env: { ...process.env, ...env, ...modelEnv }
+        }
+    };
 }
-
-/**
- * @param {{ prompt: string, worktree: string, env?: object, resume?: boolean, sessionId?: string | null, model?: string | null, teeOptions?: object }} opts
- */
 function startMistralAgent({ prompt, worktree, env, resume = false, sessionId = null, model = null, teeOptions = {} }) {
-  const invocation = buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model });
-  const resultPromise = spawnAndTee(invocation.command, invocation.args, /** @type {any} */({ ...invocation.options, ...teeOptions })).then(result => {
-    if (result && result.stdout) {
-      result.sessionId = extractMistralSessionId(result.stdout);
-    }
-    return result;
-  });
-
-  return { invocation, resultPromise };
+    const invocation = buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model });
+    const resultPromise = (0, spawn_tee_js_1.spawnAndTee)(invocation.command, invocation.args, { ...invocation.options, ...teeOptions }).then((result) => {
+        if (result && result.stdout) {
+            result.sessionId = extractMistralSessionId(result.stdout);
+        }
+        return result;
+    });
+    return { invocation, resultPromise };
 }
-
-module.exports = {
-  buildMistralInvocation,
-  extractMistralSessionId,
-  resolveMistralCommand,
-  startMistralAgent
-};

package/lib/agents/mistral.ts

@@ -0,0 +1,84 @@
+import { spawnAndTee } from '../core/spawn-tee.js';
+
+interface MistralInvocationOptions {
+  prompt: string;
+  worktree: string;
+  env?: Record<string, string>;
+  resume?: boolean;
+  sessionId?: string | null;
+  model?: string | null;
+}
+
+interface StartMistralAgentOptions extends MistralInvocationOptions {
+  teeOptions?: object;
+}
+
+// Mistral Vibe in programmatic mode (-p/--prompt) does NOT output a resume
+// hint to stdout/stderr like other agents do. Session IDs are stored in
+// ~/.vibe/logs/session/session_<timestamp>_<short_id>/meta.json with UUID format,
+// but there is no reliable stdout pattern to extract. Therefore, Mistral is
+// NOT marked as RESUME_CAPABLE in agents.js. If future Vibe versions add
+// a resume hint, update this regex and add 'mistral' to RESUME_CAPABLE.
+// Current session ID format in meta.json: UUID like "a3dd3d4d-f97d-d57d-4942-a1f694e3a922"
+// Directory naming uses first 8 chars: session_20260521_162703_a3dd3d4d
+// No stdout marker detected in testing, so we leave this as null.
+// Telemetry: mistral/vibe does not expose token-usage data. See mistral-telemetry.js
+// for the honest-zero stub. Stats hooks in active.js and review-loop.js call
+// recordStageStats which defaults to '0' for tokens when telemetry is null.
+
+
+function extractMistralSessionId(stdout: string) {
+  void stdout;
+  // Vibe does not currently emit a resume hint in programmatic mode.
+  // Return null to indicate no resume capability via stdout parsing.
+  return null;
+}
+
+function resolveMistralCommand() {
+  return 'vibe';
+}
+
+function buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model = null }: MistralInvocationOptions) {
+  void resume;
+  void sessionId;
+  const args = ['--prompt', prompt, '--trust', '--output', 'text'];
+
+  // Vibe programmatic mode does not support --resume flag in the same way
+  // as other agents. The --resume flag exists but requires interactive selection
+  // or a session picker. Since we cannot reliably pass a session ID via
+  // programmatic mode, we do not add resume flags here.
+  // If resume capability is proven in a future version, update this.
+
+  // Vibe has no CLI model flag in programmatic mode; the active model is
+  // selected via the VIBE_ACTIVE_MODEL env var (verified from `vibe --help`).
+  const modelEnv = model ? { VIBE_ACTIVE_MODEL: model } : {};
+
+  return {
+    command: resolveMistralCommand(),
+    args,
+    options: {
+      stdio: 'inherit',
+      cwd: worktree,
+      env: { ...process.env, ...env, ...modelEnv }
+    }
+  };
+}
+
+function startMistralAgent({ prompt, worktree, env, resume = false, sessionId = null, model = null, teeOptions = {} }: StartMistralAgentOptions) {
+  const invocation = buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model });
+  const resultPromise = spawnAndTee(invocation.command, invocation.args, { ...invocation.options, ...teeOptions } as any).then((result: any) => {
+    if (result && result.stdout) {
+      result.sessionId = extractMistralSessionId(result.stdout);
+    }
+    return result;
+  });
+
+  return { invocation, resultPromise };
+}
+
+export {
+  buildMistralInvocation,
+  extractMistralSessionId,
+  resolveMistralCommand,
+  startMistralAgent
+};