thumbgate 1.29.1 → 1.29.2

package/scripts/agent-reasoning-traces.js

@@ -107,10 +107,6 @@ function redactTraceText(value, maxLength = MAX_TEXT) {
   return text.length > maxLength ? `${text.slice(0, maxLength - 1)}…` : text;
 }
 
-function hashText(value) {
-  return crypto.createHash('sha256').update(String(value || '')).digest('hex').slice(0, 16);
-}
-
 function extractMessages(record = {}) {
   const candidates = [
     record.steps,
@@ -135,7 +131,7 @@ function normalizeAgentTraceRecord(record = {}, options = {}) {
   const messages = extractMessages(record);
   const steps = messages.map((message, index) => normalizeStep(message, index)).filter(Boolean);
   const taskType = options.taskType || record.taskType || inferTaskType(record, steps);
-  const traceId = record.traceId || record.id || record.uuid || `trace_${Date.now()}_${hashText(JSON.stringify(record)).slice(0, 8)}`;
+  const traceId = record.traceId || record.id || record.uuid || `trace_${crypto.randomUUID()}`;
   const outcome = normalizeOutcome(record);
 
   return {
@@ -171,11 +167,11 @@ function normalizeStep(message = {}, index = 0) {
     role,
     eventType,
     text: eventType === 'reasoning' ? '[REDACTED_REASONING_TRACE]' : redacted,
-    textHash: hashText(rawContent),
+    textHash: null,
     reasoning: reasoningRaw ? {
       present: true,
       charCount: String(reasoningRaw).length,
-      hash: hashText(reasoningRaw),
+      hash: null,
     } : null,
     toolCalls,
     error: detectError(redacted, message),
@@ -191,7 +187,10 @@ function extractToolCalls(message = {}, content = '') {
     const fn = call.function || call;
     calls.push({
       name: String(fn.name || call.name || call.tool || 'unknown'),
-      argumentsHash: hashText(JSON.stringify(fn.arguments || call.arguments || {})),
+      // Deliberately do not persist a deterministic argument fingerprint.
+      // Low-entropy values (flags, small IDs, booleans) can be recovered by
+      // enumerating candidate inputs even when only a truncated hash is stored.
+      argumentsHash: null,
     });
   }
 
@@ -584,7 +583,7 @@ function formatTraceAnalyticsReport(report = {}) {
     lines.push(`- ${candidate.gateId}: ${candidate.recommendation}`);
   }
   if (!report.gateCandidates?.length) lines.push('- None: trace shapes are currently healthy.');
-  lines.push('', 'Privacy: raw hidden reasoning is not stored; only hashes, event labels, and redacted observable text are retained.', '');
+  lines.push('', 'Privacy: raw hidden reasoning and deterministic content fingerprints are not stored; only event labels and redacted observable text are retained.', '');
   return `${lines.join('\n')}\n`;
 }
 

package/scripts/async-job-runner.js

@@ -9,6 +9,7 @@ const { runVerificationLoop } = require('./verification-loop');
 const { createExperiment } = require('./experiment-tracker');
 const { recommendEvolutionTarget } = require('./workspace-evolver');
 const { ensureDir } = require('./fs-utils');
+const { recordTaskOutcome } = require('./task-outcomes');
 
 const JOB_LOG_FILENAME = 'job-log.jsonl';
 const JOB_CONTROL_FILENAME = 'job-control.json';
@@ -306,6 +307,107 @@ function appendJobLog(result) {
   appendJSONL(getJobRuntimePaths(result.jobId).logPath, result);
 }
 
+function taskOutcomeStatus(result, verificationPassed) {
+  if (verificationPassed) return 'completed';
+  if (result.status === 'failed' || result.status === 'cancelled') return 'failed';
+  return 'partial';
+}
+
+function attachTaskOutcome(result, state, options = {}) {
+  const verification = result.phases?.verification;
+  const stageHistory = Array.isArray(state.stageHistory) ? state.stageHistory : [];
+  const failed = result.status === 'failed' || result.status === 'cancelled';
+  const verificationPassed = verification?.accepted === true;
+  const verificationPerformed = Boolean(verification);
+  const status = taskOutcomeStatus(result, verificationPassed);
+  const evidence = [];
+  if (verificationPerformed) {
+    evidence.push(`verification score ${verification.score}; attempts ${verification.attempts}`);
+  }
+  if (state.lastError?.message) evidence.push(`execution error: ${state.lastError.message}`);
+
+  const outcome = recordTaskOutcome({
+    taskId: result.jobId,
+    taskType: 'async-job',
+    goal: state.jobSpec?.context || `Execute managed job ${result.jobId}`,
+    expectedOutcome: 'Complete all stages and pass post-run verification',
+    status,
+    verification: {
+      performed: verificationPerformed,
+      passed: verificationPassed,
+      verifier: verificationPerformed ? 'verification-loop' : undefined,
+      method: verificationPerformed ? 'prevention-rule verification' : undefined,
+      evidence,
+      unsupportedClaims: 0,
+    },
+    toolCalls: stageHistory.map((stage) => ({
+      name: stage.name,
+      contractValid: true,
+      allowed: true,
+      succeeded: true,
+      attempts: 1,
+      latencyMs: 0,
+      costUsd: 0,
+      sideEffect: false,
+      duplicateSideEffect: false,
+    })),
+    policy: {
+      violations: 0,
+      unsafeEscapes: 0,
+      falseBlocks: 0,
+    },
+    failure: failed ? {
+      category: state.lastError?.code || result.status,
+      recovered: false,
+      repeated: false,
+      rolledBack: false,
+    } : undefined,
+    efficiency: {
+      latencyMs: result.durationMs,
+      costUsd: 0,
+      firstAttempt: verification?.attempts === 1,
+    },
+    traceId: result.jobId,
+    idempotencyKey: `${result.jobId}:${result.status}:${state.endedAt || state.updatedAt}`,
+    metadata: {
+      source: 'async-job-runner',
+      completedStages: stageHistory.length,
+    },
+  }, options);
+  result.taskOutcome = outcome.receipt;
+  return result;
+}
+
+function verificationFeedbackContext(job, verification) {
+  if (!verification) {
+    return `Job ${job.id} completed without post-run verification`;
+  }
+  if (verification.accepted) {
+    return `Job ${job.id} passed verification after ${verification.attempts} attempt(s)`;
+  }
+  const violations = verification.finalVerification?.violations || [];
+  const patterns = violations.map((violation) => violation.pattern).join('; ');
+  return `Job ${job.id} failed verification after ${verification.attempts} attempt(s): ${patterns}`;
+}
+
+function verificationFeedbackFields(verification) {
+  if (!verification) {
+    return {
+      whatWentWrong: 'Post-run verification was skipped, so task success is unverified',
+      whatToChange: 'Run standard verification before recording a completed task',
+    };
+  }
+  if (verification.accepted) {
+    return {
+      whatWorked: 'Verification loop accepted output',
+    };
+  }
+  return {
+    whatWentWrong: `Failed ${verification.attempts} verification attempts`,
+    whatToChange: 'Improve output to avoid known mistake patterns',
+  };
+}
+
 function readJobLog(limit) {
   const entries = readJSONL(getJobRuntimePaths().logPath);
   return limit ? entries.slice(-limit) : entries;
@@ -794,6 +896,7 @@ function executeJob(job, options = {}) {
         feedback,
         improvementExperiment,
       });
+      attachTaskOutcome(result, failedState);
       appendJobLog(result);
       return result;
     }
@@ -820,19 +923,9 @@ function executeJob(job, options = {}) {
   const feedback = normalizedJob.recordFeedback === false
     ? null
     : captureFeedback({
-      signal: !verification || verification.accepted ? 'up' : 'down',
-      context: !verification
-        ? `Job ${normalizedJob.id} completed without post-run verification`
-        : verification.accepted
-          ? `Job ${normalizedJob.id} passed verification after ${verification.attempts} attempt(s)`
-          : `Job ${normalizedJob.id} failed verification after ${verification.attempts} attempt(s): ${(verification.finalVerification.violations || []).map((violation) => violation.pattern).join('; ')}`,
-      whatWorked: !verification
-        ? 'Operational job completed successfully'
-        : verification.accepted
-          ? 'Verification loop accepted output'
-          : undefined,
-      whatWentWrong: verification && !verification.accepted ? `Failed ${verification.attempts} verification attempts` : undefined,
-      whatToChange: verification && !verification.accepted ? 'Improve output to avoid known mistake patterns' : undefined,
+      signal: verification?.accepted ? 'up' : 'down',
+      context: verificationFeedbackContext(normalizedJob, verification),
+      ...verificationFeedbackFields(verification),
       tags: !verification
         ? [...normalizedJob.tags, 'async-job-runner', 'verification-skipped']
         : [...normalizedJob.tags, 'verification-loop'],
@@ -863,6 +956,7 @@ function executeJob(job, options = {}) {
     feedback,
     improvementExperiment,
   });
+  attachTaskOutcome(result, terminalState);
   appendJobLog(result);
   return result;
 }

package/scripts/durability/step.js

@@ -107,7 +107,34 @@ function errMessage(err) {
   return err?.message ?? err;
 }
 
-function handleStepError({ err, attempt, retries, classify, backoffMs, name, onRetry, onFail, logger }) {
+function retryAfterMs(err) {
+  const raw = err?.retryAfterMs
+    ?? err?.headers?.['retry-after-ms']
+    ?? err?.headers?.['retry-after'];
+  if (raw === undefined || raw === null || raw === '') return null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric)) {
+    return String(raw).includes('.') || err?.headers?.['retry-after'] !== undefined
+      ? Math.max(0, numeric * 1000)
+      : Math.max(0, numeric);
+  }
+  const dateMs = Date.parse(raw);
+  return Number.isNaN(dateMs) ? null : Math.max(0, dateMs - Date.now());
+}
+
+function handleStepError({
+  err,
+  attempt,
+  retries,
+  classify,
+  backoffMs,
+  name,
+  onRetry,
+  onFail,
+  logger,
+  jitterRatio,
+  randomFn,
+}) {
   const verdict = classify(err);
   const terminal = verdict === 'fail' || attempt >= retries;
   if (terminal) {
@@ -117,7 +144,11 @@ function handleStepError({ err, attempt, retries, classify, backoffMs, name, onR
     }
     return { terminal: true };
   }
-  const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)];
+  const configuredWait = backoffMs[Math.min(attempt, backoffMs.length - 1)];
+  const serverWait = retryAfterMs(err);
+  const baseWait = serverWait === null ? configuredWait : Math.max(configuredWait, serverWait);
+  const jitter = jitterRatio > 0 ? baseWait * jitterRatio * ((randomFn() * 2) - 1) : 0;
+  const waitMs = Math.max(0, Math.round(baseWait + jitter));
   if (typeof onRetry === 'function') onRetry({ name, attempt, err, waitMs, verdict });
   if (typeof logger === 'function') {
     logger(`[step:${name}] RETRY attempt=${attempt} waitMs=${waitMs} err=${errMessage(err)}`);
@@ -126,10 +157,9 @@ function handleStepError({ err, attempt, retries, classify, backoffMs, name, onR
 }
 
 async function runStep(name, options, fn) {
-  if (typeof options === 'function') {
-    fn = options;
-    options = {};
-  }
+  const invocation = normalizeStepInvocation(options, fn);
+  options = invocation.options;
+  fn = invocation.fn;
   const {
     retries = 3,
     backoffMs = DEFAULT_BACKOFF_MS,
@@ -139,33 +169,112 @@ async function runStep(name, options, fn) {
     onFail,
     logger,
     sleepFn = sleep,
+    sideEffect = false,
+    idempotencyKey: stepIdempotencyKey,
+    maxElapsedMs = Infinity,
+    jitterRatio = 0,
+    randomFn = Math.random,
   } = options || {};
 
-  if (typeof fn !== 'function') {
-    throw new TypeError(`runStep(${name}): fn must be a function`);
-  }
+  validateStepConfiguration(name, fn, {
+    sideEffect,
+    stepIdempotencyKey,
+    maxElapsedMs,
+  });
 
   let lastErr;
+  const startedAt = Date.now();
   for (let attempt = 0; attempt <= retries; attempt++) {
-    if (typeof onAttempt === 'function') onAttempt({ name, attempt });
+    const context = {
+      name,
+      attempt,
+      idempotencyKey: stepIdempotencyKey || null,
+      elapsedMs: Date.now() - startedAt,
+    };
+    callIfFunction(onAttempt, context);
     try {
-      return await fn({ attempt });
+      return await fn(context);
     } catch (err) {
       lastErr = err;
       const outcome = handleStepError({
-        err, attempt, retries, classify, backoffMs, name, onRetry, onFail, logger,
+        err,
+        attempt,
+        retries,
+        classify,
+        backoffMs,
+        name,
+        onRetry,
+        onFail,
+        logger,
+        jitterRatio: Math.max(0, Number(jitterRatio) || 0),
+        randomFn,
       });
       if (outcome.terminal) throw err;
+      enforceRetryBudget({
+        err,
+        attempt,
+        name,
+        onFail,
+        startedAt,
+        waitMs: outcome.waitMs,
+        maxElapsedMs,
+      });
       await sleepFn(outcome.waitMs);
     }
   }
   throw lastErr;
 }
 
+function normalizeStepInvocation(options, fn) {
+  if (typeof options === 'function') return { options: {}, fn: options };
+  return { options: options || {}, fn };
+}
+
+function validateStepConfiguration(name, fn, options) {
+  if (typeof fn !== 'function') {
+    throw new TypeError(`runStep(${name}): fn must be a function`);
+  }
+  if (options.sideEffect && !String(options.stepIdempotencyKey || '').trim()) {
+    const error = new Error(`runStep(${name}): side-effecting steps require idempotencyKey`);
+    error.code = 'THUMBGATE_IDEMPOTENCY_KEY_REQUIRED';
+    error.nonRetryable = true;
+    throw error;
+  }
+  if (!Number.isFinite(Number(options.maxElapsedMs)) && options.maxElapsedMs !== Infinity) {
+    throw new TypeError(`runStep(${name}): maxElapsedMs must be finite or Infinity`);
+  }
+}
+
+function callIfFunction(callback, payload) {
+  if (typeof callback === 'function') callback(payload);
+}
+
+function enforceRetryBudget({
+  err,
+  attempt,
+  name,
+  onFail,
+  startedAt,
+  waitMs,
+  maxElapsedMs,
+}) {
+  if (Date.now() - startedAt + waitMs <= maxElapsedMs) return;
+  err.code = err.code || 'THUMBGATE_RETRY_BUDGET_EXHAUSTED';
+  err.retryBudgetExhausted = true;
+  callIfFunction(onFail, {
+    name,
+    attempt,
+    err,
+    verdict: 'retry_budget_exhausted',
+  });
+  throw err;
+}
+
 module.exports = {
   runStep,
   idempotencyKey,
   defaultClassify,
   TRANSIENT_CODES,
   DEFAULT_BACKOFF_MS,
+  retryAfterMs,
 };