agentxchain 2.143.0 → 2.145.0

package/package.json

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

package/scripts/release-bump.sh

@@ -69,6 +69,8 @@ echo "AgentXchain Release Identity: ${TARGET_VERSION}"
 echo "============================================="
 
 TARGET_RELEASE_DOC="website-v2/docs/releases/v${TARGET_VERSION//./-}.mdx"
+CURRENT_VERSION=$(node -e "console.log(JSON.parse(require('fs').readFileSync('package.json','utf8')).version)")
+REENTRY_MODE=0
 ALLOWED_RELEASE_PATHS=(
   "cli/CHANGELOG.md"
   "${TARGET_RELEASE_DOC}"
@@ -79,6 +81,7 @@ ALLOWED_RELEASE_PATHS=(
   ".planning/LAUNCH_EVIDENCE_REPORT.md"
   ".planning/SHOW_HN_DRAFT.md"
   ".planning/MARKETING/TWITTER_THREAD.md"
+  ".planning/MARKETING/LINKEDIN_POST.md"
   ".planning/MARKETING/REDDIT_POSTS.md"
   ".planning/MARKETING/HN_SUBMISSION.md"
   "website-v2/static/llms.txt"
@@ -88,6 +91,10 @@ ALLOWED_RELEASE_PATHS=(
   "cli/homebrew/agentxchain.rb"
   "cli/homebrew/README.md"
 )
+ALLOWED_REENTRY_VERSION_PATHS=(
+  "cli/package.json"
+  "cli/package-lock.json"
+)
 
 is_allowed_release_path() {
   local candidate="$1"
@@ -111,15 +118,32 @@ stage_if_present() {
   fi
 }
 
-# 1. Assert only allowed release-surface dirt is present
-echo "[1/8] Checking release-prep tree state..."
+# 1. Detect version/re-entry state before validating the tree
+echo "[1/10] Checking current version..."
+if [[ "$CURRENT_VERSION" == "$TARGET_VERSION" ]]; then
+  REENTRY_MODE=1
+  echo "  OK: package.json already targets ${TARGET_VERSION}; entering release re-entry mode"
+else
+  echo "  OK: current version is ${CURRENT_VERSION}, bumping to ${TARGET_VERSION}"
+fi
+
+# 2. Assert only allowed release-surface dirt is present
+echo "[2/10] Checking release-prep tree state..."
 DISALLOWED_DIRTY=()
 while IFS= read -r status_line; do
   [[ -z "$status_line" ]] && continue
   path="${status_line#?? }"
-  if ! is_allowed_release_path "$path"; then
-    DISALLOWED_DIRTY+=("$path")
+  if is_allowed_release_path "$path"; then
+    continue
+  fi
+  if [[ "$REENTRY_MODE" -eq 1 ]]; then
+    for allowed in "${ALLOWED_REENTRY_VERSION_PATHS[@]}"; do
+      if [[ "$path" == "$allowed" ]]; then
+        continue 2
+      fi
+    done
   fi
+  DISALLOWED_DIRTY+=("$path")
 done < <(git -C "$REPO_ROOT" status --porcelain)
 
 if [[ "${#DISALLOWED_DIRTY[@]}" -gt 0 ]]; then
@@ -129,17 +153,8 @@ if [[ "${#DISALLOWED_DIRTY[@]}" -gt 0 ]]; then
 fi
 echo "  OK: tree contains only allowed release-prep changes"
 
-# 2. Assert not already at target version
-echo "[2/8] Checking current version..."
-CURRENT_VERSION=$(node -e "console.log(JSON.parse(require('fs').readFileSync('package.json','utf8')).version)")
-if [[ "$CURRENT_VERSION" == "$TARGET_VERSION" ]]; then
-  echo "FAIL: package.json is already at ${TARGET_VERSION}. Cannot double-bump." >&2
-  exit 1
-fi
-echo "  OK: current version is ${CURRENT_VERSION}, bumping to ${TARGET_VERSION}"
-
 # 3. Assert tag does not already exist
-echo "[3/8] Checking for existing tag..."
+echo "[3/10] Checking for existing tag..."
 if git rev-parse "v${TARGET_VERSION}" >/dev/null 2>&1; then
   echo "FAIL: tag v${TARGET_VERSION} already exists. Delete it first or choose a different version." >&2
   exit 1
@@ -235,7 +250,11 @@ fi
 
 # 7. Update version files (no git operations)
 echo "[7/10] Updating version files..."
-npm version "$TARGET_VERSION" --no-git-tag-version
+if [[ "$REENTRY_MODE" -eq 1 ]]; then
+  npm version "$TARGET_VERSION" --no-git-tag-version --allow-same-version
+else
+  npm version "$TARGET_VERSION" --no-git-tag-version
+fi
 echo "  OK: package.json updated to ${TARGET_VERSION}"
 
 # 8. Stage version files
@@ -250,23 +269,58 @@ done
 git -C "$REPO_ROOT" add -- website-v2/docs/releases
 echo "  OK: version files and allowed release surfaces staged"
 
-# 9. Create release commit
-echo "[9/10] Creating release commit..."
-git commit -m "${TARGET_VERSION}
+# 9. Create or reuse release commit
+if git diff --cached --quiet --exit-code; then
+  CURRENT_HEAD_SHA=$(git rev-parse HEAD)
+  echo "[9/10] Resolving re-entry release identity..."
+  COMMIT_MSG=$(git log -1 --format=%s)
+  if [[ "$COMMIT_MSG" == "$TARGET_VERSION" ]]; then
+    COMMIT_BODY=$(git log -1 --format=%B)
+    if [[ "$COMMIT_BODY" != *"Co-Authored-By: ${COAUTHORED_BY}"* ]]; then
+      echo "FAIL: existing HEAD commit for re-entry is missing the required Co-Authored-By trailer" >&2
+      exit 1
+    fi
+    RELEASE_SHA=$(git rev-parse HEAD)
+    echo "  OK: reusing existing release commit ${RELEASE_SHA:0:7}"
+  elif [[ "$REENTRY_MODE" -eq 1 ]]; then
+    echo "  No staged release-surface deltas remain; creating metadata-only release identity commit for ${CURRENT_HEAD_SHA:0:7}"
+    git commit --allow-empty -m "${TARGET_VERSION}
+
+Release-Base: ${CURRENT_HEAD_SHA}
+Co-Authored-By: ${COAUTHORED_BY}"
+    RELEASE_SHA=$(git rev-parse HEAD)
+    COMMIT_BODY=$(git log -1 --format=%B)
+    if [[ "$COMMIT_BODY" != *"Release-Base: ${CURRENT_HEAD_SHA}"* ]]; then
+      echo "FAIL: metadata-only release identity commit is missing the required Release-Base line" >&2
+      exit 1
+    fi
+    if [[ "$COMMIT_BODY" != *"Co-Authored-By: ${COAUTHORED_BY}"* ]]; then
+      echo "FAIL: metadata-only release identity commit is missing the required Co-Authored-By trailer" >&2
+      exit 1
+    fi
+    echo "  OK: metadata-only release identity commit ${RELEASE_SHA:0:7} recorded base ${CURRENT_HEAD_SHA:0:7}"
+  else
+    echo "FAIL: no staged release-identity changes remain, and HEAD is not already the ${TARGET_VERSION} release commit. Found commit message '${COMMIT_MSG}'." >&2
+    exit 1
+  fi
+else
+  echo "[9/10] Creating release commit..."
+  git commit -m "${TARGET_VERSION}
 
 Co-Authored-By: ${COAUTHORED_BY}"
-RELEASE_SHA=$(git rev-parse HEAD)
-COMMIT_MSG=$(git log -1 --format=%s)
-if [[ "$COMMIT_MSG" != "$TARGET_VERSION" ]]; then
-  echo "FAIL: commit message is '${COMMIT_MSG}', expected '${TARGET_VERSION}'" >&2
-  exit 1
-fi
-COMMIT_BODY=$(git log -1 --format=%B)
-if [[ "$COMMIT_BODY" != *"Co-Authored-By: ${COAUTHORED_BY}"* ]]; then
-  echo "FAIL: release commit body is missing the required Co-Authored-By trailer" >&2
-  exit 1
+  RELEASE_SHA=$(git rev-parse HEAD)
+  COMMIT_MSG=$(git log -1 --format=%s)
+  if [[ "$COMMIT_MSG" != "$TARGET_VERSION" ]]; then
+    echo "FAIL: commit message is '${COMMIT_MSG}', expected '${TARGET_VERSION}'" >&2
+    exit 1
+  fi
+  COMMIT_BODY=$(git log -1 --format=%B)
+  if [[ "$COMMIT_BODY" != *"Co-Authored-By: ${COAUTHORED_BY}"* ]]; then
+    echo "FAIL: release commit body is missing the required Co-Authored-By trailer" >&2
+    exit 1
+  fi
+  echo "  OK: commit ${RELEASE_SHA:0:7} with message '${TARGET_VERSION}'"
 fi
-echo "  OK: commit ${RELEASE_SHA:0:7} with message '${TARGET_VERSION}'"
 
 # 9.5. Inline preflight gate — tests, pack, and docs build must pass before tag
 if [[ "$SKIP_PREFLIGHT" -eq 1 ]]; then

package/src/commands/resume.js

@@ -40,6 +40,7 @@ import { deriveRecoveryDescriptor } from '../lib/blocked-state.js';
 import { runHooks } from '../lib/hook-runner.js';
 import { summarizeRunProvenance } from '../lib/run-provenance.js';
 import { consumeNextApprovedIntent } from '../lib/intake.js';
+import { reconcileStaleTurns } from '../lib/stale-turn-watchdog.js';
 
 export async function resumeCommand(opts) {
   const context = loadProjectContext();
@@ -75,6 +76,13 @@ export async function resumeCommand(opts) {
     process.exit(1);
   }
 
+  const staleReconciliation = reconcileStaleTurns(root, state, config);
+  state = staleReconciliation.state || state;
+  if (staleReconciliation.stale_turns.length > 0) {
+    printStaleTurnRecovery(staleReconciliation.stale_turns);
+    process.exit(1);
+  }
+
   // §47: active + turns present → reject (resume assigns new turns, not re-dispatches)
   const activeCount = getActiveTurnCount(state);
   const activeTurns = getActiveTurns(state);
@@ -351,6 +359,19 @@ export async function resumeCommand(opts) {
   printDispatchSummary(state, config);
 }
 
+function printStaleTurnRecovery(staleTurns) {
+  console.log(chalk.red.bold('Stale turn detected.'));
+  console.log('');
+  for (const stale of staleTurns) {
+    const mins = Math.floor(stale.running_ms / 60000);
+    console.log(`  Turn:    ${stale.turn_id} (${stale.role})`);
+    console.log(`  Runtime: ${stale.runtime_id}`);
+    console.log(`  Age:     ${mins}m with no output`);
+    console.log(`  Recover: ${chalk.cyan(`agentxchain reissue-turn --turn ${stale.turn_id} --reason stale`)}`);
+    console.log('');
+  }
+}
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function printResumeRunContext({ root, state, config }) {

package/src/commands/status.js

@@ -21,10 +21,11 @@ import { deriveConflictedTurnResolutionActions } from '../lib/conflict-actions.j
 import { summarizeLatestGateActionAttempt } from '../lib/gate-actions.js';
 import { findCurrentHumanEscalation } from '../lib/human-escalations.js';
 import { getDashboardPid, getDashboardSession } from './dashboard.js';
-import { readPreemptionMarker, findPendingApprovedIntents } from '../lib/intake.js';
+import { readPreemptionMarker, validatePreemptionMarker, findPendingApprovedIntents } from '../lib/intake.js';
 import { readContinuousSession } from '../lib/continuous-run.js';
 import { readAllDispatchProgress } from '../lib/dispatch-progress.js';
 import { readCoordinatorWarnings } from '../lib/coordinator-warnings.js';
+import { reconcileStaleTurns } from '../lib/stale-turn-watchdog.js';
 
 export async function statusCommand(opts) {
   const context = loadStatusContext();
@@ -134,7 +135,7 @@ function loadStatusContext(dir = process.cwd()) {
 
 function renderGovernedStatus(context, opts) {
   const { root, config, version } = context;
-  const state = loadProjectState(root, config);
+  let state = loadProjectState(root, config);
   const stateRunId = state?.run_id || readRawStateRunId(root, config);
   const continuity = getContinuityStatus(root, state);
   const connectorHealth = getConnectorHealth(root, config, state);
@@ -146,7 +147,8 @@ function renderGovernedStatus(context, opts) {
 
   const workflowKitArtifacts = deriveWorkflowKitArtifacts(root, config, state);
   const humanEscalation = findCurrentHumanEscalation(root, state);
-  const preemptionMarker = readPreemptionMarker(root);
+  // BUG-48: validate the marker against live intent state; auto-clear stale markers
+  const preemptionMarker = validatePreemptionMarker(root);
   const pendingIntents = findPendingApprovedIntents(root, { run_id: stateRunId || null });
   const continuousSession = readContinuousSession(root);
   const gateActionAttempt = state?.pending_phase_transition
@@ -164,6 +166,11 @@ function renderGovernedStatus(context, opts) {
   // Coordinator warning surfacing — DEC-COORD-RETRY-PROJECTION-EVENT-001
   const coordinatorWarnings = readCoordinatorWarnings(root, { runId: stateRunId || null });
 
+  // BUG-47: detect stale running turns and emit turn_stalled events
+  const staleReconciliation = reconcileStaleTurns(root, state, config);
+  state = staleReconciliation.state || state;
+  const staleTurns = staleReconciliation.stale_turns;
+
   if (opts.json) {
     const dashPid = getDashboardPid(root);
     const dashSession = getDashboardSession(root);
@@ -201,6 +208,7 @@ function renderGovernedStatus(context, opts) {
       binding_drift: detectActiveTurnBindingDrift(state, config),
       bundle_integrity: detectStateBundleDesync(root, state),
       coordinator_warnings: coordinatorWarnings,
+      stale_turns: staleTurns,
     }, null, 2));
     return;
   }
@@ -445,6 +453,19 @@ function renderGovernedStatus(context, opts) {
     }
   }
 
+  // BUG-47: Stale turn warning
+  if (staleTurns.length > 0) {
+    console.log('');
+    for (const st of staleTurns) {
+      const mins = Math.floor(st.running_ms / 60000);
+      console.log(`  ${chalk.red.bold('⚠ Stale turn detected')}`);
+      console.log(`  ${chalk.dim('Turn:')}     ${st.turn_id} (${st.role})`);
+      console.log(`  ${chalk.dim('Runtime:')}  ${st.runtime_id}`);
+      console.log(`  ${chalk.dim('Running:')}  ${mins}m with no output`);
+      console.log(`  ${chalk.dim('Recover:')}  ${chalk.cyan(`agentxchain reissue-turn --turn ${st.turn_id} --reason stale`)}`);
+    }
+  }
+
   // Queued phase/completion requests
   if (state?.queued_phase_transition) {
     const qt = state.queued_phase_transition;

package/src/commands/step.js

@@ -70,6 +70,7 @@ import { resolveGovernedRole } from '../lib/role-resolution.js';
 import { shouldSuggestManualQaFallback } from '../lib/manual-qa-fallback.js';
 import { evaluateApprovalSlaReminders } from '../lib/notification-runner.js';
 import { consumeNextApprovedIntent } from '../lib/intake.js';
+import { reconcileStaleTurns } from '../lib/stale-turn-watchdog.js';
 
 export async function stepCommand(opts) {
   const context = loadProjectContext();
@@ -94,6 +95,13 @@ export async function stepCommand(opts) {
     process.exit(1);
   }
 
+  const staleReconciliation = reconcileStaleTurns(root, state, config);
+  state = staleReconciliation.state || state;
+  if (staleReconciliation.stale_turns.length > 0) {
+    printStaleTurnRecovery(staleReconciliation.stale_turns);
+    process.exit(1);
+  }
+
   // Completed runs cannot take more turns
   if (state.status === 'completed') {
     console.log(chalk.green.bold('This run is already completed.'));
@@ -901,6 +909,19 @@ export async function stepCommand(opts) {
   }
 }
 
+function printStaleTurnRecovery(staleTurns) {
+  console.log(chalk.red.bold('Stale turn detected.'));
+  console.log('');
+  for (const stale of staleTurns) {
+    const mins = Math.floor(stale.running_ms / 60000);
+    console.log(`  Turn:    ${stale.turn_id} (${stale.role})`);
+    console.log(`  Runtime: ${stale.runtime_id}`);
+    console.log(`  Age:     ${mins}m with no output`);
+    console.log(`  Recover: ${chalk.cyan(`agentxchain reissue-turn --turn ${stale.turn_id} --reason stale`)}`);
+    console.log('');
+  }
+}
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function loadHookStagedTurn(root, stagingRel) {

package/src/lib/governed-state.js

@@ -91,8 +91,28 @@ const INTAKE_INTENTS_DIR = '.agentxchain/intake/intents';
 const STALE_LOCK_TIMEOUT_MS = 30_000;
 const GOVERNED_SCHEMA_VERSION = '1.1';
 
+const PREEMPTION_MARKER_REL = '.agentxchain/intake/injected-priority.json';
+
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
+/**
+ * BUG-48: clear the preemption marker if it references the given intent.
+ * Inlined here to avoid a circular dependency with intake.js.
+ */
+function clearPreemptionMarkerIfMatchesIntent(root, intentId) {
+  if (!intentId) return;
+  const p = join(root, PREEMPTION_MARKER_REL);
+  if (!existsSync(p)) return;
+  try {
+    const marker = JSON.parse(readFileSync(p, 'utf8'));
+    if (marker && marker.intent_id === intentId) {
+      unlinkSync(p);
+    }
+  } catch {
+    // best-effort
+  }
+}
+
 function generateId(prefix) {
   return `${prefix}_${randomBytes(8).toString('hex')}`;
 }
@@ -240,6 +260,8 @@ function retireApprovedPhaseScopedIntents(root, state, config, exitedPhase, now)
       entered_phase: state?.phase || null,
     });
     safeWriteJson(intentPath, intent);
+    // BUG-48: clear preemption marker if it references this now-satisfied intent
+    clearPreemptionMarkerIfMatchesIntent(root, intent.intent_id);
     retired.push(intent.intent_id);
   }
 
@@ -2355,6 +2377,13 @@ export function initializeGovernedRun(root, config, options = {}) {
     repo_decisions: repoDecisions.length > 0 ? repoDecisions : null,
   };
 
+  if ((provenance?.trigger === 'continuation' || provenance?.trigger === 'recovery') && !updatedState.accepted_integration_ref) {
+    const baseline = captureBaseline(root);
+    if (baseline?.head_ref) {
+      updatedState.accepted_integration_ref = `git:${baseline.head_ref}`;
+    }
+  }
+
   writeState(root, updatedState);
 
   const startupIntents = archiveStaleIntentsForRun(root, runId, {

package/src/lib/intake.js

@@ -412,6 +412,7 @@ export function triageIntent(root, intentId, fields) {
     intent.updated_at = now;
     intent.history.push({ from: 'detected', to: 'suppressed', at: now, reason: fields.reason });
     safeWriteJson(intentPath, intent);
+    clearPreemptionMarkerForIntent(root, intentId);
     return { ok: true, intent, exitCode: 0 };
   }
 
@@ -428,6 +429,7 @@ export function triageIntent(root, intentId, fields) {
     intent.updated_at = now;
     intent.history.push({ from: 'triaged', to: 'rejected', at: now, reason: fields.reason });
     safeWriteJson(intentPath, intent);
+    clearPreemptionMarkerForIntent(root, intentId);
     return { ok: true, intent, exitCode: 0 };
   }
 
@@ -839,6 +841,8 @@ export function approveIntent(root, intentId, options = {}) {
     intent.archived_reason = phantomReason;
     intent.history.push({ from: previousStatus, to: 'superseded', at: now, reason: phantomReason, approver });
     safeWriteJson(intentPath, intent);
+    // BUG-48: clear preemption marker if it references this now-superseded intent
+    clearPreemptionMarkerForIntent(root, intentId);
     return { ok: true, intent, superseded: true, exitCode: 0 };
   }
 
@@ -1319,6 +1323,8 @@ export function resolveIntent(root, intentId, opts = {}) {
     mkdirSync(obsDir, { recursive: true });
 
     safeWriteJson(intentPath, intent);
+    // BUG-48: clear preemption marker if it references this now-completed intent
+    clearPreemptionMarkerForIntent(root, intentId);
     return {
       ok: true,
       intent,
@@ -1765,6 +1771,47 @@ export function clearPreemptionMarker(root) {
   }
 }
 
+/**
+ * BUG-48: Clear the preemption marker if it references a specific intent.
+ * Called when an intent transitions to a non-actionable terminal state so the
+ * marker cannot outlive the intent it points at.
+ */
+export function clearPreemptionMarkerForIntent(root, intentId) {
+  if (!intentId) return;
+  const marker = readPreemptionMarker(root);
+  if (marker && marker.intent_id === intentId) {
+    clearPreemptionMarker(root);
+  }
+}
+
+/**
+ * BUG-48: Validate the preemption marker against the live intent state.
+ * If the marker references an intent whose on-disk status is non-actionable
+ * (superseded, satisfied, completed, rejected, suppressed, failed,
+ * archived_migration), auto-clear the marker and return null.
+ * Otherwise return the marker as-is.
+ */
+const PREEMPTION_ACTIONABLE_STATUSES = new Set(['approved', 'planned']);
+
+export function validatePreemptionMarker(root) {
+  const marker = readPreemptionMarker(root);
+  if (!marker?.intent_id) return marker;
+
+  const loaded = readIntent(root, marker.intent_id);
+  if (!loaded.ok) {
+    // intent file missing — stale marker
+    clearPreemptionMarker(root);
+    return null;
+  }
+
+  if (!PREEMPTION_ACTIONABLE_STATUSES.has(loaded.intent?.status)) {
+    clearPreemptionMarker(root);
+    return null;
+  }
+
+  return marker;
+}
+
 export function consumePreemptionMarker(root, options = {}) {
   const marker = readPreemptionMarker(root);
   if (!marker?.intent_id) {

package/src/lib/intent-startup-migration.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { queryAcceptedTurnHistory } from './accepted-turn-history.js';
@@ -6,6 +6,25 @@ import { safeWriteJson } from './safe-write.js';
 import { VALID_GOVERNED_TEMPLATE_IDS, loadGovernedTemplate } from './governed-templates.js';
 
 const DISPATCHABLE_STATUSES = new Set(['planned', 'approved']);
+const PREEMPTION_MARKER_REL = '.agentxchain/intake/injected-priority.json';
+
+/**
+ * BUG-48: clear preemption marker if it references the given intent.
+ * Inlined to avoid circular dependency with intake.js.
+ */
+function clearPreemptionMarkerIfMatchesIntent(root, intentId) {
+  if (!intentId) return;
+  const p = join(root, PREEMPTION_MARKER_REL);
+  if (!existsSync(p)) return;
+  try {
+    const marker = JSON.parse(readFileSync(p, 'utf8'));
+    if (marker && marker.intent_id === intentId) {
+      unlinkSync(p);
+    }
+  } catch {
+    // best-effort
+  }
+}
 
 function nowISO() {
   return new Date().toISOString();
@@ -127,6 +146,7 @@ export function migratePreBug34Intents(root, runId, options = {}) {
       reason: intent.archived_reason,
     });
     safeWriteJson(intentPath, intent);
+    clearPreemptionMarkerIfMatchesIntent(root, intent.intent_id);
     if (intent.intent_id) archivedMigrationIntentIds.push(intent.intent_id);
   }
 
@@ -260,6 +280,8 @@ export function archiveStaleIntentsForRun(root, runId, options = {}) {
         reason: intent.archived_reason,
       });
       safeWriteJson(intentPath, intent);
+      // BUG-48: clear preemption marker if it references this now-superseded intent
+      clearPreemptionMarkerIfMatchesIntent(root, intent.intent_id);
       phantomSuperseded += 1;
       if (intent.intent_id) phantomSupersededIntentIds.push(intent.intent_id);
       continue;

package/src/lib/recent-event-summary.js

@@ -53,6 +53,7 @@ function describeEvent(eventType, entry) {
       return `${prefix}${eventType}${wsIdWarn ? ` ${wsIdWarn}` : ''}${warnRepo ? ` (${warnRepo})` : ''} — reconciliation required`;
     }
     case 'turn_checkpointed':
+    case 'turn_stalled':
       return `${prefix}${eventType}${roleId ? ` [${roleId}]` : ''}`;
     case 'dispatch_progress':
       return `${prefix}${eventType}${roleId ? ` [${roleId}]` : ''}`;

package/src/lib/release-alignment.js

@@ -279,6 +279,12 @@ export const RELEASE_ALIGNMENT_SURFACES = [
     scopes: [RELEASE_ALIGNMENT_SCOPES.PREBUMP, RELEASE_ALIGNMENT_SCOPES.CURRENT],
     check: validateTextIncludesVersionAndEvidence('.planning/MARKETING/TWITTER_THREAD.md', 'twitter thread draft').check,
   },
+  {
+    id: 'linkedin_post',
+    label: 'linkedin release post draft',
+    scopes: [RELEASE_ALIGNMENT_SCOPES.PREBUMP, RELEASE_ALIGNMENT_SCOPES.CURRENT],
+    check: validateTextIncludesVersionAndEvidence('.planning/MARKETING/LINKEDIN_POST.md', 'linkedin release post draft').check,
+  },
   {
     id: 'reddit_posts',
     label: 'reddit posts draft',

package/src/lib/repo-observer.js

@@ -31,6 +31,7 @@ export const OPERATIONAL_PATH_PREFIXES = Object.freeze([
   '.agentxchain/transactions/',
   '.agentxchain/missions/',
   '.agentxchain/multirepo/',
+  '.agentxchain/plugins/',
   '.agentxchain/prompts/',
 ]);
 
@@ -84,18 +85,56 @@ export const RUN_CONTINUITY_DIRECTORY_ROOTS = Object.freeze([
   ...BASELINE_EXEMPT_PATH_PREFIXES.map((prefix) => prefix.replace(/\/$/, '')),
 ]);
 
+function pathMatchesAnyPrefix(filePath, prefixes) {
+  return prefixes.some((prefix) => filePath.startsWith(prefix));
+}
+
+function pathMatchesAnyRoot(filePath, roots) {
+  return roots.some((root) => filePath === root || filePath.startsWith(`${root}/`));
+}
+
+/**
+ * Return the repo-owned vs framework-owned classification flags for a path.
+ *
+ * The categories intentionally overlap:
+ *   - continuity state is always baseline-exempt
+ *   - operational paths are always baseline-exempt
+ *   - some baseline-exempt evidence paths also participate in continuity export
+ *
+ * This overlap is the contract. The framework does NOT use mutually exclusive
+ * buckets for observation, clean-baseline checks, and continuity export.
+ */
+export function classifyRepoPath(filePath) {
+  const operational = pathMatchesAnyPrefix(filePath, OPERATIONAL_PATH_PREFIXES)
+    || ORCHESTRATOR_STATE_FILES.includes(filePath);
+  const continuityState = RUN_CONTINUITY_STATE_FILES.includes(filePath)
+    || pathMatchesAnyRoot(filePath, RUN_CONTINUITY_DIRECTORY_ROOTS);
+  const baselineExempt = operational
+    || continuityState
+    || pathMatchesAnyPrefix(filePath, BASELINE_EXEMPT_PATH_PREFIXES);
+
+  return {
+    operational,
+    baselineExempt,
+    continuityState,
+    projectOwned: !baselineExempt,
+  };
+}
+
 /**
  * Check whether a file path belongs to orchestrator-owned operational state.
  * These paths are excluded from actor-attributed observation.
  */
 export function isOperationalPath(filePath) {
-  return OPERATIONAL_PATH_PREFIXES.some(prefix => filePath.startsWith(prefix))
-    || ORCHESTRATOR_STATE_FILES.includes(filePath);
+  return classifyRepoPath(filePath).operational;
 }
 
 export function isBaselineExemptPath(filePath) {
-  return isOperationalPath(filePath)
-    || BASELINE_EXEMPT_PATH_PREFIXES.some(prefix => filePath.startsWith(prefix));
+  return classifyRepoPath(filePath).baselineExempt;
+}
+
+export function isRunContinuityPath(filePath) {
+  return classifyRepoPath(filePath).continuityState;
 }
 
 export function normalizeCheckpointableFiles(filesChanged) {

package/src/lib/run-events.js

@@ -24,6 +24,7 @@ export const VALID_RUN_EVENTS = [
   'conflict_resolved',
   'acceptance_failed',
   'turn_reissued',
+  'turn_stalled',
   'turn_checkpointed',
   'coordinator_retry',
   'coordinator_retry_projection_warning',

package/src/lib/run-history.js

@@ -42,10 +42,18 @@ export function recordRunHistory(root, state, config, status) {
     const filePath = join(root, RUN_HISTORY_PATH);
     mkdirSync(dirname(filePath), { recursive: true });
 
-    const historyEntries = readJsonlSafe(root, HISTORY_PATH);
+    const allHistoryEntries = readJsonlSafe(root, HISTORY_PATH);
     const ledgerEntries = readJsonlSafe(root, LEDGER_PATH);
 
-    // Extract unique phases and roles from turn history
+    // BUG-50: filter history entries to the current run only.
+    // history.jsonl accumulates across runs; using all entries causes fresh
+    // run records to inherit parent run phases_completed/total_turns.
+    const currentRunId = state?.run_id || null;
+    const historyEntries = currentRunId
+      ? allHistoryEntries.filter(e => e.run_id === currentRunId)
+      : allHistoryEntries;
+
+    // Extract unique phases and roles from THIS run's turn history only
     const phasesCompleted = [...new Set(historyEntries.map(e => e.phase).filter(Boolean))];
     const rolesUsed = [...new Set(historyEntries.map(e => e.role).filter(Boolean))];
 
@@ -84,6 +92,7 @@ export function recordRunHistory(root, state, config, status) {
       connector_used: connectorUsed,
       model_used: modelUsed,
       provenance: normalizeRunProvenance(state?.provenance),
+      parent_context: buildParentContextSummary(state),
       retrospective: buildRunRetrospective({
         state,
         config,
@@ -317,6 +326,18 @@ function buildRecentAcceptedTurnSnapshot(entries) {
     }));
 }
 
+function buildParentContextSummary(state) {
+  const parentRunId = state?.provenance?.parent_run_id || state?.inherited_context?.parent_run_id || null;
+  if (!parentRunId) return null;
+
+  return {
+    parent_run_id: parentRunId,
+    parent_status: state?.inherited_context?.parent_status || null,
+    parent_completed_at: state?.inherited_context?.parent_completed_at || null,
+    inherited_at: state?.inherited_context?.inherited_at || null,
+  };
+}
+
 function buildRunRetrospective({ state, config, status, historyEntries }) {
   const acceptedTurns = historyEntries.filter((entry) => entry && typeof entry === 'object');
   const lastAcceptedTurn = acceptedTurns[acceptedTurns.length - 1] || null;

package/src/lib/run-loop.js

@@ -38,7 +38,7 @@ import { runAdmissionControl } from './admission-control.js';
 import { appendFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { evaluateApprovalSlaReminders } from './notification-runner.js';
-import { readPreemptionMarker } from './intake.js';
+import { validatePreemptionMarker } from './intake.js';
 import { buildTimeoutBlockedReason, evaluateTimeouts } from './timeout-evaluator.js';
 
 const DEFAULT_MAX_TURNS = 50;
@@ -139,7 +139,8 @@ export async function runLoop(root, config, callbacks, options = {}) {
     // interruption).
     const activeTurnCount = getActiveTurnCount(state);
     if (activeTurnCount === 0) {
-      const marker = readPreemptionMarker(root);
+      // BUG-48: validate marker against live intent state before preempting
+      const marker = validatePreemptionMarker(root);
       if (marker && marker.priority === 'p0') {
         emit({ type: 'priority_injected', intent_id: marker.intent_id, priority: marker.priority });
         const result = makeResult(false, 'priority_preempted', state, turnsExecuted, turnHistory, gatesApproved, errors);

package/src/lib/stale-turn-watchdog.js

@@ -0,0 +1,234 @@
+/**
+ * Stale Turn Watchdog — BUG-47
+ *
+ * Lazy idle-threshold detection: if an active turn has status "running"
+ * for >N seconds with no event log activity AND no staged result file,
+ * report it as stalled.
+ *
+ * Fires on CLI invocations (status, resume, step --resume) rather than
+ * requiring a background daemon.
+ *
+ * Default thresholds:
+ *   - local_cli turns: 10 minutes
+ *   - api_proxy turns: 5 minutes
+ *   - Configurable via run_loop.stale_turn_threshold_ms in agentxchain.json
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { safeWriteJson } from './safe-write.js';
+import { emitRunEvent, readRunEvents } from './run-events.js';
+import { getTurnStagingResultPath } from './turn-paths.js';
+import { getDispatchProgressRelativePath } from './dispatch-progress.js';
+
+const DEFAULT_LOCAL_CLI_THRESHOLD_MS = 10 * 60 * 1000; // 10 minutes
+const DEFAULT_API_PROXY_THRESHOLD_MS = 5 * 60 * 1000;  // 5 minutes
+const LEGACY_STAGING_PATH = '.agentxchain/staging/turn-result.json';
+
+/**
+ * Check all active turns for stale "running" status.
+ *
+ * @param {string} root - project root directory
+ * @param {object} state - current governed state
+ * @param {object} config - normalized config
+ * @returns {Array<{ turn_id: string, role: string, runtime_id: string, running_ms: number, threshold_ms: number, recommendation: string }>}
+ */
+export function detectStaleTurns(root, state, config) {
+  const activeTurns = state?.active_turns || {};
+  const stale = [];
+  const now = Date.now();
+
+  for (const [turnId, turn] of Object.entries(activeTurns)) {
+    if (turn.status !== 'running' && turn.status !== 'retrying') continue;
+    if (!turn.started_at) continue;
+
+    const startedAt = new Date(turn.started_at).getTime();
+    if (isNaN(startedAt)) continue;
+
+    const runningMs = now - startedAt;
+    const threshold = resolveThreshold(turn, config);
+
+    if (runningMs < threshold) continue;
+
+    if (hasTurnScopedStagedResult(root, turnId)) continue;
+
+    const progressPath = join(root, getDispatchProgressRelativePath(turnId));
+    if (existsSync(progressPath)) {
+      try {
+        const progress = JSON.parse(readFileSync(progressPath, 'utf8'));
+        const lastActivity = progress.last_activity_at
+          ? new Date(progress.last_activity_at).getTime()
+          : 0;
+        // If there was activity within the threshold, not stale
+        if (lastActivity > 0 && (now - lastActivity) < threshold) continue;
+      } catch {
+        // ignore parse errors
+      }
+    }
+
+    if (hasRecentTurnEventActivity(root, turnId, startedAt, threshold, now)) continue;
+
+    const runningMinutes = Math.floor(runningMs / 60000);
+    stale.push({
+      turn_id: turnId,
+      role: turn.assigned_role || 'unknown',
+      runtime_id: turn.runtime_id || 'unknown',
+      running_ms: runningMs,
+      threshold_ms: threshold,
+      recommendation: `Turn ${turnId} has been running for ${runningMinutes}m with no output. `
+        + `Run \`agentxchain reissue-turn --turn ${turnId} --reason stale\` to recover.`,
+    });
+  }
+
+  return stale;
+}
+
+/**
+ * Detect stale turns and emit turn_stalled events for each.
+ * Returns the stale turn list for caller display.
+ */
+export function detectAndEmitStaleTurns(root, state, config) {
+  return reconcileStaleTurns(root, state, config).stale_turns;
+}
+
+// ── Internal ────────────────────────────────────────────────────────────────
+
+export function reconcileStaleTurns(root, state, config) {
+  if (!state || typeof state !== 'object') {
+    return { stale_turns: [], state, changed: false };
+  }
+
+  const stale = detectStaleTurns(root, state, config);
+  if (stale.length === 0) {
+    return { stale_turns: [], state, changed: false };
+  }
+
+  const nowIso = new Date().toISOString();
+  const activeTurns = { ...(state.active_turns || {}) };
+  let changed = false;
+
+  for (const entry of stale) {
+    const turn = activeTurns[entry.turn_id];
+    if (!turn || (turn.status !== 'running' && turn.status !== 'retrying')) continue;
+
+    activeTurns[entry.turn_id] = {
+      ...turn,
+      status: 'stalled',
+      stalled_at: nowIso,
+      stalled_reason: 'no_output_within_threshold',
+      stalled_previous_status: turn.status,
+      stalled_threshold_ms: entry.threshold_ms,
+      stalled_running_ms: entry.running_ms,
+      recovery_command: `agentxchain reissue-turn --turn ${entry.turn_id} --reason stale`,
+    };
+    changed = true;
+
+    emitRunEvent(root, 'turn_stalled', {
+      run_id: state?.run_id || null,
+      phase: state?.phase || null,
+      status: 'blocked',
+      turn: { turn_id: entry.turn_id, role_id: entry.role },
+      payload: {
+        running_ms: entry.running_ms,
+        threshold_ms: entry.threshold_ms,
+        runtime_id: entry.runtime_id,
+        recommendation: entry.recommendation,
+      },
+    });
+  }
+
+  if (!changed) {
+    return { stale_turns: stale, state, changed: false };
+  }
+
+  const primary = stale[0];
+  const nextState = {
+    ...state,
+    status: 'blocked',
+    active_turns: activeTurns,
+    blocked_on: stale.length === 1 ? `turn:stalled:${primary.turn_id}` : 'turns:stalled',
+    blocked_reason: {
+      category: 'stale_turn',
+      blocked_at: nowIso,
+      turn_id: primary.turn_id,
+      recovery: {
+        typed_reason: 'stale_turn',
+        owner: 'human',
+        recovery_action: primary.recommendation,
+        turn_retained: true,
+        detail: primary.recommendation,
+      },
+    },
+  };
+
+  safeWriteJson(join(root, '.agentxchain', 'state.json'), nextState);
+  emitRunEvent(root, 'run_blocked', {
+    run_id: nextState.run_id || null,
+    phase: nextState.phase || null,
+    status: 'blocked',
+    turn: { turn_id: primary.turn_id, role_id: primary.role },
+    payload: {
+      category: 'stale_turn',
+      stalled_turn_ids: stale.map((entry) => entry.turn_id),
+    },
+  });
+  return { stale_turns: stale, state: nextState, changed: true };
+}
+
+function resolveThreshold(turn, config) {
+  // Config override takes precedence
+  const configThreshold = config?.run_loop?.stale_turn_threshold_ms;
+  if (typeof configThreshold === 'number' && configThreshold > 0) {
+    return configThreshold;
+  }
+
+  // Runtime-type-based defaults
+  const runtimeId = turn.runtime_id || '';
+  const runtimeConfig = config?.runtimes?.[runtimeId];
+  const runtimeType = runtimeConfig?.type || '';
+
+  if (runtimeType === 'api_proxy') {
+    return DEFAULT_API_PROXY_THRESHOLD_MS;
+  }
+
+  return DEFAULT_LOCAL_CLI_THRESHOLD_MS;
+}
+
+function hasRecentTurnEventActivity(root, turnId, startedAt, threshold, now) {
+  try {
+    const events = readRunEvents(root, { limit: 200 });
+    for (let i = events.length - 1; i >= 0; i--) {
+      const event = events[i];
+      if (event?.turn?.turn_id !== turnId) continue;
+      if (event.event_type === 'turn_stalled') continue;
+      const timestamp = Date.parse(event.timestamp || '');
+      if (!Number.isFinite(timestamp)) continue;
+      if (timestamp < startedAt) continue;
+      if ((now - timestamp) < threshold) {
+        return true;
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+function hasTurnScopedStagedResult(root, turnId) {
+  const turnScopedPath = join(root, getTurnStagingResultPath(turnId));
+  if (existsSync(turnScopedPath)) {
+    return true;
+  }
+
+  const legacyPath = join(root, LEGACY_STAGING_PATH);
+  if (!existsSync(legacyPath)) {
+    return false;
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(legacyPath, 'utf8'));
+    return parsed?.turn_id === turnId;
+  } catch {
+    return false;
+  }
+}

package/src/lib/turn-checkpoint.js

@@ -1,10 +1,10 @@
 import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { resolveAcceptedTurnHistoryReference } from './accepted-turn-history.js';
+import { queryAcceptedTurnHistory, resolveAcceptedTurnHistoryReference } from './accepted-turn-history.js';
 import { emitRunEvent } from './run-events.js';
 import { safeWriteJson } from './safe-write.js';
-import { normalizeCheckpointableFiles } from './repo-observer.js';
+import { checkCleanBaseline, normalizeCheckpointableFiles } from './repo-observer.js';
 
 const STATE_PATH = '.agentxchain/state.json';
 const HISTORY_PATH = '.agentxchain/history.jsonl';
@@ -57,6 +57,68 @@ function normalizeFilesChanged(filesChanged) {
   return normalizeCheckpointableFiles(filesChanged);
 }
 
+function supportsLegacyFilesChangedRecovery(entry) {
+  const artifactType = entry?.artifact?.type;
+  return artifactType === 'workspace' || artifactType === 'patch';
+}
+
+function getActorDirtyFiles(root, dirtyFiles = null) {
+  if (Array.isArray(dirtyFiles)) {
+    return normalizeFilesChanged(dirtyFiles);
+  }
+  const cleanCheck = checkCleanBaseline(root, 'authoritative');
+  return cleanCheck.clean ? [] : normalizeFilesChanged(cleanCheck.dirty_files);
+}
+
+function recoverLegacyCheckpointFiles(root, entry, opts = {}) {
+  if (!supportsLegacyFilesChangedRecovery(entry) || entry?.checkpoint_sha) {
+    return [];
+  }
+
+  const state = readState(root);
+  if (state && Object.keys(state.active_turns || {}).length > 0) {
+    return [];
+  }
+
+  const acceptedHistory = queryAcceptedTurnHistory(root);
+  if (acceptedHistory[0]?.turn_id !== entry?.turn_id) {
+    return [];
+  }
+
+  return getActorDirtyFiles(root, opts.dirtyFiles);
+}
+
+function persistRecoveredFilesChanged(root, turnId, recoveredFiles) {
+  const normalizedRecoveredFiles = normalizeFilesChanged(recoveredFiles);
+  if (normalizedRecoveredFiles.length === 0) return;
+
+  const recoveredAt = new Date().toISOString();
+  const nextEntries = readHistoryEntries(root).map((historyEntry) => {
+    if (historyEntry.turn_id !== turnId) {
+      return historyEntry;
+    }
+
+    const observedArtifact = historyEntry?.observed_artifact && typeof historyEntry.observed_artifact === 'object'
+      ? historyEntry.observed_artifact
+      : null;
+
+    return {
+      ...historyEntry,
+      files_changed: normalizedRecoveredFiles,
+      files_changed_recovered_at: recoveredAt,
+      files_changed_recovery_source: 'legacy_dirty_worktree',
+      observed_artifact: observedArtifact
+        ? {
+            ...observedArtifact,
+            files_changed: normalizedRecoveredFiles,
+          }
+        : observedArtifact,
+    };
+  });
+
+  writeHistoryEntries(root, nextEntries);
+}
+
 function extractGitError(err) {
   const stderr = typeof err?.stderr === 'string' ? err.stderr.trim() : '';
   const stdout = typeof err?.stdout === 'string' ? err.stdout.trim() : '';
@@ -88,15 +150,22 @@ export function detectPendingCheckpoint(root, dirtyFiles = []) {
   if (entry.checkpoint_sha) return { required: false };
 
   const turnFiles = normalizeFilesChanged(entry.files_changed);
-  if (turnFiles.length === 0) return { required: false };
+  const recoveredFiles = turnFiles.length === 0
+    ? recoverLegacyCheckpointFiles(root, entry, { dirtyFiles: actorDirtyFiles })
+    : [];
+  const effectiveTurnFiles = turnFiles.length > 0 ? turnFiles : recoveredFiles;
+  if (effectiveTurnFiles.length === 0) return { required: false };
 
-  const dirtyOutsideTurn = actorDirtyFiles.filter((file) => !turnFiles.includes(file));
+  const dirtyOutsideTurn = actorDirtyFiles.filter((file) => !effectiveTurnFiles.includes(file));
   if (dirtyOutsideTurn.length > 0) return { required: false };
 
   return {
     required: true,
     turn_id: entry.turn_id,
-    message: `Accepted turn ${entry.turn_id} is not checkpointed yet. Run agentxchain checkpoint-turn --turn ${entry.turn_id} before assigning the next code-writing turn.`,
+    recovered_files_changed: recoveredFiles.length > 0 ? recoveredFiles : undefined,
+    message: recoveredFiles.length > 0
+      ? `Accepted turn ${entry.turn_id} has legacy-empty files_changed history but still owns ${recoveredFiles.length} dirty actor file(s). Run agentxchain checkpoint-turn --turn ${entry.turn_id} to recover and checkpoint them.`
+      : `Accepted turn ${entry.turn_id} is not checkpointed yet. Run agentxchain checkpoint-turn --turn ${entry.turn_id} before assigning the next code-writing turn.`,
   };
 }
 
@@ -120,7 +189,17 @@ export function checkpointAcceptedTurn(root, opts = {}) {
     };
   }
 
-  const filesChanged = normalizeFilesChanged(entry.files_changed);
+  const declaredFilesChanged = normalizeFilesChanged(entry.files_changed);
+  const recoveredFilesChanged = declaredFilesChanged.length === 0
+    ? recoverLegacyCheckpointFiles(root, entry)
+    : [];
+  const filesChanged = declaredFilesChanged.length > 0
+    ? declaredFilesChanged
+    : recoveredFilesChanged;
+  if (recoveredFilesChanged.length > 0) {
+    persistRecoveredFilesChanged(root, entry.turn_id, recoveredFilesChanged);
+  }
+
   if (filesChanged.length === 0) {
     return {
       ok: true,
@@ -188,6 +267,10 @@ export function checkpointAcceptedTurn(root, opts = {}) {
   if (state) {
     writeState(root, {
       ...state,
+      // BUG-49: advance accepted_integration_ref to the new checkpoint SHA
+      // so drift detection compares against the current checkpoint, not a
+      // stale ref from the parent run or the pre-checkpoint state.
+      accepted_integration_ref: `git:${checkpointSha}`,
       last_completed_turn: {
         turn_id: entry.turn_id,
         role: entry.role || null,