agentxchain 2.127.0 → 2.129.0

package/src/lib/intake.js

@@ -27,6 +27,8 @@ const INTENT_ID_RE = /^intent_\d+_[0-9a-f]{4}$/;
 // intent files, but current first-party intake writers do not transition into it.
 const S1_STATES = new Set(['detected', 'triaged', 'approved', 'planned', 'executing', 'blocked', 'completed', 'failed', 'suppressed', 'rejected']);
 const TERMINAL_STATES = new Set(['suppressed', 'rejected', 'completed', 'failed']);
+const DISPATCHABLE_STATUSES = new Set(['planned', 'approved']);
+const PRIORITY_RANK = { p0: 0, p1: 1, p2: 2, p3: 3 };
 
 const VALID_TRANSITIONS = {
   detected: ['triaged', 'suppressed'],
@@ -502,6 +504,196 @@ export function intakeStatus(root, intentId) {
   return { ok: true, summary, exitCode: 0 };
 }
 
+export function findNextDispatchableIntent(root) {
+  const dirs = intakeDirs(root);
+  if (!existsSync(dirs.intents)) {
+    return { ok: false, error: 'no intents directory' };
+  }
+
+  const intents = readJsonDir(dirs.intents)
+    .filter((intent) => intent && DISPATCHABLE_STATUSES.has(intent.status));
+
+  if (intents.length === 0) {
+    return { ok: false, error: 'no dispatchable intents' };
+  }
+
+  const approved = intents.filter((intent) => intent.status === 'approved');
+  const candidates = approved.length > 0 ? approved : intents;
+
+  candidates.sort((a, b) => {
+    const aPriority = PRIORITY_RANK[a.priority] ?? Number.MAX_SAFE_INTEGER;
+    const bPriority = PRIORITY_RANK[b.priority] ?? Number.MAX_SAFE_INTEGER;
+    if (aPriority !== bPriority) return aPriority - bPriority;
+
+    const aTime = Date.parse(a.approved_at || a.planned_at || a.created_at || a.updated_at || 0);
+    const bTime = Date.parse(b.approved_at || b.planned_at || b.created_at || b.updated_at || 0);
+    if (Number.isFinite(aTime) && Number.isFinite(bTime) && aTime !== bTime) {
+      return aTime - bTime;
+    }
+
+    return String(a.intent_id || '').localeCompare(String(b.intent_id || ''));
+  });
+
+  const intent = candidates[0];
+  return {
+    ok: true,
+    intentId: intent.intent_id,
+    status: intent.status,
+    priority: intent.priority || null,
+    charter: intent.charter || null,
+    acceptance_count: Array.isArray(intent.acceptance_contract) ? intent.acceptance_contract.length : 0,
+    intent,
+  };
+}
+
+/**
+ * Return all approved-but-unconsumed intents sorted by priority (BUG-15).
+ * Used by `status` to surface the pending intent queue.
+ */
+export function findPendingApprovedIntents(root) {
+  const dirs = intakeDirs(root);
+  if (!existsSync(dirs.intents)) return [];
+
+  return readJsonDir(dirs.intents)
+    .filter((intent) => intent && intent.status === 'approved')
+    .sort((a, b) => {
+      const aPriority = PRIORITY_RANK[a.priority] ?? Number.MAX_SAFE_INTEGER;
+      const bPriority = PRIORITY_RANK[b.priority] ?? Number.MAX_SAFE_INTEGER;
+      if (aPriority !== bPriority) return aPriority - bPriority;
+      const aTime = Date.parse(a.approved_at || a.created_at || 0);
+      const bTime = Date.parse(b.approved_at || b.created_at || 0);
+      if (Number.isFinite(aTime) && Number.isFinite(bTime) && aTime !== bTime) return aTime - bTime;
+      return String(a.intent_id || '').localeCompare(String(b.intent_id || ''));
+    })
+    .map((intent) => ({
+      intent_id: intent.intent_id,
+      priority: intent.priority || 'p0',
+      charter: intent.charter || intent.description || null,
+      acceptance_count: Array.isArray(intent.acceptance_contract) ? intent.acceptance_contract.length : 0,
+      approved_at: intent.approved_at || null,
+    }));
+}
+
+/**
+ * Unified intent consumption entry point (BUG-16).
+ * Both manual (resume/step --resume) and continuous/scheduler paths should call
+ * this single function to consume the next approved intent.
+ *
+ * @param {string} root
+ * @param {{ role?: string, writeDispatchBundle?: boolean, allowTerminalRestart?: boolean, provenance?: object }} options
+ * @returns {{ ok: boolean, intentId?: string, intent?: object, error?: string }}
+ */
+export function consumeNextApprovedIntent(root, options = {}) {
+  const queued = findNextDispatchableIntent(root);
+  if (!queued.ok) {
+    return { ok: false, error: queued.error || 'no dispatchable intents' };
+  }
+
+  const prepared = prepareIntentForDispatch(root, queued.intentId, {
+    role: options.role,
+    writeDispatchBundle: options.writeDispatchBundle ?? false,
+    allowTerminalRestart: options.allowTerminalRestart ?? false,
+    provenance: options.provenance,
+  });
+
+  if (!prepared.ok) {
+    return { ok: false, error: prepared.error, intentId: queued.intentId };
+  }
+
+  return {
+    ok: true,
+    intentId: queued.intentId,
+    status: queued.status,
+    priority: queued.priority,
+    charter: queued.charter,
+    intent: prepared.intent,
+    run_id: prepared.run_id,
+    turn_id: prepared.turn_id,
+    role: prepared.role,
+  };
+}
+
+export function prepareIntentForDispatch(root, intentId, options = {}) {
+  const loadedIntent = readIntent(root, intentId);
+  if (!loadedIntent.ok) {
+    return loadedIntent;
+  }
+
+  const startingStatus = loadedIntent.intent.status;
+  let intent = loadedIntent.intent;
+  let planned = false;
+
+  if (intent.status === 'approved') {
+    const plannedResult = planIntent(root, intent.intent_id, {
+      projectName: options.projectName,
+      force: options.forcePlan === true,
+    });
+    if (!plannedResult.ok) {
+      return {
+        ok: false,
+        error: `plan failed: ${plannedResult.error}`,
+        intent_status: intent.status,
+        exitCode: plannedResult.exitCode || 1,
+      };
+    }
+    intent = plannedResult.intent;
+    planned = true;
+  }
+
+  if (intent.status === 'planned') {
+    const startResult = startIntent(root, intent.intent_id, {
+      allowTerminalRestart: options.allowTerminalRestart === true,
+      provenance: options.provenance,
+      role: options.role || undefined,
+      writeDispatchBundle: options.writeDispatchBundle,
+    });
+    if (!startResult.ok) {
+      return {
+        ok: false,
+        error: `start failed: ${startResult.error}`,
+        intent_status: intent.status,
+        exitCode: startResult.exitCode || 1,
+      };
+    }
+    return {
+      ok: true,
+      intent_id: intent.intent_id,
+      starting_status: startingStatus,
+      final_status: startResult.intent.status,
+      planned,
+      started: true,
+      run_id: startResult.run_id,
+      turn_id: startResult.turn_id,
+      role: startResult.role,
+      intent: startResult.intent,
+      exitCode: 0,
+    };
+  }
+
+  if (intent.status === 'executing') {
+    return {
+      ok: true,
+      intent_id: intent.intent_id,
+      starting_status: startingStatus,
+      final_status: intent.status,
+      planned,
+      started: false,
+      run_id: intent.target_run || null,
+      turn_id: intent.target_turn || null,
+      role: options.role || null,
+      intent,
+      exitCode: 0,
+    };
+  }
+
+  return {
+    ok: false,
+    error: `intent ${intentId} is in unsupported status "${intent.status}" for dispatch preparation`,
+    intent_status: intent.status,
+    exitCode: 1,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Approve
 // ---------------------------------------------------------------------------
@@ -750,7 +942,9 @@ export function startIntent(root, intentId, options = {}) {
   }
 
   // Assign governed turn
-  const assignResult = assignGovernedTurn(root, config, roleId.role);
+  const assignResult = assignGovernedTurn(root, config, roleId.role, {
+    intakeContext,
+  });
   if (!assignResult.ok) {
     return { ok: false, error: `turn assignment failed: ${assignResult.error}`, exitCode: 1 };
   }
@@ -763,24 +957,18 @@ export function startIntent(root, intentId, options = {}) {
     return { ok: false, error: 'turn assignment succeeded but turn not found in state', exitCode: 1 };
   }
 
-  assignedTurn.intake_context = intakeContext;
-  if (state.active_turns?.[assignedTurn.turn_id]) {
-    state.active_turns[assignedTurn.turn_id].intake_context = intakeContext;
-    safeWriteJson(statePath, state);
-  }
+  if (options.writeDispatchBundle !== false) {
+    const bundleResult = writeDispatchBundle(root, state, config);
+    if (!bundleResult.ok) {
+      return { ok: false, error: `dispatch bundle failed: ${bundleResult.error}`, exitCode: 1 };
+    }
 
-  // Write dispatch bundle
-  const bundleResult = writeDispatchBundle(root, state, config);
-  if (!bundleResult.ok) {
-    return { ok: false, error: `dispatch bundle failed: ${bundleResult.error}`, exitCode: 1 };
+    finalizeDispatchManifest(root, assignedTurn.turn_id, {
+      run_id: state.run_id,
+      role: assignedTurn.assigned_role,
+    });
   }
 
-  // Finalize dispatch manifest
-  finalizeDispatchManifest(root, assignedTurn.turn_id, {
-    run_id: state.run_id,
-    role: assignedTurn.assigned_role,
-  });
-
   // Update intent: planned → executing
   const now = nowISO();
   intent.status = 'executing';
@@ -1426,83 +1614,39 @@ export function consumePreemptionMarker(root, options = {}) {
     };
   }
 
-  const startingStatus = loadedIntent.intent.status;
-  let intent = loadedIntent.intent;
-  let planned = false;
-  let started = false;
-
-  if (intent.status === 'approved') {
-    const plannedResult = planIntent(root, intent.intent_id, {
-      projectName: options.projectName,
-      force: options.forcePlan === true,
-    });
-    if (!plannedResult.ok) {
-      return {
-        ok: false,
-        error: `failed to plan injected intent ${intent.intent_id}: ${plannedResult.error}`,
-        marker,
-        intent_status: intent.status,
-        exitCode: plannedResult.exitCode || 1,
-      };
-    }
-    intent = plannedResult.intent;
-    planned = true;
-  }
-
-  if (intent.status === 'planned') {
-    const startResult = startIntent(root, intent.intent_id, {
-      role: options.role || undefined,
-    });
-    if (!startResult.ok) {
-      return {
-        ok: false,
-        error: `failed to start injected intent ${intent.intent_id}: ${startResult.error}`,
-        marker,
-        intent_status: intent.status,
-        exitCode: startResult.exitCode || 1,
-      };
-    }
-    clearPreemptionMarker(root);
+  const prepared = prepareIntentForDispatch(root, marker.intent_id, options);
+  if (!prepared.ok) {
     return {
-      ok: true,
+      ...prepared,
+      error: `failed to prepare injected intent ${marker.intent_id}: ${prepared.error}`,
       marker,
-      intent_id: intent.intent_id,
-      starting_status: startingStatus,
-      final_status: startResult.intent.status,
-      planned,
-      started: true,
-      run_id: startResult.run_id,
-      turn_id: startResult.turn_id,
-      role: startResult.role,
-      intent: startResult.intent,
-      exitCode: 0,
     };
   }
 
-  if (intent.status === 'executing') {
+  if (prepared.final_status === 'executing') {
     clearPreemptionMarker(root);
     return {
       ok: true,
       marker,
-      intent_id: intent.intent_id,
-      starting_status: startingStatus,
-      final_status: intent.status,
-      planned,
-      started: false,
-      run_id: intent.target_run || null,
-      turn_id: intent.target_turn || null,
-      role: options.role || null,
-      intent,
+      intent_id: prepared.intent_id,
+      starting_status: prepared.starting_status,
+      final_status: prepared.final_status,
+      planned: prepared.planned,
+      started: prepared.started,
+      run_id: prepared.run_id,
+      turn_id: prepared.turn_id,
+      role: prepared.role,
+      intent: prepared.intent,
       exitCode: 0,
     };
   }
 
   return {
     ok: false,
-    error: `cannot consume preemption marker from intent status "${intent.status}"`,
+    error: `cannot consume preemption marker from intent status "${prepared.final_status}"`,
     marker,
-    intent_id: intent.intent_id,
-    intent_status: intent.status,
+    intent_id: prepared.intent_id,
+    intent_status: prepared.final_status,
     exitCode: 1,
   };
 }

package/src/lib/missions.js

@@ -3,6 +3,7 @@ import { join } from 'path';
 import { loadAllChainReports, loadChainReport, loadLatestChainReport } from './chain-reports.js';
 import { buildPlanProgressSummary, loadLatestPlan } from './mission-plans.js';
 import { getActiveRepoDecisions } from './repo-decisions.js';
+import { getCoordinatorStatus } from './coordinator-state.js';
 
 const MISSION_ATTENTION_TERMINALS = new Set(['operator_abort', 'parent_validation_failed']);
 const MISSION_ATTENTION_RUN_STATUSES = new Set(['blocked', 'failed']);
@@ -143,9 +144,21 @@ export function buildMissionSnapshot(root, missionArtifact) {
   const latestPlan = loadLatestPlan(root, missionArtifact.mission_id);
   const activeRepoDecisions = getActiveRepoDecisions(root);
 
+  // Load coordinator status if mission is bound to a multi-repo coordinator
+  let coordinatorStatus = null;
+  if (missionArtifact.coordinator && missionArtifact.coordinator.super_run_id) {
+    const workspacePath = missionArtifact.coordinator.workspace_path || root;
+    try {
+      const cs = getCoordinatorStatus(workspacePath);
+      coordinatorStatus = cs || { unreachable: true, super_run_id: missionArtifact.coordinator.super_run_id };
+    } catch {
+      coordinatorStatus = { unreachable: true, super_run_id: missionArtifact.coordinator.super_run_id };
+    }
+  }
+
   return {
     ...missionArtifact,
-    derived_status: deriveMissionStatus(missionArtifact, chains, missingChainIds),
+    derived_status: deriveMissionStatus(missionArtifact, chains, missingChainIds, coordinatorStatus),
     chain_count: chainIds.length,
     attached_chain_count: chains.length,
     missing_chain_ids: missingChainIds,
@@ -155,6 +168,7 @@ export function buildMissionSnapshot(root, missionArtifact) {
     latest_terminal_reason: latestChain?.terminal_reason || null,
     latest_plan: buildPlanProgressSummary(latestPlan),
     active_repo_decisions_count: activeRepoDecisions.length,
+    coordinator_status: coordinatorStatus,
     chains,
   };
 }
@@ -163,19 +177,24 @@ export function loadAllMissionSnapshots(root) {
   return loadAllMissionArtifacts(root).map((mission) => buildMissionSnapshot(root, mission));
 }
 
-function deriveMissionStatus(missionArtifact, chains, missingChainIds) {
+function deriveMissionStatus(missionArtifact, chains, missingChainIds, coordinatorStatus) {
   if (missionArtifact.status && missionArtifact.status !== 'active') {
     return missionArtifact.status;
   }
+  // Coordinator-bound missions: check coordinator health
+  if (coordinatorStatus && !coordinatorStatus.unreachable && coordinatorStatus.status === 'blocked') {
+    return 'needs_attention';
+  }
   if (missingChainIds.length > 0) return 'degraded';
-  if (chains.length === 0) return 'planned';
+  if (chains.length === 0 && !coordinatorStatus) return 'planned';
   if (chains.some((chain) => (
     MISSION_ATTENTION_TERMINALS.has(chain.terminal_reason)
     || (chain.runs || []).some((run) => MISSION_ATTENTION_RUN_STATUSES.has(run.status))
   ))) {
     return 'needs_attention';
   }
-  return 'progressing';
+  if (coordinatorStatus && !coordinatorStatus.unreachable) return 'progressing';
+  return chains.length > 0 ? 'progressing' : 'planned';
 }
 
 export function loadLatestMissionSnapshot(root) {
@@ -196,3 +215,36 @@ export function loadMissionAttachmentTarget(root, missionId) {
   if (missionId) return loadMissionArtifact(root, missionId);
   return loadLatestMissionArtifact(root);
 }
+
+/**
+ * Bind a coordinator super_run_id to a mission artifact.
+ *
+ * @param {string} root - project root
+ * @param {string} missionId - mission to bind
+ * @param {{ super_run_id: string, config_path: string, workspace_path?: string }} coordinatorRef
+ * @returns {{ ok: boolean, mission?: object, error?: string }}
+ */
+export function bindCoordinatorToMission(root, missionId, coordinatorRef) {
+  const mission = loadMissionArtifact(root, missionId);
+  if (!mission) {
+    return { ok: false, error: `Mission not found: ${missionId}` };
+  }
+
+  if (!coordinatorRef || typeof coordinatorRef.super_run_id !== 'string') {
+    return { ok: false, error: 'coordinator super_run_id is required' };
+  }
+
+  const updated = {
+    ...mission,
+    coordinator: {
+      super_run_id: coordinatorRef.super_run_id,
+      config_path: coordinatorRef.config_path || null,
+      workspace_path: coordinatorRef.workspace_path || '.',
+    },
+    updated_at: new Date().toISOString(),
+  };
+
+  mkdirSync(getMissionsDir(root), { recursive: true });
+  writeFileSync(join(getMissionsDir(root), `${updated.mission_id}.json`), JSON.stringify(updated, null, 2));
+  return { ok: true, mission: updated };
+}

package/src/lib/normalized-config.js

@@ -330,6 +330,53 @@ export function detectConfigVersion(raw) {
   return null;
 }
 
+function formatInvalidReviewOnlyLocalCliBindingError(roleId, runtimeId) {
+  return `Role "${roleId}" uses invalid review_only + local_cli binding on runtime "${runtimeId}" — change write_authority to "authoritative" for local CLI automation, or move the role to "manual", "api_proxy", "mcp", or "remote_agent"`;
+}
+
+function formatInvalidAuthoritativeBindingError(roleId, runtimeId, runtimeType, writeAuthority) {
+  return `Role "${roleId}" has write_authority "${writeAuthority}" but uses ${runtimeType} runtime "${runtimeId}" — ${runtimeType} only supports review_only and proposed roles`;
+}
+
+export function findAuthorityRuntimeBindingIssues(data) {
+  const issues = [];
+
+  if (!data?.roles || !data?.runtimes) {
+    return issues;
+  }
+
+  for (const [roleId, role] of Object.entries(data.roles)) {
+    if (!role?.runtime || !data.runtimes[role.runtime]) {
+      continue;
+    }
+
+    const runtime = data.runtimes[role.runtime];
+    const contract = getRoleRuntimeCapabilityContract(roleId, role, runtime);
+
+    if (contract.effective_write_path === 'invalid_review_only_binding') {
+      issues.push({
+        role_id: roleId,
+        runtime_id: role.runtime,
+        runtime_type: runtime.type,
+        write_authority: role.write_authority,
+        effective_write_path: contract.effective_write_path,
+        message: formatInvalidReviewOnlyLocalCliBindingError(roleId, role.runtime),
+      });
+    } else if (contract.effective_write_path === 'invalid_authoritative_binding') {
+      issues.push({
+        role_id: roleId,
+        runtime_id: role.runtime,
+        runtime_type: runtime.type,
+        write_authority: role.write_authority,
+        effective_write_path: contract.effective_write_path,
+        message: formatInvalidAuthoritativeBindingError(roleId, role.runtime, runtime.type, role.write_authority),
+      });
+    }
+  }
+
+  return issues;
+}
+
 /**
  * Validate a governed config.
  * Returns { ok, errors }.
@@ -458,21 +505,9 @@ export function validateV4Config(data, projectRoot) {
     }
   }
 
-  // Cross-reference: review_only roles should not use authoritative runtimes
-  if (data.roles && data.runtimes) {
-    for (const [id, role] of Object.entries(data.roles)) {
-      if (role.runtime && data.runtimes[role.runtime]) {
-        const rt = data.runtimes[role.runtime];
-        const contract = getRoleRuntimeCapabilityContract(id, role, rt);
-        if (contract.effective_write_path === 'invalid_review_only_binding') {
-          errors.push(`Role "${id}" is review_only but uses local_cli runtime "${role.runtime}" — review_only roles should not have authoritative write access`);
-        } else if (contract.effective_write_path === 'invalid_authoritative_binding') {
-          errors.push(
-            `Role "${id}" has write_authority "${role.write_authority}" but uses ${rt.type} runtime "${role.runtime}" — ${rt.type} only supports review_only and proposed roles`
-          );
-        }
-      }
-    }
+  // Cross-reference: role authority must match the runtime's write contract
+  for (const issue of findAuthorityRuntimeBindingIssues(data)) {
+    errors.push(issue.message);
   }
 
   // Routing (optional but validated if present)

package/src/lib/repo-observer.js

@@ -540,7 +540,7 @@ export function compareDeclaredVsObserved(declared, observed, writeAuthority, op
         // The attribution system will handle later-accepted siblings correctly.
         warnings.push(`Undeclared file changes detected (likely from concurrent sibling turns): ${undeclared.join(', ')}`);
       } else {
-        errors.push(`Undeclared file changes detected (observed but not in files_changed): ${undeclared.join(', ')}`);
+        errors.push(`Undeclared file changes detected (observed but not in files_changed): ${undeclared.join(', ')}. If these files were changed by the operator (not the turn), add them to the dispatch baseline by committing or stashing them before dispatch.`);
       }
     }
     if (phantom.length > 0) {
@@ -701,7 +701,12 @@ function getWorkingTreeChanges(root) {
   }
 }
 
-function captureDirtyWorkspaceSnapshot(root) {
+/**
+ * Capture hashes of all non-operational dirty files in the workspace.
+ * Used at baseline time AND at dispatch time to snapshot pre-existing dirt
+ * so acceptance can filter unchanged files (BUG-1 fix).
+ */
+export function captureDirtyWorkspaceSnapshot(root) {
   const snapshot = {};
   for (const filePath of getWorkingTreeChanges(root).filter((filePath) => !isOperationalPath(filePath))) {
     snapshot[filePath] = getWorkspaceFileMarker(root, filePath);

package/src/lib/run-events.js

@@ -18,6 +18,8 @@ export const VALID_RUN_EVENTS = [
   'turn_accepted',
   'turn_rejected',
   'turn_conflicted',
+  'acceptance_failed',
+  'turn_reissued',
   'run_blocked',
   'run_completed',
   'escalation_raised',
@@ -41,6 +43,7 @@ export const VALID_RUN_EVENTS = [
  * @param {string} [details.phase]   - Current phase
  * @param {string} [details.status]  - Current run status
  * @param {object} [details.turn]    - Turn context (turn_id, role_id, etc.)
+ * @param {string} [details.intent_id] - Intake intent id when the event services queued intake work
  * @param {object} [details.payload] - Additional event-specific data
  * @returns {{ ok: boolean, event_id: string }}
  */
@@ -54,6 +57,7 @@ export function emitRunEvent(root, eventType, details = {}) {
     phase: details.phase || null,
     status: details.status || null,
     turn: details.turn || null,
+    intent_id: details.intent_id || null,
     payload: details.payload || {},
   };
 

package/src/lib/run-loop.js

@@ -23,6 +23,7 @@ import {
   rejectTurn,
   markRunBlocked,
   writeDispatchBundle,
+  refreshTurnBaselineSnapshot,
   getTurnStagingResultPath,
   approvePhaseGate,
   approveCompletionGate,
@@ -308,6 +309,8 @@ async function executeParallelTurns(root, config, state, maxConcurrent, callback
   // ── Build dispatch contexts ──────────────────────────────────────────
   const contexts = [];
   for (const { turn, state: turnState } of turnsToDispatch) {
+    // BUG-1 fix: refresh baseline to capture files dirtied between assignment and dispatch
+    refreshTurnBaselineSnapshot(root, turn.turn_id);
     const bundleResult = writeDispatchBundle(root, turnState, config, { turnId: turn.turn_id });
     if (!bundleResult.ok) {
       errors.push(`writeDispatchBundle(${turn.assigned_role}): ${bundleResult.error}`);
@@ -442,6 +445,8 @@ async function dispatchAndProcess(root, config, turn, assignState, callbacks, em
   const roleId = turn.assigned_role;
   const history = [];
 
+  // BUG-1 fix: refresh baseline to capture files dirtied between assignment and dispatch
+  refreshTurnBaselineSnapshot(root, turn.turn_id);
   const bundleResult = writeDispatchBundle(root, assignState, config);
   if (!bundleResult.ok) {
     errors.push(`writeDispatchBundle(${roleId}): ${bundleResult.error}`);

package/src/lib/runner-interface.js

@@ -39,6 +39,8 @@ export {
   getActiveTurn,
   acquireAcceptanceLock as acquireLock,
   releaseAcceptanceLock as releaseLock,
+  refreshTurnBaselineSnapshot,
+  reissueTurn,
 } from './governed-state.js';
 
 // ── Dispatch ────────────────────────────────────────────────────────────────

package/src/lib/session-checkpoint.js

@@ -103,8 +103,24 @@ export function writeSessionCheckpoint(root, state, reason, extra = {}) {
     const pendingGate = state.pending_phase_transition?.gate || state.pending_transition?.gate || null;
     const pendingRunCompletion = state.pending_run_completion?.gate || null;
 
-    // Capture git baseline for repo-drift detection
-    const baselineRef = extra.baseline_ref || captureBaselineRef(root);
+    // Capture git baseline for repo-drift detection.
+    // When a turn_baseline from captureBaseline() is provided, derive
+    // baseline_ref from it so session.json and state.json always agree
+    // on workspace-dirty status (BUG-2 fix).
+    let baselineRef;
+    if (extra.turn_baseline) {
+      baselineRef = {
+        git_head: extra.turn_baseline.head_ref || null,
+        git_branch: null,
+        workspace_dirty: !extra.turn_baseline.clean,
+      };
+      // Fill in git_branch if available
+      try {
+        baselineRef.git_branch = shellExec('git rev-parse --abbrev-ref HEAD', { cwd: root, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+      } catch { /* non-fatal */ }
+    } else {
+      baselineRef = extra.baseline_ref || captureBaselineRef(root);
+    }
 
     const checkpoint = {
       session_id: sessionId,