chore(release): v2.14.55

Author: CharGrnmn

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "job-forge",
-  "version": "2.14.54",
+  "version": "2.14.55",
   "description": "AI-powered job search pipeline for Codex and OpenCode",
   "type": "module",
   "bin": {

package.json

@@ -758,32 +758,40 @@ export async function authorizeSafeRetry({ projectDir, job, priorAttempt, retryO
   }
   const outcomePath = join(runDir, 'outcome.json');
   const eventsPath = join(runDir, 'events.jsonl');
-  if (!existsSync(outcomePath) || !existsSync(eventsPath)) {
-    throw new Error(`${job.id} prior attempt lacks outcome and MCP trace evidence`);
-  }
-  const outcome = parseJson(await readFile(outcomePath, 'utf8'), outcomePath);
-  for (const [label, expected, actual] of [
-    ['candidate', priorAttempt.candidateId, outcome.candidateId],
-    ['company', job.company, outcome.company],
-    ['role', job.role, outcome.role],
-    ['URL', job.url, outcome.url],
-  ]) {
-    if (expected !== actual) throw new Error(`${job.id} prior outcome ${label} does not match`);
-  }
-  if (outcome.submissionAttempted !== false
-    || outcome.submitActionCount !== 0
-    || outcome.otpConfirmationActions !== 0
-    || !['not-submitted', 'not-applicable'].includes(outcome.confirmation?.state)
-    || outcome.confirmation?.source !== 'none') {
-    throw new Error(`${job.id} prior attempt cannot prove a pre-submit terminal outcome`);
-  }
-  if (!Number.isInteger(outcome.runActionsTransactions)
-    || outcome.runActionsTransactions < 0
-    || outcome.runActionsTransactions > 1
-    || !Number.isInteger(outcome.runActionsContinuations)
-    || outcome.runActionsContinuations < 0
-    || outcome.runActionsContinuations > 1) {
-    throw new Error(`${job.id} prior outcome has invalid run-actions counts`);
+  const guardPath = join(runDir, 'tool-guard-state.json');
+  const hasOutcome = existsSync(outcomePath);
+  const hasGuard = existsSync(guardPath);
+  if (!existsSync(eventsPath)) {
+    throw new Error(`${job.id} prior attempt lacks MCP trace evidence`);
+  }
+  if (!hasOutcome && !hasGuard) {
+    throw new Error(`${job.id} prior attempt lacks outcome and guarded startup evidence`);
+  }
+  const outcome = hasOutcome ? parseJson(await readFile(outcomePath, 'utf8'), outcomePath) : null;
+  if (outcome) {
+    for (const [label, expected, actual] of [
+      ['candidate', priorAttempt.candidateId, outcome.candidateId],
+      ['company', job.company, outcome.company],
+      ['role', job.role, outcome.role],
+      ['URL', job.url, outcome.url],
+    ]) {
+      if (expected !== actual) throw new Error(`${job.id} prior outcome ${label} does not match`);
+    }
+    if (outcome.submissionAttempted !== false
+      || outcome.submitActionCount !== 0
+      || outcome.otpConfirmationActions !== 0
+      || !['not-submitted', 'not-applicable'].includes(outcome.confirmation?.state)
+      || outcome.confirmation?.source !== 'none') {
+      throw new Error(`${job.id} prior attempt cannot prove a pre-submit terminal outcome`);
+    }
+    if (!Number.isInteger(outcome.runActionsTransactions)
+      || outcome.runActionsTransactions < 0
+      || outcome.runActionsTransactions > 1
+      || !Number.isInteger(outcome.runActionsContinuations)
+      || outcome.runActionsContinuations < 0
+      || outcome.runActionsContinuations > 1) {
+      throw new Error(`${job.id} prior outcome has invalid run-actions counts`);
+    }
   }
 
   const readOnlyOrLifecycleTools = new Set([
@@ -803,8 +811,6 @@ export async function authorizeSafeRetry({ projectDir, job, priorAttempt, retryO
     'geometra_wait_for_resume_parse',
     'geometra_workflow_state',
   ]);
-  const guardPath = join(runDir, 'tool-guard-state.json');
-  const hasGuard = existsSync(guardPath);
   const mutationCalls = new Map();
   const opaqueCommandExecutions = new Set();
   const safeGmailTools = new Set(['get_message', 'gmail_get_message', 'gmail_list_messages', 'list_messages']);
@@ -850,6 +856,7 @@ export async function authorizeSafeRetry({ projectDir, job, priorAttempt, retryO
   const mutations = [...mutationCalls.values()];
 
   let guardTerminalState = 'legacy-zero-mutation';
+  let outcomeLessRuntimeEvidence = null;
   if (hasGuard) {
     if (opaqueCommandExecutions.size > 0) {
       throw new Error(`${job.id} guarded prior trace contains opaque command execution`);
@@ -867,9 +874,11 @@ export async function authorizeSafeRetry({ projectDir, job, priorAttempt, retryO
     }
     const guardProvesPreSubmit = guard.runActionsTerminalState === 'proven-pre-submit'
       && guard.submitBoundaryObserved === false
+      && guard.otpFills === 0
       && guard.otpConfirmationClicks === 0;
     const guardProvesNoTransaction = guard.runActionsCalls === 0
       && guard.submitBoundaryObserved === false
+      && guard.otpFills === 0
       && guard.otpConfirmationClicks === 0;
     if (!guardProvesPreSubmit && !guardProvesNoTransaction) {
       throw new Error(`${job.id} prior guard cannot prove execution stopped before Submit`);
@@ -879,25 +888,44 @@ export async function authorizeSafeRetry({ projectDir, job, priorAttempt, retryO
       || (!guardProvesPreSubmit && mutations.length > 0)) {
       throw new Error(`${job.id} prior MCP trace contains an unproven mutation`);
     }
-    const guardedTransactions = guard.runActionsCalls > 0 ? 1 : 0;
-    const guardedContinuations = Math.max(0, guard.runActionsCalls - 1);
-    const guardedSessions = guard.connectSucceeded ? 1 : 0;
-    if (outcome.runActionsTransactions !== guardedTransactions
-      || outcome.runActionsContinuations !== guardedContinuations
-      || outcome.sessionsOpened !== guardedSessions
-      || (guardedSessions === 1 && outcome.sessionId !== guard.ownedSessionId)
-      || (guardedSessions === 0 && outcome.sessionId !== null)
-      || outcome.ownSessionDisconnected !== guard.ownedSessionDisconnected) {
-      throw new Error(`${job.id} prior outcome does not match its guarded execution ledger`);
-    }
-    if (guardedTransactions > 0 && outcome.confirmation?.state !== 'not-submitted') {
-      throw new Error(`${job.id} guarded pre-submit transaction requires not-submitted confirmation state`);
-    }
-    if (guardedTransactions === 0 && !['not-submitted', 'not-applicable'].includes(outcome.confirmation?.state)) {
-      throw new Error(`${job.id} guarded zero-transaction outcome has an invalid confirmation state`);
+    if (outcome) {
+      const guardedTransactions = guard.runActionsCalls > 0 ? 1 : 0;
+      const guardedContinuations = Math.max(0, guard.runActionsCalls - 1);
+      const guardedSessions = guard.connectSucceeded ? 1 : 0;
+      if (outcome.runActionsTransactions !== guardedTransactions
+        || outcome.runActionsContinuations !== guardedContinuations
+        || outcome.sessionsOpened !== guardedSessions
+        || (guardedSessions === 1 && outcome.sessionId !== guard.ownedSessionId)
+        || (guardedSessions === 0 && outcome.sessionId !== null)
+        || outcome.ownSessionDisconnected !== guard.ownedSessionDisconnected) {
+        throw new Error(`${job.id} prior outcome does not match its guarded execution ledger`);
+      }
+      if (guardedTransactions > 0 && outcome.confirmation?.state !== 'not-submitted') {
+        throw new Error(`${job.id} guarded pre-submit transaction requires not-submitted confirmation state`);
+      }
+      if (guardedTransactions === 0 && !['not-submitted', 'not-applicable'].includes(outcome.confirmation?.state)) {
+        throw new Error(`${job.id} guarded zero-transaction outcome has an invalid confirmation state`);
+      }
+    } else {
+      if (!guardProvesNoTransaction) {
+        throw new Error(`${job.id} outcome-less guarded retry requires a zero-transaction attempt`);
+      }
+      outcomeLessRuntimeEvidence = await validateOutcomeLessRetryRuntime({
+        projectDir,
+        runDir,
+        guardPath,
+        eventsPath,
+        guard,
+        priorAttempt,
+        job,
+      });
+      guardTerminalState = 'guarded-zero-transaction';
     }
-    guardTerminalState = guard.runActionsTerminalState;
+    if (outcome) guardTerminalState = guard.runActionsTerminalState;
   } else {
+    if (!outcome) {
+      throw new Error(`${job.id} legacy prior attempt cannot retry without a structured outcome`);
+    }
     if (outcome.sessionsOpened !== 0
       || outcome.sessionId !== null
       || outcome.ownSessionDisconnected !== false
@@ -922,15 +950,95 @@ export async function authorizeSafeRetry({ projectDir, job, priorAttempt, retryO
     priorAttemptId: retryOfAttemptId,
     evidence: {
       runDir: relativeProjectPath(projectDir, runDir),
-      outcome: relativeProjectPath(projectDir, outcomePath),
+      outcome: hasOutcome ? relativeProjectPath(projectDir, outcomePath) : null,
       events: relativeProjectPath(projectDir, eventsPath),
+      guard: hasGuard ? relativeProjectPath(projectDir, guardPath) : null,
+      workerRuntime: outcomeLessRuntimeEvidence
+        ? relativeProjectPath(projectDir, outcomeLessRuntimeEvidence.runtimePath)
+        : null,
+      legacyStartupFailure: outcomeLessRuntimeEvidence?.legacyStartupFailure || false,
+      startupStderr: outcomeLessRuntimeEvidence?.stderrPath
+        ? relativeProjectPath(projectDir, outcomeLessRuntimeEvidence.stderrPath)
+        : null,
       guardTerminalState,
       mutationStarts: mutations,
       opaqueCommandExecutions: opaqueCommandExecutions.size,
     },
   };
 }
 
+async function validateOutcomeLessRetryRuntime({
+  projectDir,
+  runDir,
+  guardPath,
+  eventsPath,
+  guard,
+  priorAttempt,
+  job,
+}) {
+  const runtimePath = join(runDir, 'worker-runtime.json');
+  if (!existsSync(runtimePath)) {
+    throw new Error(`${job.id} outcome-less guarded retry lacks worker runtime evidence`);
+  }
+  const runtime = parseJson(await readFile(runtimePath, 'utf8'), runtimePath);
+  const expectedGuardPath = relativeProjectPath(projectDir, guardPath);
+  const allowedServers = Array.isArray(runtime.allowedMcpServers)
+    ? [...new Set(runtime.allowedMcpServers)].sort()
+    : [];
+  const expectedServers = [...ALLOWED_APPLY_MCP_SERVERS].sort();
+  const guardsMatch = [
+    runtime.packagedPreToolUseGuard,
+    runtime.packagedPostToolUseGuard,
+    runtime.packagedPermissionRequestGuard,
+  ].every((path) => path === expectedGuardPath);
+  if (runtime.permissionProfile !== 'jobforge_apply'
+    || runtime.approvalPolicy !== 'never (Codex exec invariant)'
+    || runtime.approvalsReviewer !== 'user'
+    || runtime.shellToolEnabled !== false
+    || runtime.ignoreUserConfig !== true
+    || runtime.ignoreExecPolicyRules !== true
+    || runtime.hookTrustBypassScopedToPackagedGuard !== true
+    || runtime.alternateBrowserToolsDisabled !== true
+    || runtime.ephemeral !== true
+    || !guardsMatch
+    || allowedServers.length !== expectedServers.length
+    || allowedServers.some((server, index) => server !== expectedServers[index])) {
+    throw new Error(`${job.id} outcome-less guarded retry lacks exact worker confinement evidence`);
+  }
+  if (runtime.ignoreProjectConfig === true) {
+    return { runtimePath, legacyStartupFailure: false, stderrPath: null };
+  }
+  if (runtime.ignoreProjectConfig !== undefined) {
+    throw new Error(`${job.id} outcome-less guarded retry lacks project-config isolation evidence`);
+  }
+
+  const expectedGuard = {
+    ...initialGuardState(guard.authoritativeUrl, guard.projectRoot, {
+      company: guard.authoritativeCompany,
+      role: guard.authoritativeRole,
+      candidateEmailHash: guard.candidateEmailHash,
+      configuredProxyHash: guard.configuredProxyHash,
+      allowedUploadPaths: guard.allowedUploadPaths,
+    }),
+    projectRoot: guard.projectRoot,
+  };
+  const stderrPath = join(runDir, 'stderr.log');
+  const expectedReason = `worker exited ${priorAttempt.workerExitCode}; worker produced no structured outcome`;
+  if (!Number.isInteger(priorAttempt.workerExitCode)
+    || priorAttempt.workerExitCode === 0
+    || priorAttempt.reason !== expectedReason
+    || (await readFile(eventsPath, 'utf8')).trim() !== ''
+    || JSON.stringify(guard) !== JSON.stringify(expectedGuard)
+    || !existsSync(stderrPath)) {
+    throw new Error(`${job.id} legacy outcome-less retry lacks pristine pre-startup failure evidence`);
+  }
+  const stderr = await readFile(stderrPath, 'utf8');
+  if (!/^Error loading config\.toml: invalid transport\r?\nin `mcp_servers\.[^`\r\n]+`\r?\n?$/.test(stderr)) {
+    throw new Error(`${job.id} legacy outcome-less retry is not an exact pre-startup config failure`);
+  }
+  return { runtimePath, legacyStartupFailure: true, stderrPath };
+}
+
 function parseMarkdownRows(text) {
   const rows = [];
   for (const line of text.split('\n')) {