thumbgate 1.28.4 → 1.29.2

package/public/pro.html

@@ -37,7 +37,7 @@ __GA_BOOTSTRAP__
 <script type="application/ld+json">
 {
   "@context": "https://schema.org",
-  "@type": "FAQPage", "mainEntity": [{ "@type": "Question", "name": "How is Pro different from the free install?", "acceptedAnswer": { "@type": "Answer", "text": "Free keeps local recall, checks, and MCP. Pro adds the personal dashboard, DPO export, auto-connect, and founder support." } }, { "@type": "Question", "name": "Does Pro require a cloud account?", "acceptedAnswer": { "@type": "Answer", "text": "No. Pro stays local-first; Enterprise is the hosted rollout lane for shared lessons, org visibility, and reviews." } }, { "@type": "Question", "name": "What happens after checkout?", "acceptedAnswer": { "@type": "Answer", "text": "You activate Pro, connect the local dashboard, and inspect blocked actions, lessons, and exports." } }, { "@type": "Question", "name": "When should I choose Enterprise instead of Pro?", "acceptedAnswer": { "@type": "Answer", "text": "Choose Enterprise when one correction needs to protect multiple developers or agents across shared repositories." } }]
+  "@type": "FAQPage", "mainEntity": [{ "@type": "Question", "name": "How is Pro different from the free install?", "acceptedAnswer": { "@type": "Answer", "text": "Free keeps local recall, checks, and MCP. Pro adds the personal dashboard, DPO export, auto-connect, and founder support." } }, { "@type": "Question", "name": "Does Pro require a cloud account?", "acceptedAnswer": { "@type": "Answer", "text": "No. Pro stays local-first. Enterprise service work is qualified and signed after intake; hosted team sync and a hosted org dashboard are not generally available." } }, { "@type": "Question", "name": "What happens after checkout?", "acceptedAnswer": { "@type": "Answer", "text": "You activate Pro, connect the local dashboard, and inspect blocked actions, lessons, and exports." } }, { "@type": "Question", "name": "When should I choose Enterprise instead of Pro?", "acceptedAnswer": { "@type": "Answer", "text": "Choose Enterprise service work after proof when two or three consequential local workflows need explicit approval boundaries, rollback paths, and evidence ownership. It does not imply generally available hosted team features." } }]
 }
 </script>
 
@@ -926,7 +926,7 @@ __GA_BOOTSTRAP__
       <div class="team-card">
         <div class="section-label" style="text-align:left;margin-bottom:8px;">When Enterprise is better</div>
         <h3>Need shared enforcement?</h3>
-        <p>Choose Enterprise when one correction must protect multiple developers or agents across shared repositories, CI, approval policies, and audit trails. Enterprise is custom pricing, scoped after intake.</p>
+        <p>Choose Enterprise service work after proof when two or three consequential local workflows need explicit approval boundaries, rollback paths, and evidence ownership. The proposal-only paths are a $15,000 30-day pilot and $10,000/month after a completed pilot.</p>
         <div class="hero-actions" style="margin-top:18px;">
           <a class="btn-secondary" href="/#workflow-sprint-intake">Book an Enterprise Pilot Call</a>
         </div>
@@ -951,7 +951,7 @@ __GA_BOOTSTRAP__
       </div>
       <div class="faq-item">
         <button class="faq-q" type="button" onclick="toggleFaq(this)" onkeydown="handleFaqKeydown(event)" aria-expanded="false">Does Pro require a cloud account?</button>
-        <div class="faq-a">No. Pro is still local-first for the individual operator lane. Enterprise is the hosted rollout lane for shared lessons, org visibility, and hosted review views.</div>
+        <div class="faq-a">No. Pro is still local-first for the individual operator lane. Enterprise service work is qualified and signed after intake; hosted team sync, a hosted org dashboard, and hosted review views are not generally available.</div>
       </div>
       <div class="faq-item">
         <button class="faq-q" type="button" onclick="toggleFaq(this)" onkeydown="handleFaqKeydown(event)" aria-expanded="false">What happens after checkout?</button>
@@ -959,7 +959,7 @@ __GA_BOOTSTRAP__
       </div>
       <div class="faq-item">
         <button class="faq-q" type="button" onclick="toggleFaq(this)" onkeydown="handleFaqKeydown(event)" aria-expanded="false">When should I choose Enterprise instead of Pro?</button>
-        <div class="faq-a">Choose Enterprise when one thumbs-down should protect multiple people or agents across shared repositories, or when you need shared hosted lessons, org dashboard visibility, and a workflow hardening pilot with rollout review views.</div>
+        <div class="faq-a">Choose Enterprise service work after proof when two or three consequential local workflows need explicit approval boundaries, rollback paths, and evidence ownership. The current pilot uses the local runtime and does not promise hosted team sync, a hosted org dashboard, or hosted review views.</div>
       </div>
     </div>
   </div>

package/scripts/agent-outcome-eval.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  TASK_OUTCOME_SCHEMA,
+  calculateTaskOutcomeMetrics,
+  normalizeTaskOutcome,
+} = require('./task-outcomes');
+const { validateToolContract } = require('./tool-contract-validator');
+
+const ROOT = path.join(__dirname, '..');
+const DEFAULT_SUITE = path.join(ROOT, 'config', 'evals', 'agent-outcomes-golden.json');
+const DEFAULT_BASELINE = path.join(ROOT, 'config', 'evals', 'agent-outcomes-baseline.json');
+
+function runCase(testCase = {}) {
+  const receipt = normalizeTaskOutcome(testCase.receipt, new Date('2026-07-26T00:00:00.000Z'));
+  const validation = validateToolContract(TASK_OUTCOME_SCHEMA, receipt);
+  const expectedReasons = [...(testCase.expected?.reasons || [])]
+    .sort((left, right) => left.localeCompare(right));
+  const actualReasons = [...(receipt.workingReasons || [])]
+    .sort((left, right) => left.localeCompare(right));
+  const checks = [
+    {
+      id: 'schema_valid',
+      pass: validation.valid,
+      detail: validation.valid ? 'receipt schema valid' : validation.errors.join('; '),
+    },
+    {
+      id: 'working_verdict',
+      pass: receipt.working === testCase.expected?.working,
+      detail: `expected ${testCase.expected?.working}, got ${receipt.working}`,
+    },
+    {
+      id: 'reason_codes',
+      pass: JSON.stringify(actualReasons) === JSON.stringify(expectedReasons),
+      detail: `expected [${expectedReasons.join(', ')}], got [${actualReasons.join(', ')}]`,
+    },
+  ];
+  const passed = checks.every((check) => check.pass);
+  return {
+    id: testCase.id,
+    status: passed ? 'pass' : 'fail',
+    score: Math.round((checks.filter((check) => check.pass).length / checks.length) * 100),
+    severity: testCase.severity,
+    split: testCase.split,
+    checks,
+    receipt,
+  };
+}
+
+function runAgentOutcomeEval(options = {}) {
+  const suitePath = path.resolve(options.suitePath || DEFAULT_SUITE);
+  const suite = JSON.parse(fs.readFileSync(suitePath, 'utf8'));
+  if (!Array.isArray(suite.cases) || suite.cases.length === 0) {
+    throw new Error('Agent outcome suite must contain non-empty cases');
+  }
+  const results = suite.cases.map(runCase);
+  const passed = results.filter((result) => result.status === 'pass').length;
+  const score = Math.round((results.reduce((sum, result) => sum + result.score, 0) / results.length));
+  const minimumCases = Number(suite.successCriteria?.minimumCases || 1);
+  const minimumScore = Number(suite.successCriteria?.minAggregateScore || 100);
+  const baselinePath = path.resolve(options.baselinePath || DEFAULT_BASELINE);
+  const baseline = fs.existsSync(baselinePath)
+    ? JSON.parse(fs.readFileSync(baselinePath, 'utf8'))
+    : null;
+  const regressions = compareBaseline(results, baseline);
+  const report = {
+    suite: suite.name,
+    generatedAt: new Date().toISOString(),
+    evidenceStatus: results.length >= minimumCases ? 'measured' : 'insufficient_evidence',
+    total: results.length,
+    passed,
+    failed: results.length - passed,
+    score,
+    minimumScore,
+    minimumCases,
+    regressions,
+    pass: results.length >= minimumCases
+      && score >= minimumScore
+      && (!suite.successCriteria?.requireNoRegressions || regressions.length === 0),
+    metrics: calculateTaskOutcomeMetrics(results.map((result) => result.receipt)),
+    results,
+  };
+  return report;
+}
+
+function compareBaseline(results, baseline) {
+  if (!baseline) return [];
+  const current = new Map(results.map((result) => [result.id, result]));
+  const regressions = [];
+  for (const previous of baseline.results || []) {
+    const result = current.get(previous.id);
+    if (!result) {
+      regressions.push({ id: previous.id, reason: 'missing_case' });
+    } else if (result.score < previous.score || (previous.status === 'pass' && result.status !== 'pass')) {
+      regressions.push({
+        id: previous.id,
+        reason: 'score_or_status_regression',
+        baselineScore: previous.score,
+        currentScore: result.score,
+      });
+    }
+  }
+  return regressions;
+}
+
+function isCliInvocation() {
+  return Boolean(process.argv[1]) && path.resolve(process.argv[1]) === __filename;
+}
+
+if (isCliInvocation()) {
+  const suitePath = process.argv.find((arg) => arg.startsWith('--suite='))?.slice(8);
+  const baselinePath = process.argv.find((arg) => arg.startsWith('--baseline='))?.slice(11);
+  const outputPath = process.argv.find((arg) => arg.startsWith('--output='))?.slice(9);
+  const report = runAgentOutcomeEval({ suitePath, baselinePath });
+  if (outputPath) {
+    fs.mkdirSync(path.dirname(path.resolve(outputPath)), { recursive: true });
+    fs.writeFileSync(path.resolve(outputPath), `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+  }
+  console.log(JSON.stringify(report, null, 2));
+  process.exitCode = report.pass ? 0 : 1;
+}
+
+module.exports = {
+  compareBaseline,
+  runAgentOutcomeEval,
+  runCase,
+};

package/scripts/agent-outcome-monitor.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { calculateTaskOutcomeMetrics, readTaskOutcomes } = require('./task-outcomes');
+
+const DEFAULT_THRESHOLDS = path.join(__dirname, '..', 'config', 'agent-outcome-monitor-thresholds.json');
+const DEFAULT_HOSTED_ORIGIN = 'https://thumbgate-production.up.railway.app';
+const DEFAULT_MONITOR_PATH = '/v1/task-outcomes/monitor';
+const DEFAULT_SCHEDULE_ID = 'thumbgate-agent-outcome-monitor';
+
+function monitorTaskOutcomes(outcomes = [], options = {}) {
+  const metrics = calculateTaskOutcomeMetrics(outcomes);
+  const thresholds = options.thresholds || JSON.parse(fs.readFileSync(
+    path.resolve(options.thresholdsPath || DEFAULT_THRESHOLDS),
+    'utf8',
+  ));
+  const minimumSamples = Number(thresholds.minimumSamples || 1);
+  if (metrics.sampleSize < minimumSamples) {
+    return {
+      generatedAt: new Date().toISOString(),
+      verdict: 'insufficient_evidence',
+      sampleSize: metrics.sampleSize,
+      minimumSamples,
+      alerts: [{
+        id: 'minimum-samples',
+        severity: 'block',
+        message: `Need ${minimumSamples} task outcomes; observed ${metrics.sampleSize}.`,
+      }],
+      metrics,
+    };
+  }
+
+  const values = flattenMetricValues(metrics);
+  const alerts = [];
+  for (const [id, rule] of Object.entries(thresholds)) {
+    if (id === 'minimumSamples') continue;
+    const actual = values[id];
+    if (actual === null || actual === undefined) {
+      alerts.push({
+        id: `${id}-missing`,
+        severity: rule.severity || 'warn',
+        message: `${id} has no measured denominator.`,
+      });
+      continue;
+    }
+    if (!passesRule(actual, rule)) {
+      alerts.push({
+        id: `${id}-threshold`,
+        severity: rule.severity || 'warn',
+        actual,
+        expected: `${rule.operator} ${rule.value}`,
+        message: `${id}=${actual} violates ${rule.operator} ${rule.value}.`,
+      });
+    }
+  }
+  let verdict = 'healthy';
+  if (alerts.some((alert) => alert.severity === 'block')) {
+    verdict = 'blocked';
+  } else if (alerts.length > 0) {
+    verdict = 'watch';
+  }
+  return {
+    generatedAt: new Date().toISOString(),
+    verdict,
+    sampleSize: metrics.sampleSize,
+    minimumSamples,
+    alerts,
+    metrics,
+  };
+}
+
+function flattenMetricValues(metrics) {
+  return {
+    workingRate: metrics.task.workingRate,
+    verifiedCompletionRate: metrics.task.verifiedCompletionRate,
+    evidenceBackedCompletionRate: metrics.task.evidenceBackedCompletionRate,
+    unsupportedClaimRate: metrics.task.unsupportedClaimRate,
+    toolContractAccuracy: metrics.tools.contractAccuracy,
+    executionSuccessRate: metrics.tools.executionSuccessRate,
+    duplicateSideEffectRate: metrics.tools.duplicateSideEffectRate,
+    unsafeEscapeRate: metrics.safety.unsafeEscapeRate,
+    policyViolationRate: metrics.safety.policyViolationRate,
+    safeFalseBlockRate: metrics.safety.safeFalseBlockRate,
+    correctEscalationRate: metrics.escalation.correctEscalationRate,
+    latencyP95Ms: metrics.efficiency.latencyP95Ms,
+  };
+}
+
+function passesRule(actual, rule) {
+  if (rule.operator === 'gte') return actual >= Number(rule.value);
+  if (rule.operator === 'lte') return actual <= Number(rule.value);
+  if (rule.operator === 'gt') return actual > Number(rule.value);
+  if (rule.operator === 'lt') return actual < Number(rule.value);
+  if (rule.operator === 'eq') return actual === Number(rule.value);
+  throw new Error(`Unsupported threshold operator '${rule.operator}'`);
+}
+
+function isCliInvocation() {
+  return Boolean(process.argv[1]) && path.resolve(process.argv[1]) === __filename;
+}
+
+function parseArgs(argv = []) {
+  return {
+    hosted: argv.includes('--hosted'),
+    installSchedule: argv.includes('--install-schedule'),
+    inputPath: valueForArg(argv, '--input='),
+    thresholdsPath: valueForArg(argv, '--thresholds='),
+    outputPath: valueForArg(argv, '--output='),
+    baseUrl: valueForArg(argv, '--base-url='),
+    workingDirectory: valueForArg(argv, '--working-directory='),
+  };
+}
+
+function valueForArg(argv, prefix) {
+  const value = argv.find((arg) => arg.startsWith(prefix));
+  return value ? value.slice(prefix.length) : undefined;
+}
+
+async function fetchHostedMonitor(options = {}) {
+  const env = options.env || process.env;
+  const { loadObservabilityEnv } = require('./observability-env');
+  loadObservabilityEnv({
+    env,
+    operatorPath: options.operatorPath,
+    observabilityPath: options.observabilityPath,
+    applyStripeManagedFiles: false,
+  });
+
+  const apiKey = String(env.THUMBGATE_OPERATOR_KEY || env.THUMBGATE_API_KEY || '').trim();
+  if (!apiKey) {
+    return {
+      generatedAt: new Date().toISOString(),
+      verdict: 'not_configured',
+      source: 'hosted',
+      reason: 'operator_authentication_unavailable',
+    };
+  }
+
+  const baseUrl = options.baseUrl
+    || env.THUMBGATE_BILLING_API_BASE_URL
+    || DEFAULT_HOSTED_ORIGIN;
+  const url = new URL(DEFAULT_MONITOR_PATH, baseUrl);
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), Number(options.timeoutMs || 15000));
+  try {
+    const response = await (options.fetchImpl || globalThis.fetch)(url, {
+      method: 'GET',
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        accept: 'application/json',
+      },
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      return {
+        generatedAt: new Date().toISOString(),
+        verdict: 'unavailable',
+        source: 'hosted',
+        httpStatus: response.status,
+        reason: 'hosted_monitor_http_error',
+      };
+    }
+    const report = await response.json();
+    return {
+      ...report,
+      source: 'hosted',
+    };
+  } catch (error) {
+    return {
+      generatedAt: new Date().toISOString(),
+      verdict: 'unavailable',
+      source: 'hosted',
+      reason: error?.name === 'AbortError' ? 'hosted_monitor_timeout' : 'hosted_monitor_request_failed',
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function buildAgentOutcomeMonitorSchedule(options = {}) {
+  const workingDirectory = path.resolve(options.workingDirectory || process.cwd());
+  const outputPath = path.resolve(
+    options.outputPath
+      || path.join(os.homedir(), '.thumbgate', 'reports', 'agent-outcome-monitor.json'),
+  );
+  const args = [
+    __filename,
+    '--hosted',
+    `--output=${outputPath}`,
+  ];
+  if (options.baseUrl) args.push(`--base-url=${options.baseUrl}`);
+  const command = [
+    'const { spawnSync } = require(\'node:child_process\');',
+    `const result = spawnSync(process.execPath, ${JSON.stringify(args)}, {`,
+    `  cwd: ${JSON.stringify(workingDirectory)},`,
+    '  env: process.env,',
+    '  stdio: \'inherit\',',
+    '});',
+    'if (result.error) throw result.error;',
+    'process.exit(typeof result.status === \'number\' ? result.status : 1);',
+  ].join(' ');
+  return {
+    id: DEFAULT_SCHEDULE_ID,
+    name: 'ThumbGate Agent Outcome Monitor',
+    description: 'Checks hosted task outcomes daily against fail-closed production thresholds.',
+    schedule: options.schedule || 'daily 10:17',
+    command,
+    workingDirectory,
+  };
+}
+
+function installAgentOutcomeMonitorSchedule(options, manager) {
+  const scheduleManager = manager || require('./schedule-manager');
+  return scheduleManager.createSchedule(buildAgentOutcomeMonitorSchedule(options || {}));
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+  if (options.installSchedule) {
+    const result = installAgentOutcomeMonitorSchedule(options);
+    console.log(JSON.stringify(result, null, 2));
+    process.exitCode = result.success ? 0 : 1;
+    return result;
+  }
+
+  const report = options.hosted
+    ? await fetchHostedMonitor(options)
+    : monitorTaskOutcomes(
+      readTaskOutcomes({ inputPath: options.inputPath }),
+      { thresholdsPath: options.thresholdsPath },
+    );
+  if (options.outputPath) {
+    const outputPath = path.resolve(options.outputPath);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+  }
+  console.log(JSON.stringify(report, null, 2));
+  process.exitCode = report.verdict === 'healthy' ? 0 : 1;
+  return report;
+}
+
+if (isCliInvocation()) {
+  main().catch((error) => {
+    console.error(`Agent outcome monitor failed: ${error.message}`);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = {
+  buildAgentOutcomeMonitorSchedule,
+  fetchHostedMonitor,
+  flattenMetricValues,
+  installAgentOutcomeMonitorSchedule,
+  main,
+  monitorTaskOutcomes,
+  parseArgs,
+  passesRule,
+};

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;
 }