agentxchain 2.155.45 → 2.155.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.155.45",
+  "version": "2.155.47",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/lib/repo-observer.js

@@ -69,6 +69,10 @@ export const BASELINE_EXEMPT_PATH_PREFIXES = Object.freeze([
   '.agentxchain/proposed/',
 ]);
 
+export const DOGFOOD_EVIDENCE_PATH_PREFIXES = Object.freeze([
+  '.planning/dogfood-100-turn-evidence/',
+]);
+
 const GENERATED_REPORT_PATH_PATTERNS = Object.freeze([
   /^\.agentxchain\/reports\/report-[^/]+\.md$/,
   /^\.agentxchain\/reports\/export-[^/]+\.json$/,
@@ -122,7 +126,8 @@ export function classifyRepoPath(filePath) {
     || pathMatchesAnyRoot(filePath, RUN_CONTINUITY_DIRECTORY_ROOTS);
   const baselineExempt = operational
     || continuityState
-    || pathMatchesAnyPrefix(filePath, BASELINE_EXEMPT_PATH_PREFIXES);
+    || pathMatchesAnyPrefix(filePath, BASELINE_EXEMPT_PATH_PREFIXES)
+    || pathMatchesAnyPrefix(filePath, DOGFOOD_EVIDENCE_PATH_PREFIXES);
 
   return {
     operational,
@@ -148,6 +153,10 @@ export function isRunContinuityPath(filePath) {
   return classifyRepoPath(filePath).continuityState;
 }
 
+export function isDogfoodEvidencePath(filePath) {
+  return pathMatchesAnyPrefix(filePath, DOGFOOD_EVIDENCE_PATH_PREFIXES);
+}
+
 export function normalizeCheckpointableFiles(filesChanged) {
   return [...new Set(
     (Array.isArray(filesChanged) ? filesChanged : [])
@@ -249,8 +258,10 @@ export function observeChanges(root, baseline) {
 
   changedFiles = filterBaselineDirtyFiles(root, changedFiles, baseline);
 
-  // Filter out orchestrator-owned operational paths (Session #19 freeze)
-  const actorFiles = changedFiles.filter(f => !isOperationalPath(f));
+  // Filter out orchestrator-owned operational paths (Session #19 freeze) and
+  // DOGFOOD-100 proof evidence, which is operator-proof metadata for this
+  // repository's formal dogfood run rather than turn-authored product work.
+  const actorFiles = changedFiles.filter(f => !isOperationalPath(f) && !isDogfoodEvidencePath(f));
 
   return {
     files_changed: actorFiles.sort(),

package/src/lib/run-loop.js

@@ -36,7 +36,7 @@ import {
 } from './runner-interface.js';
 
 import { runAdmissionControl } from './admission-control.js';
-import { appendFileSync, mkdirSync, writeFileSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { evaluateApprovalSlaReminders } from './notification-runner.js';
 import { validatePreemptionMarker } from './intake.js';
@@ -162,6 +162,26 @@ export async function runLoop(root, config, callbacks, options = {}) {
       }
     }
 
+    const failedAcceptanceResult = await reattemptFailedAcceptanceTurn(root, config, state, callbacks, emit, errors);
+    if (failedAcceptanceResult) {
+      if (failedAcceptanceResult.terminal) {
+        return makeResult(
+          failedAcceptanceResult.ok,
+          failedAcceptanceResult.stop_reason,
+          loadState(root, config),
+          turnsExecuted,
+          turnHistory,
+          gatesApproved,
+          errors,
+        );
+      }
+      if (failedAcceptanceResult.accepted) {
+        turnsExecuted++;
+      }
+      turnHistory.push(...failedAcceptanceResult.history);
+      continue;
+    }
+
     // ── Determine concurrency mode ────────────────────────────────────────
     const maxConcurrent = getMaxConcurrentTurns(config, state.phase);
 
@@ -490,6 +510,43 @@ function isDispatchableActiveTurn(turn) {
   return ['assigned', 'dispatched', 'starting', 'running', 'retrying'].includes(turn?.status);
 }
 
+async function reattemptFailedAcceptanceTurn(root, config, state, callbacks, emit, errors) {
+  const turn = Object.values(getActiveTurns(state)).find(t => t?.status === 'failed_acceptance');
+  if (!turn) return null;
+
+  const roleId = turn.assigned_role;
+  const stagingPath = getTurnStagingResultPath(turn.turn_id);
+  if (!existsSync(join(root, stagingPath))) {
+    errors.push(`failed_acceptance(${roleId}): missing staged result at ${stagingPath}`);
+    return { terminal: true, ok: false, stop_reason: 'blocked', history: [] };
+  }
+
+  const acceptResult = acceptTurn(root, config, { turnId: turn.turn_id });
+  if (!acceptResult.ok) {
+    errors.push(`acceptTurn(${roleId}): ${acceptResult.error}`);
+    return {
+      terminal: true,
+      ok: false,
+      stop_reason: acceptResult.error_code === 'conflict' ? 'conflict_loop' : 'blocked',
+      history: [{ role: roleId, turn_id: turn.turn_id, accepted: false, accept_error: acceptResult.error }],
+    };
+  }
+
+  const history = [{ role: roleId, turn_id: turn.turn_id, accepted: true }];
+  if (callbacks.afterAccept) {
+    const afterAcceptResult = await callbacks.afterAccept({ turn, acceptResult });
+    if (afterAcceptResult?.ok === false) {
+      errors.push(`afterAccept(${roleId}): ${afterAcceptResult.error}`);
+      if (afterAcceptResult.state) {
+        emit({ type: 'blocked', state: afterAcceptResult.state, reason: 'after_accept_failed' });
+      }
+      return { terminal: true, ok: false, stop_reason: 'blocked', history };
+    }
+  }
+  emit({ type: 'turn_accepted', turn, role: roleId, state: acceptResult.state });
+  return { terminal: false, accepted: true, history };
+}
+
 /**
  * Dispatch a single turn and process its result.
  */