agentxchain 2.142.0 → 2.144.0

package/package.json

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

package/scripts/normalize-release-note-sidebar-positions.mjs

@@ -42,12 +42,10 @@ function updateSidebarPosition(content, nextPosition) {
   const body = content.slice(frontmatterEnd + 5);
   const expectedLine = `sidebar_position: ${nextPosition}`;
 
-  let updatedFrontmatter;
-  if (/^sidebar_position:\s*\d+\s*$/m.test(frontmatter)) {
-    updatedFrontmatter = frontmatter.replace(/^sidebar_position:\s*\d+\s*$/m, expectedLine);
-  } else {
-    updatedFrontmatter = frontmatter.replace(/^---\n/, `---\n${expectedLine}\n`);
-  }
+  // Strip ALL existing sidebar_position lines (handles duplicates from manual edits)
+  let strippedFrontmatter = frontmatter.replace(/^sidebar_position:\s*-?\d+\s*\n/gm, '');
+  // Insert the canonical position after the opening delimiter
+  let updatedFrontmatter = strippedFrontmatter.replace(/^---\n/, `---\n${expectedLine}\n`);
 
   const updated = updatedFrontmatter + body;
   return {

package/scripts/release-bump.sh

@@ -79,6 +79,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"

package/src/lib/export.js

@@ -6,6 +6,10 @@ import { join, relative, resolve } from 'node:path';
 import { loadProjectContext, loadProjectState } from './config.js';
 import { loadCoordinatorConfig, COORDINATOR_CONFIG_FILE } from './coordinator-config.js';
 import { loadCoordinatorState } from './coordinator-state.js';
+import {
+  RUN_CONTINUITY_DIRECTORY_ROOTS,
+  RUN_CONTINUITY_STATE_FILES,
+} from './repo-observer.js';
 import { normalizeRunProvenance } from './run-provenance.js';
 import { getDashboardPid, getDashboardSession } from '../commands/dashboard.js';
 import { readRepoDecisions, summarizeRepoDecisions } from './repo-decisions.js';
@@ -23,62 +27,24 @@ const COORDINATOR_INCLUDED_ROOTS = [
   '.agentxchain/multirepo/RECOVERY_REPORT.md',
 ];
 
-export const RUN_EXPORT_INCLUDED_ROOTS = [
+const RUN_EXPORT_ONLY_ROOTS = [
   'agentxchain.json',
-  'TALK.md',
   '.agentxchain-dashboard.pid',
   '.agentxchain-dashboard.json',
-  '.agentxchain/state.json',
-  '.agentxchain/session.json',
-  '.agentxchain/history.jsonl',
-  '.agentxchain/decision-ledger.jsonl',
-  '.agentxchain/repo-decisions.jsonl',
-  '.agentxchain/hook-audit.jsonl',
-  '.agentxchain/hook-annotations.jsonl',
-  '.agentxchain/notification-audit.jsonl',
-  '.agentxchain/run-history.jsonl',
-  '.agentxchain/events.jsonl',
-  '.agentxchain/schedule-state.json',
-  '.agentxchain/schedule-daemon.json',
-  '.agentxchain/continuous-session.json',
-  '.agentxchain/human-escalations.jsonl',
-  '.agentxchain/sla-reminders.json',
-  '.agentxchain/dispatch',
-  '.agentxchain/staging',
-  '.agentxchain/transactions/accept',
-  '.agentxchain/intake',
-  '.agentxchain/multirepo',
-  '.agentxchain/reviews',
-  '.agentxchain/proposed',
-  '.agentxchain/reports',
   '.planning',
 ];
 
+export const RUN_EXPORT_INCLUDED_ROOTS = [
+  'agentxchain.json',
+  ...RUN_CONTINUITY_STATE_FILES,
+  ...RUN_CONTINUITY_DIRECTORY_ROOTS,
+  ...RUN_EXPORT_ONLY_ROOTS.filter((root) => root !== 'agentxchain.json'),
+];
+
 export const RUN_RESTORE_ROOTS = [
   'agentxchain.json',
-  'TALK.md',
-  '.agentxchain/state.json',
-  '.agentxchain/session.json',
-  '.agentxchain/history.jsonl',
-  '.agentxchain/decision-ledger.jsonl',
-  '.agentxchain/hook-audit.jsonl',
-  '.agentxchain/hook-annotations.jsonl',
-  '.agentxchain/notification-audit.jsonl',
-  '.agentxchain/run-history.jsonl',
-  '.agentxchain/events.jsonl',
-  '.agentxchain/schedule-state.json',
-  '.agentxchain/schedule-daemon.json',
-  '.agentxchain/continuous-session.json',
-  '.agentxchain/human-escalations.jsonl',
-  '.agentxchain/sla-reminders.json',
-  '.agentxchain/dispatch',
-  '.agentxchain/staging',
-  '.agentxchain/transactions/accept',
-  '.agentxchain/intake',
-  '.agentxchain/multirepo',
-  '.agentxchain/reviews',
-  '.agentxchain/proposed',
-  '.agentxchain/reports',
+  ...RUN_CONTINUITY_STATE_FILES,
+  ...RUN_CONTINUITY_DIRECTORY_ROOTS,
   '.planning',
 ];
 

package/src/lib/governed-state.js

@@ -3547,6 +3547,7 @@ function _acceptGovernedTurnLocked(root, config, opts) {
   // protocol violation for authoritative completed turns. A workspace artifact
   // declares "I mutated repo files" — if files_changed is empty, the declaration
   // is incoherent and must be rejected before replay or history persistence.
+  // proposed turns cannot use workspace artifacts (validator rejects earlier).
   if (artifactType === 'workspace'
     && writeAuthority === 'authoritative'
     && turnResult.status === 'completed'

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

@@ -22,20 +22,22 @@ import { join } from 'path';
 // They must never be attributed to agents in observation or baseline checks.
 // Frozen per Session #19 decision.
 
-const OPERATIONAL_PATH_PREFIXES = [
+export const OPERATIONAL_PATH_PREFIXES = Object.freeze([
   '.agentxchain/dispatch/',
-  '.agentxchain/dispatch-progress-',
+  '.agentxchain/dispatch-progress',
   '.agentxchain/staging/',
   '.agentxchain/intake/',
   '.agentxchain/locks/',
   '.agentxchain/transactions/',
   '.agentxchain/missions/',
   '.agentxchain/multirepo/',
-];
+  '.agentxchain/plugins/',
+  '.agentxchain/prompts/',
+]);
 
 // Orchestrator-owned state files that agents must never be blamed for modifying.
 // These are written exclusively by the orchestrator (§4.1 State Ownership Rule).
-const ORCHESTRATOR_STATE_FILES = [
+export const ORCHESTRATOR_STATE_FILES = Object.freeze([
   '.agentxchain/state.json',
   '.agentxchain/session.json',
   '.agentxchain/history.jsonl',
@@ -52,31 +54,87 @@ const ORCHESTRATOR_STATE_FILES = [
   '.agentxchain/continuous-session.json',
   '.agentxchain/human-escalations.jsonl',
   '.agentxchain/sla-reminders.json',
+  '.agentxchain/SESSION_RECOVERY.md',
+  '.agentxchain/migration-report.md',
   'TALK.md',
   'HUMAN_TASKS.md',
-];
+]);
 
 // Evidence paths may legitimately remain dirty across turns without blocking the
 // next code-writing assignment. They still remain actor-observable so review
 // accountability is preserved during acceptance.
-const BASELINE_EXEMPT_PATH_PREFIXES = [
+export const BASELINE_EXEMPT_PATH_PREFIXES = Object.freeze([
   '.agentxchain/reviews/',
   '.agentxchain/reports/',
   '.agentxchain/proposed/',
-];
+]);
+
+// Continuity export/restore must stay aligned with orchestrator ownership,
+// but only for the subset that represents governed run state.
+export const RUN_CONTINUITY_STATE_FILES = Object.freeze([
+  ...ORCHESTRATOR_STATE_FILES.filter((filePath) => filePath !== 'HUMAN_TASKS.md'),
+]);
+
+export const RUN_CONTINUITY_DIRECTORY_ROOTS = Object.freeze([
+  '.agentxchain/dispatch',
+  '.agentxchain/staging',
+  '.agentxchain/transactions/accept',
+  '.agentxchain/intake',
+  '.agentxchain/missions',
+  '.agentxchain/multirepo',
+  ...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/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,