agentxchain 2.35.0 → 2.37.0

package/dashboard/app.js

@@ -16,7 +16,7 @@ import { render as renderBlockers } from './components/blockers.js';
 import { render as renderArtifacts } from './components/artifacts.js';
 
 const VIEWS = {
-  timeline: { fetch: ['state', 'history', 'audit', 'annotations'], render: renderTimeline },
+  timeline: { fetch: ['state', 'continuity', 'history', 'audit', 'annotations'], render: renderTimeline },
   ledger: { fetch: ['ledger'], render: renderLedger },
   hooks: { fetch: ['audit', 'annotations'], render: renderHooks },
   blocked: { fetch: ['state', 'audit', 'coordinatorState', 'coordinatorAudit'], render: renderBlocked },
@@ -29,6 +29,7 @@ const VIEWS = {
 
 const API_MAP = {
   state: '/api/state',
+  continuity: '/api/continuity',
   history: '/api/history',
   ledger: '/api/ledger',
   audit: '/api/hooks/audit',

package/dashboard/components/timeline.js

@@ -132,7 +132,41 @@ function renderTurnDetailPanel(turnId, annotations, audit) {
   return html;
 }
 
-export function render({ state, history, annotations, audit }) {
+function renderContinuityPanel(continuity) {
+  if (!continuity) return '';
+
+  const checkpoint = continuity.checkpoint;
+  const checkpointSummary = checkpoint?.last_checkpoint_at
+    ? `${checkpoint.checkpoint_reason || 'unknown'} at ${checkpoint.last_checkpoint_at}`
+    : (checkpoint?.checkpoint_reason || 'No session checkpoint recorded');
+
+  let html = `<div class="section continuity-section"><h3>Continuity</h3><div class="turn-card">`;
+
+  if (checkpoint) {
+    html += `<div class="turn-detail"><span class="detail-label">Session:</span> <span class="mono">${esc(checkpoint.session_id || 'unknown')}</span></div>`;
+    html += `<div class="turn-detail"><span class="detail-label">Checkpoint:</span> ${esc(checkpointSummary)}</div>`;
+    html += `<div class="turn-detail"><span class="detail-label">Last turn:</span> <span class="mono">${esc(checkpoint.last_turn_id || 'none')}</span></div>`;
+    html += `<div class="turn-detail"><span class="detail-label">Last role:</span> ${esc(checkpoint.last_role || 'unknown')}</div>`;
+    if (continuity.stale_checkpoint) {
+      html += `<div class="turn-detail risks"><span class="detail-label">Warning:</span> checkpoint tracks <span class="mono">${esc(checkpoint.run_id || 'unknown')}</span>, but state.json remains source of truth.</div>`;
+    }
+  } else {
+    html += `<div class="turn-detail"><span class="detail-label">Checkpoint:</span> No session checkpoint recorded</div>`;
+  }
+
+  if (continuity.restart_recommended) {
+    html += `<div class="turn-detail"><span class="detail-label">Restart:</span> <span class="mono">agentxchain restart</span></div>`;
+  }
+
+  if (continuity.recovery_report_path) {
+    html += `<div class="turn-detail"><span class="detail-label">Report:</span> <span class="mono">${esc(continuity.recovery_report_path)}</span></div>`;
+  }
+
+  html += `</div></div>`;
+  return html;
+}
+
+export function render({ state, continuity, history, annotations, audit }) {
   if (!state) {
     return `<div class="placeholder"><h2>No Run</h2><p>No governed run found. Start one with <code class="mono">agentxchain init --governed</code></p></div>`;
   }
@@ -152,6 +186,8 @@ export function render({ state, history, annotations, audit }) {
     </div>
   </div>`;
 
+  html += renderContinuityPanel(continuity);
+
   // Active turns
   if (activeTurns.length > 0) {
     html += `<div class="section"><h3>Active Turns</h3><div class="turn-list">`;

package/package.json

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

package/scripts/release-bump.sh

@@ -56,6 +56,8 @@ ALLOWED_RELEASE_PATHS=(
   ".agentxchain-conformance/capabilities.json"
   "website-v2/docs/protocol-implementor-guide.mdx"
   ".planning/LAUNCH_EVIDENCE_REPORT.md"
+  "cli/homebrew/agentxchain.rb"
+  "cli/homebrew/README.md"
 )
 
 is_allowed_release_path() {
@@ -119,7 +121,11 @@ echo "  OK: tag v${TARGET_VERSION} does not exist"
 # Ensures all governed version surfaces already reference the target version
 # BEFORE the bump commit is created. This catches stale drift that would
 # otherwise only be discovered after minting local release identities.
-echo "[4/8] Verifying version-surface alignment for ${TARGET_VERSION}..."
+#
+# NOTE: Homebrew mirror formula and README are NOT checked here. They are
+# auto-aligned in step 5 because the registry SHA256 is inherently a
+# post-publish artifact. See DEC-HOMEBREW-SHA-SPLIT-001.
+echo "[4/9] Verifying version-surface alignment for ${TARGET_VERSION}..."
 SURFACE_ERRORS=()
 
 # 4a. CHANGELOG top heading
@@ -172,13 +178,45 @@ if [[ "${#SURFACE_ERRORS[@]}" -gt 0 ]]; then
 fi
 echo "  OK: all 7 governed version surfaces reference ${TARGET_VERSION}"
 
-# 5. Update version files (no git operations)
-echo "[5/8] Updating version files..."
+# 5. Auto-align Homebrew mirror to target version
+# The formula URL and README version/tarball are updated automatically.
+# The SHA256 is carried from the previous version — it is inherently a
+# post-publish artifact (npm registry tarballs are not byte-identical to
+# local npm-pack output). sync-homebrew.sh corrects the SHA after publish.
+echo "[5/9] Auto-aligning Homebrew mirror to ${TARGET_VERSION}..."
+HOMEBREW_MIRROR="${REPO_ROOT}/cli/homebrew/agentxchain.rb"
+HOMEBREW_MIRROR_README="${REPO_ROOT}/cli/homebrew/README.md"
+TARBALL_URL="https://registry.npmjs.org/agentxchain/-/agentxchain-${TARGET_VERSION}.tgz"
+HOMEBREW_ALIGNED=false
+
+if [[ -f "$HOMEBREW_MIRROR" ]]; then
+  ESCAPED_URL="$(printf '%s' "$TARBALL_URL" | sed 's/[&/\]/\\&/g')"
+  sed -i.bak -E "s|^([[:space:]]*url \").*(\")|\1${ESCAPED_URL}\2|" "$HOMEBREW_MIRROR"
+  rm -f "${HOMEBREW_MIRROR}.bak"
+  HOMEBREW_ALIGNED=true
+  echo "  OK: formula URL -> ${TARBALL_URL}"
+fi
+
+if [[ -f "$HOMEBREW_MIRROR_README" ]]; then
+  sed -i.bak -E "s|^(- version: \`).*(\`)|\1${TARGET_VERSION}\2|" "$HOMEBREW_MIRROR_README"
+  sed -i.bak -E "s|^(- source tarball: \`).*(\`)|\1${TARBALL_URL}\2|" "$HOMEBREW_MIRROR_README"
+  rm -f "${HOMEBREW_MIRROR_README}.bak"
+  echo "  OK: README version and tarball -> ${TARGET_VERSION}"
+fi
+
+if $HOMEBREW_ALIGNED; then
+  echo "  Note: SHA carried from previous version; sync-homebrew.sh will set the real registry SHA post-publish"
+else
+  echo "  Skipped: no Homebrew mirror files found"
+fi
+
+# 6. Update version files (no git operations)
+echo "[6/9] Updating version files..."
 npm version "$TARGET_VERSION" --no-git-tag-version
 echo "  OK: package.json updated to ${TARGET_VERSION}"
 
-# 6. Stage version files
-echo "[6/8] Staging version files..."
+# 7. Stage version files
+echo "[7/9] Staging version files..."
 git add -- package.json
 if [[ -f package-lock.json ]]; then
   git add -- package-lock.json
@@ -188,8 +226,8 @@ for rel_path in "${ALLOWED_RELEASE_PATHS[@]}"; do
 done
 echo "  OK: version files and allowed release surfaces staged"
 
-# 7. Create release commit
-echo "[7/8] Creating release commit..."
+# 8. Create release commit
+echo "[8/9] Creating release commit..."
 git commit -m "${TARGET_VERSION}"
 RELEASE_SHA=$(git rev-parse HEAD)
 COMMIT_MSG=$(git log -1 --format=%s)
@@ -199,8 +237,8 @@ if [[ "$COMMIT_MSG" != "$TARGET_VERSION" ]]; then
 fi
 echo "  OK: commit ${RELEASE_SHA:0:7} with message '${TARGET_VERSION}'"
 
-# 8. Create annotated tag
-echo "[8/8] Creating annotated tag..."
+# 9. Create annotated tag
+echo "[9/9] Creating annotated tag..."
 git tag -a "v${TARGET_VERSION}" -m "v${TARGET_VERSION}"
 TAG_SHA=$(git rev-parse "v${TARGET_VERSION}")
 if [[ -z "$TAG_SHA" ]]; then

package/src/commands/status.js

@@ -1,12 +1,8 @@
-import { existsSync } from 'fs';
-import { join } from 'path';
 import chalk from 'chalk';
 import { loadConfig, loadLock, loadProjectContext, loadProjectState, loadState } from '../lib/config.js';
 import { deriveRecoveryDescriptor } from '../lib/blocked-state.js';
 import { getActiveTurn, getActiveTurnCount, getActiveTurns } from '../lib/governed-state.js';
-import { readSessionCheckpoint } from '../lib/session-checkpoint.js';
-
-const SESSION_RECOVERY_PATH = '.agentxchain/SESSION_RECOVERY.md';
+import { getContinuityStatus } from '../lib/continuity-status.js';
 
 export async function statusCommand(opts) {
   const context = loadProjectContext();
@@ -247,28 +243,6 @@ function renderGovernedStatus(context, opts) {
   console.log('');
 }
 
-function getContinuityStatus(root, state) {
-  const checkpoint = readSessionCheckpoint(root);
-  const recoveryReportPath = existsSync(join(root, SESSION_RECOVERY_PATH))
-    ? SESSION_RECOVERY_PATH
-    : null;
-
-  if (!checkpoint && !recoveryReportPath) return null;
-
-  const staleCheckpoint = !!(
-    checkpoint?.run_id
-    && state?.run_id
-    && checkpoint.run_id !== state.run_id
-  );
-
-  return {
-    checkpoint,
-    stale_checkpoint: staleCheckpoint,
-    recovery_report_path: recoveryReportPath,
-    restart_recommended: !!state && !['blocked', 'completed', 'failed'].includes(state.status),
-  };
-}
-
 function renderContinuityStatus(continuity, state) {
   if (!continuity) return;
 

package/src/lib/adapters/api-proxy-adapter.js

@@ -23,7 +23,7 @@
  *   All error returns include a `classified` ApiProxyError object with
  *   error_class, recovery instructions, and retryable flag.
  *
- * Supported providers: "anthropic", "openai"
+ * Supported providers: "anthropic", "openai", "google"
  */
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from 'fs';
@@ -45,9 +45,12 @@ import {
 import { verifyDispatchManifestForAdapter } from '../dispatch-manifest.js';
 
 // Provider endpoint registry
+// Google Gemini endpoint requires the model name interpolated at call time;
+// the registry stores a template with {model} as a placeholder.
 const PROVIDER_ENDPOINTS = {
   anthropic: 'https://api.anthropic.com/v1/messages',
   openai: 'https://api.openai.com/v1/chat/completions',
+  google: 'https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent',
 };
 
 // Bundled cost rates per million tokens (USD).
@@ -67,6 +70,10 @@ const BUNDLED_COST_RATES = {
   'o3': { input_per_1m: 2.00, output_per_1m: 8.00 },
   'o3-mini': { input_per_1m: 1.10, output_per_1m: 4.40 },
   'o4-mini': { input_per_1m: 1.10, output_per_1m: 4.40 },
+  // Google Gemini — verified 2026-04-09 (training knowledge)
+  'gemini-2.5-pro': { input_per_1m: 1.25, output_per_1m: 10.00 },
+  'gemini-2.5-flash': { input_per_1m: 0.15, output_per_1m: 0.60 },
+  'gemini-2.0-flash': { input_per_1m: 0.10, output_per_1m: 0.40 },
 };
 
 // Resolve cost rates: operator-supplied cost_rates override bundled defaults
@@ -135,6 +142,25 @@ const PROVIDER_ERROR_MAPS = {
       { provider_error_type: 'rate_limit_error', http_status: 429, error_class: 'rate_limited', retryable: true },
     ],
   },
+  google: {
+    extractErrorType(body) {
+      // Google errors use { error: { status: "INVALID_ARGUMENT", ... } }
+      return typeof body?.error?.status === 'string' ? body.error.status : null;
+    },
+    extractErrorCode(body) {
+      return typeof body?.error?.code === 'number' ? String(body.error.code) : null;
+    },
+    mappings: [
+      { provider_error_type: 'UNAUTHENTICATED', http_status: 401, error_class: 'auth_failure', retryable: false },
+      { provider_error_type: 'PERMISSION_DENIED', http_status: 403, error_class: 'auth_failure', retryable: false },
+      { provider_error_type: 'NOT_FOUND', http_status: 404, error_class: 'model_not_found', retryable: false },
+      { provider_error_type: 'RESOURCE_EXHAUSTED', http_status: 429, error_class: 'rate_limited', retryable: true },
+      { provider_error_type: 'INVALID_ARGUMENT', http_status: 400, body_pattern: /token.*limit|context|too.long/i, error_class: 'context_overflow', retryable: false },
+      { provider_error_type: 'INVALID_ARGUMENT', http_status: 400, error_class: 'invalid_request', retryable: false },
+      { provider_error_type: 'UNAVAILABLE', http_status: 503, error_class: 'provider_overloaded', retryable: true },
+      { provider_error_type: 'INTERNAL', http_status: 500, error_class: 'unknown_api_error', retryable: true },
+    ],
+  },
 };
 
 // ── Error classification ──────────────────────────────────────────────────────
@@ -442,6 +468,10 @@ function usageFromTelemetry(provider, model, usage, config) {
   if (provider === 'openai') {
     inputTokens = Number.isFinite(usage.prompt_tokens) ? usage.prompt_tokens : 0;
     outputTokens = Number.isFinite(usage.completion_tokens) ? usage.completion_tokens : 0;
+  } else if (provider === 'google') {
+    // Google Gemini returns usageMetadata at root level with promptTokenCount / candidatesTokenCount
+    inputTokens = Number.isFinite(usage.promptTokenCount) ? usage.promptTokenCount : 0;
+    outputTokens = Number.isFinite(usage.candidatesTokenCount) ? usage.candidatesTokenCount : 0;
   } else {
     inputTokens = Number.isFinite(usage.input_tokens) ? usage.input_tokens : 0;
     outputTokens = Number.isFinite(usage.output_tokens) ? usage.output_tokens : 0;
@@ -691,7 +721,9 @@ async function executeApiCall({
     };
   }
 
-  const usage = usageFromTelemetry(provider, model, responseData.usage, config);
+  // Google Gemini returns usage at responseData.usageMetadata; others at responseData.usage
+  const usageSource = provider === 'google' ? responseData.usageMetadata : responseData.usage;
+  const usage = usageFromTelemetry(provider, model, usageSource, config);
   const extraction = extractTurnResult(responseData, provider);
 
   if (!extraction.ok) {
@@ -791,7 +823,7 @@ export async function dispatchApiProxy(root, state, config, options = {}) {
     return errorReturn(root, turn.turn_id, classified);
   }
 
-  const endpoint = runtime.base_url || PROVIDER_ENDPOINTS[provider];
+  let endpoint = runtime.base_url || PROVIDER_ENDPOINTS[provider];
   if (!endpoint) {
     const classified = classifyError(
       'unsupported_provider',
@@ -802,6 +834,12 @@ export async function dispatchApiProxy(root, state, config, options = {}) {
     return errorReturn(root, turn.turn_id, classified);
   }
 
+  // Google Gemini: interpolate model into endpoint URL and append API key as query param
+  if (provider === 'google') {
+    endpoint = endpoint.replace('{model}', encodeURIComponent(model));
+    endpoint += (endpoint.includes('?') ? '&' : '?') + `key=${encodeURIComponent(apiKey)}`;
+  }
+
   // Build request
   const maxOutputTokens = runtime.max_output_tokens || 4096;
   const timeoutSeconds = runtime.timeout_seconds || 120;
@@ -1086,10 +1124,92 @@ function buildOpenAiRequest(promptMd, contextMd, model, maxOutputTokens) {
   };
 }
 
+function buildGoogleHeaders(_apiKey) {
+  // Google Gemini uses API key as a query parameter, not a header
+  return {
+    'Content-Type': 'application/json',
+  };
+}
+
+function buildGoogleRequest(promptMd, contextMd, model, maxOutputTokens) {
+  const userContent = contextMd
+    ? `${promptMd}${SEPARATOR}${contextMd}`
+    : promptMd;
+
+  return {
+    systemInstruction: {
+      parts: [{ text: SYSTEM_PROMPT }],
+    },
+    contents: [
+      {
+        role: 'user',
+        parts: [{ text: userContent }],
+      },
+    ],
+    generationConfig: {
+      maxOutputTokens,
+      responseMimeType: 'application/json',
+    },
+  };
+}
+
+function extractGoogleTurnResult(responseData) {
+  const promptBlockReason = responseData?.promptFeedback?.blockReason;
+  if (typeof promptBlockReason === 'string' && promptBlockReason.trim()) {
+    return {
+      ok: false,
+      error: `Google Gemini blocked the prompt before generation (blockReason: ${promptBlockReason})`,
+    };
+  }
+
+  if (!Array.isArray(responseData?.candidates) || responseData.candidates.length === 0) {
+    return { ok: false, error: 'API response has no candidates' };
+  }
+
+  const candidate = responseData.candidates[0];
+  const finishReason = typeof candidate?.finishReason === 'string'
+    ? candidate.finishReason
+    : null;
+  const parts = candidate?.content?.parts;
+  if (!Array.isArray(parts) || parts.length === 0) {
+    if (finishReason && finishReason !== 'STOP') {
+      return {
+        ok: false,
+        error: `Google Gemini candidate has no content parts (finishReason: ${finishReason})`,
+      };
+    }
+    return { ok: false, error: 'API response candidate has no content parts' };
+  }
+
+  const textPart = parts.find(p => typeof p.text === 'string');
+  if (!textPart?.text?.trim()) {
+    if (finishReason && finishReason !== 'STOP') {
+      return {
+        ok: false,
+        error: `Google Gemini returned no extractable text (finishReason: ${finishReason})`,
+      };
+    }
+    return { ok: false, error: 'API response has no text content part' };
+  }
+
+  const extraction = extractTurnResultFromText(textPart.text);
+  if (!extraction.ok && finishReason && finishReason !== 'STOP') {
+    return {
+      ok: false,
+      error: `Google Gemini returned non-extractable turn JSON (finishReason: ${finishReason})`,
+    };
+  }
+
+  return extraction;
+}
+
 function buildProviderHeaders(provider, apiKey) {
   if (provider === 'openai') {
     return buildOpenAiHeaders(apiKey);
   }
+  if (provider === 'google') {
+    return buildGoogleHeaders(apiKey);
+  }
   return buildAnthropicHeaders(apiKey);
 }
 
@@ -1097,6 +1217,9 @@ function buildProviderRequest(provider, promptMd, contextMd, model, maxOutputTok
   if (provider === 'openai') {
     return buildOpenAiRequest(promptMd, contextMd, model, maxOutputTokens);
   }
+  if (provider === 'google') {
+    return buildGoogleRequest(promptMd, contextMd, model, maxOutputTokens);
+  }
   return buildAnthropicRequest(promptMd, contextMd, model, maxOutputTokens);
 }
 
@@ -1184,6 +1307,9 @@ function extractTurnResult(responseData, provider = 'anthropic') {
   if (provider === 'openai') {
     return extractOpenAiTurnResult(responseData);
   }
+  if (provider === 'google') {
+    return extractGoogleTurnResult(responseData);
+  }
   return extractAnthropicTurnResult(responseData);
 }
 
@@ -1198,6 +1324,7 @@ export {
   extractTurnResult,
   buildAnthropicRequest,
   buildOpenAiRequest,
+  buildGoogleRequest,
   classifyError,
   classifyHttpError,
   BUNDLED_COST_RATES,

package/src/lib/continuity-status.js

@@ -0,0 +1,27 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { readSessionCheckpoint } from './session-checkpoint.js';
+
+export const SESSION_RECOVERY_PATH = '.agentxchain/SESSION_RECOVERY.md';
+
+export function getContinuityStatus(root, state) {
+  const checkpoint = readSessionCheckpoint(root);
+  const recoveryReportPath = existsSync(join(root, SESSION_RECOVERY_PATH))
+    ? SESSION_RECOVERY_PATH
+    : null;
+
+  if (!checkpoint && !recoveryReportPath) return null;
+
+  const staleCheckpoint = !!(
+    checkpoint?.run_id
+    && state?.run_id
+    && checkpoint.run_id !== state.run_id
+  );
+
+  return {
+    checkpoint,
+    stale_checkpoint: staleCheckpoint,
+    recovery_report_path: recoveryReportPath,
+    restart_recommended: !!state && !['blocked', 'completed', 'failed'].includes(state.status),
+  };
+}

package/src/lib/dashboard/state-reader.js

@@ -7,10 +7,12 @@
  */
 
 import { readFileSync, existsSync } from 'fs';
-import { join, normalize } from 'path';
+import { join, normalize, resolve } from 'path';
+import { getContinuityStatus } from '../continuity-status.js';
 
 const STATE_FILE = 'state.json';
 const SESSION_FILE = 'session.json';
+const SESSION_RECOVERY_FILE = 'SESSION_RECOVERY.md';
 const HISTORY_FILE = 'history.jsonl';
 const LEDGER_FILE = 'decision-ledger.jsonl';
 const HOOK_AUDIT_FILE = 'hook-audit.jsonl';
@@ -44,6 +46,7 @@ export const RESOURCE_MAP = {
 export const FILE_TO_RESOURCE = Object.fromEntries(
   Object.entries(RESOURCE_MAP).map(([resource, file]) => [normalizeRelativePath(file), resource])
 );
+FILE_TO_RESOURCE[normalizeRelativePath(SESSION_RECOVERY_FILE)] = '/api/continuity';
 
 export const WATCH_DIRECTORIES = [
   '',
@@ -86,6 +89,13 @@ export function readJsonlFile(agentxchainDir, filename) {
  * Read a resource by its API path. Returns { data, format } or null.
  */
 export function readResource(agentxchainDir, resourcePath) {
+  if (resourcePath === '/api/continuity') {
+    const root = resolve(agentxchainDir, '..');
+    const state = readJsonFile(agentxchainDir, STATE_FILE);
+    const data = getContinuityStatus(root, state);
+    return { data, format: 'json' };
+  }
+
   const filename = RESOURCE_MAP[resourcePath];
   if (!filename) return null;
 

package/src/lib/normalized-config.js

@@ -18,7 +18,7 @@ import { SUPPORTED_TOKEN_COUNTER_PROVIDERS } from './token-counter.js';
 
 const VALID_WRITE_AUTHORITIES = ['authoritative', 'proposed', 'review_only'];
 const VALID_RUNTIME_TYPES = ['manual', 'local_cli', 'api_proxy', 'mcp', 'remote_agent'];
-const VALID_API_PROXY_PROVIDERS = ['anthropic', 'openai'];
+const VALID_API_PROXY_PROVIDERS = ['anthropic', 'openai', 'google'];
 export const VALID_PROMPT_TRANSPORTS = ['argv', 'stdin', 'dispatch_bundle_only'];
 const VALID_MCP_TRANSPORTS = ['stdio', 'streamable_http'];
 const DEFAULT_PHASES = ['planning', 'implementation', 'qa'];