agentxchain 2.143.0 → 2.144.0

package/package.json

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

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/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/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,