agentxchain 2.132.0 → 2.134.0

package/package.json

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

package/scripts/release-postflight.sh

@@ -2,8 +2,9 @@
 # Release postflight — run this after publish succeeds.
 # Verifies: release tag exists, npm registry serves the version, metadata is present,
 # the published package resolves through npx, the published package can execute its
-# CLI entrypoint from the tarball, and runner package exports are importable in a
-# clean consumer project.
+# CLI entrypoint from the tarball, runner package exports are importable in a
+# clean consumer project, and the installed CLI can scaffold and validate a fresh
+# governed workspace.
 # Usage: bash scripts/release-postflight.sh --target-version <semver> [--tag vX.Y.Z]
 set -uo pipefail
 
@@ -260,6 +261,64 @@ EOF
   return "$node_status"
 }
 
+run_operator_frontdoor_smoke() {
+  if [[ -z "$TARBALL_URL" ]]; then
+    echo "registry tarball metadata unavailable for operator front-door smoke" >&2
+    return 1
+  fi
+
+  local smoke_root
+  local workspace
+  local bin_path
+  local smoke_npmrc
+  local install_status
+  local init_output
+  local init_status
+  local validate_output
+  local validate_status
+
+  smoke_root="$(mktemp -d "${TMPDIR:-/tmp}/agentxchain-operator-postflight.XXXXXX")"
+  workspace="${smoke_root}/workspace"
+  bin_path="${smoke_root}/bin/${PACKAGE_BIN_NAME}"
+  smoke_npmrc="${smoke_root}/.npmrc"
+  echo "registry=https://registry.npmjs.org/" > "$smoke_npmrc"
+
+  env -u NODE_AUTH_TOKEN NPM_CONFIG_USERCONFIG="$smoke_npmrc" \
+    npm install --global --prefix "$smoke_root" "$TARBALL_URL" >/dev/null 2>&1
+  install_status=$?
+  if [[ "$install_status" -ne 0 ]]; then
+    rm -rf "$smoke_root"
+    return "$install_status"
+  fi
+
+  if [[ ! -x "$bin_path" ]]; then
+    echo "installed binary missing at ${bin_path}" >&2
+    rm -rf "$smoke_root"
+    return 1
+  fi
+
+  init_output="$(
+    env -u NODE_AUTH_TOKEN NPM_CONFIG_USERCONFIG="$smoke_npmrc" \
+      "$bin_path" init --governed --template cli-tool --goal "Release operator smoke" --dir "$workspace" -y 2>&1
+  )"
+  init_status=$?
+  if [[ "$init_status" -ne 0 ]]; then
+    printf '%s\n' "$init_output"
+    rm -rf "$smoke_root"
+    return "$init_status"
+  fi
+
+  validate_output="$(
+    cd "$workspace" || exit 1
+    env -u NODE_AUTH_TOKEN NPM_CONFIG_USERCONFIG="$smoke_npmrc" \
+      "$bin_path" validate --mode kickoff --json 2>&1
+  )"
+  validate_status=$?
+  printf '%s\n' "$validate_output"
+  rm -rf "$smoke_root"
+  return "$validate_status"
+}
+
 run_with_retry() {
   local __output_var="$1"
   local description="$2"
@@ -313,17 +372,17 @@ run_with_retry() {
 
 echo "AgentXchain v${TARGET_VERSION} Release Postflight"
 echo "====================================="
-echo "Checks release truth after publish: tag, registry visibility, metadata, npx smoke, CLI install smoke, and package export smoke."
+echo "Checks release truth after publish: tag, registry visibility, metadata, npx smoke, CLI install smoke, package export smoke, and operator front-door smoke."
 echo ""
 
-echo "[1/7] Git tag"
+echo "[1/8] Git tag"
 if git rev-parse -q --verify "refs/tags/${TAG}" >/dev/null 2>&1; then
   pass "Git tag ${TAG} exists locally"
 else
   fail "Git tag ${TAG} is missing locally"
 fi
 
-echo "[2/7] Registry version"
+echo "[2/8] Registry version"
 if run_with_retry VERSION_OUTPUT "registry version" equals "${TARGET_VERSION}" npm view "${PACKAGE_NAME}@${TARGET_VERSION}" version; then
   PUBLISHED_VERSION="$(trim_last_line "$VERSION_OUTPUT")"
   if [[ "$PUBLISHED_VERSION" == "$TARGET_VERSION" ]]; then
@@ -336,7 +395,7 @@ else
   printf '%s\n' "$VERSION_OUTPUT" | tail -20
 fi
 
-echo "[3/7] Registry tarball metadata"
+echo "[3/8] Registry tarball metadata"
 if run_with_retry TARBALL_OUTPUT "registry tarball metadata" nonempty "" npm view "${PACKAGE_NAME}@${TARGET_VERSION}" dist.tarball; then
   TARBALL_URL="$(trim_last_line "$TARBALL_OUTPUT")"
   if [[ -n "$TARBALL_URL" ]]; then
@@ -349,7 +408,7 @@ else
   printf '%s\n' "$TARBALL_OUTPUT" | tail -20
 fi
 
-echo "[4/7] Registry checksum metadata"
+echo "[4/8] Registry checksum metadata"
 if run_with_retry INTEGRITY_OUTPUT "registry checksum metadata" nonempty "" npm view "${PACKAGE_NAME}@${TARGET_VERSION}" dist.integrity; then
   REGISTRY_CHECKSUM="$(trim_last_line "$INTEGRITY_OUTPUT")"
 fi
@@ -364,7 +423,7 @@ else
   fail "registry did not return checksum metadata"
 fi
 
-echo "[5/7] npx smoke"
+echo "[5/8] npx smoke"
 if run_with_retry NPX_OUTPUT "npx smoke" nonempty "" run_npx_smoke; then
   NPX_VERSION="$(extract_matching_line "$NPX_OUTPUT" "$TARGET_VERSION" 2>/dev/null || trim_last_line "$NPX_OUTPUT")"
   if [[ "$NPX_VERSION" == "$TARGET_VERSION" ]]; then
@@ -377,7 +436,7 @@ else
   printf '%s\n' "$NPX_OUTPUT" | tail -20
 fi
 
-echo "[6/7] Install smoke"
+echo "[6/8] Install smoke"
 if run_with_retry EXEC_OUTPUT "install smoke" nonempty "" run_install_smoke; then
   EXEC_VERSION="$(trim_last_line "$EXEC_OUTPUT")"
   if [[ "$EXEC_VERSION" == "$TARGET_VERSION" ]]; then
@@ -390,7 +449,7 @@ else
   printf '%s\n' "$EXEC_OUTPUT" | tail -20
 fi
 
-echo "[7/7] Package export smoke"
+echo "[7/8] Package export smoke"
 if run_with_retry RUNNER_EXPORT_OUTPUT "runner export smoke" nonempty "" run_runner_export_smoke; then
   RUNNER_EXPORT_JSON="$(trim_last_line "$RUNNER_EXPORT_OUTPUT")"
   RUNNER_EXPORT_VERSION="$(printf '%s' "$RUNNER_EXPORT_JSON" | node --input-type=module -e "process.stdin.setEncoding('utf8'); let raw=''; process.stdin.on('data', (chunk) => raw += chunk); process.stdin.on('end', () => { const parsed = JSON.parse(raw); console.log(parsed.runner_interface_version || ''); });")"
@@ -410,6 +469,20 @@ else
   printf '%s\n' "$RUNNER_EXPORT_OUTPUT" | tail -20
 fi
 
+echo "[8/8] Operator front-door smoke"
+if run_with_retry OPERATOR_OUTPUT "operator front-door smoke" nonempty "" run_operator_frontdoor_smoke; then
+  OPERATOR_OK="$(printf '%s' "$OPERATOR_OUTPUT" | node --input-type=module -e "process.stdin.setEncoding('utf8'); let raw=''; process.stdin.on('data', (chunk) => raw += chunk); process.stdin.on('end', () => { const parsed = JSON.parse(raw); console.log(parsed.ok ? 'true' : 'false'); });" 2>/dev/null || true)"
+  OPERATOR_PROTOCOL_MODE="$(printf '%s' "$OPERATOR_OUTPUT" | node --input-type=module -e "process.stdin.setEncoding('utf8'); let raw=''; process.stdin.on('data', (chunk) => raw += chunk); process.stdin.on('end', () => { const parsed = JSON.parse(raw); console.log(parsed.protocol_mode || ''); });" 2>/dev/null || true)"
+  if [[ "$OPERATOR_OK" == "true" && "$OPERATOR_PROTOCOL_MODE" == "governed" ]]; then
+    pass "published CLI scaffolds and validates a governed workspace"
+  else
+    fail "published operator front-door smoke did not validate a governed workspace"
+  fi
+else
+  fail "published operator front-door smoke failed"
+  printf '%s\n' "$OPERATOR_OUTPUT" | tail -20
+fi
+
 echo ""
 echo "====================================="
 echo "Results: ${PASS} passed, ${FAIL} failed"

package/src/commands/mission.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { readFileSync } from 'fs';
-import { resolve } from 'path';
+import { join, resolve } from 'path';
 import { findProjectRoot, loadProjectContext } from '../lib/config.js';
 import {
   attachChainToMission,
@@ -37,6 +37,7 @@ import { executeChainedRun } from '../lib/run-chain.js';
 import { executeGovernedRun } from './run.js';
 import { dispatchCoordinatorTurn, selectAssignmentForWorkstream } from '../lib/coordinator-dispatch.js';
 import { loadCoordinatorState } from '../lib/coordinator-state.js';
+import { projectRepoAcceptance } from '../lib/coordinator-acceptance.js';
 
 export async function missionStartCommand(opts) {
   const root = findProjectRoot(opts.dir || process.cwd());
@@ -144,6 +145,43 @@ export async function missionStartCommand(opts) {
   renderMissionSnapshot(snapshot);
 }
 
+function loadAcceptedRepoTurn(repoPath, turnId) {
+  try {
+    const historyPath = join(repoPath, '.agentxchain', 'history.jsonl');
+    const content = readFileSync(historyPath, 'utf8').trim();
+    if (!content) return null;
+    const entries = content
+      .split('\n')
+      .map((line) => JSON.parse(line))
+      .filter((entry) => entry?.turn_id === turnId)
+      .filter((entry) => Boolean(entry?.accepted_at) || entry?.status === 'accepted' || entry?.status === 'completed');
+    return entries.at(-1) || null;
+  } catch {
+    return null;
+  }
+}
+
+function projectAcceptedCoordinatorTurn(workspacePath, coordinatorConfig, repoId, turnId, workstreamId, fallbackState) {
+  const acceptedTurn = loadAcceptedRepoTurn(coordinatorConfig.repos?.[repoId]?.resolved_path, turnId);
+  if (!acceptedTurn) {
+    return { ok: false, error: `Accepted turn ${turnId} not found in repo-local history for ${repoId}.` };
+  }
+
+  const currentState = loadCoordinatorState(workspacePath) || fallbackState;
+  if (!currentState) {
+    return { ok: false, error: `Coordinator state not found at ${workspacePath}.` };
+  }
+
+  return projectRepoAcceptance(
+    workspacePath,
+    currentState,
+    coordinatorConfig,
+    repoId,
+    acceptedTurn,
+    workstreamId,
+  );
+}
+
 export async function missionListCommand(opts) {
   const root = findProjectRoot(opts.dir || process.cwd());
   if (!root) {
@@ -578,6 +616,7 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
       }
 
       const executor = opts._executeGovernedRun || executeGovernedRun;
+      const childLog = opts.json ? noop : (opts._log || console.log);
       const repoContext = loadProjectContext(retry.retryResult.repo_path);
       if (!repoContext) {
         console.error(chalk.red(`Cannot load project context for retried repo at ${retry.retryResult.repo_path}.`));
@@ -586,6 +625,7 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
 
       const runOpts = {
         autoApprove: !!opts.autoApprove,
+        log: childLog,
         provenance: {
           trigger: 'manual',
           created_by: 'operator',
@@ -619,6 +659,20 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
         process.exit(1);
       }
 
+      if ((execution?.exitCode ?? 0) === 0) {
+        const projection = projectAcceptedCoordinatorTurn(
+          mission.coordinator.workspace_path,
+          coordinatorConfigResult.config,
+          retry.retryResult.repo_id,
+          retry.retryResult.reissued_turn_id,
+          opts.workstream,
+          loadCoordinatorState(mission.coordinator.workspace_path),
+        );
+        if (!projection.ok) {
+          console.error(chalk.yellow(`Coordinator retry projection warning: ${projection.error}`));
+        }
+      }
+
       const syncedRetry = synchronizeCoordinatorPlanState(root, mission, retry.plan);
       const retriedPlan = syncedRetry.ok ? syncedRetry.plan : retry.plan;
       const retriedWorkstream = retriedPlan.workstreams.find((ws) => ws.workstream_id === opts.workstream);
@@ -1385,7 +1439,7 @@ async function dispatchAndExecuteCoordinatorWorkstream(
   root, mission, plan, workstreamId, coordinatorConfig, coordinatorState, opts,
 ) {
   const executor = opts._executeGovernedRun || executeGovernedRun;
-  const logger = opts._log || console.log;
+  const logger = opts.json ? noop : (opts._log || console.log);
 
   // 1. Select assignment
   const assignment = selectAssignmentForWorkstream(
@@ -1456,6 +1510,26 @@ async function dispatchAndExecuteCoordinatorWorkstream(
     };
   }
 
+  if ((execution?.exitCode ?? 0) === 0) {
+    const projection = projectAcceptedCoordinatorTurn(
+      mission.coordinator.workspace_path,
+      coordinatorConfig,
+      dispatch.repo_id,
+      dispatch.turn_id,
+      workstreamId,
+      loadCoordinatorState(mission.coordinator.workspace_path) || coordinatorState,
+    );
+    if (!projection.ok) {
+      return {
+        ok: false,
+        status: 'projection_error',
+        repo_id: dispatch.repo_id,
+        turn_id: dispatch.turn_id,
+        error: projection.error,
+      };
+    }
+  }
+
   // 5. Sync plan state from coordinator (updates barriers, accepted repos, failures)
   const synced = synchronizeCoordinatorPlanState(root, mission, launch.plan);
 
@@ -2285,3 +2359,5 @@ function formatTimestamp(value) {
 function pad(value, width) {
   return String(value).padEnd(width);
 }
+
+function noop() {}

package/src/lib/coordinator-dispatch.js

@@ -1,7 +1,7 @@
 import { appendFileSync, copyFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { loadProjectContext, loadProjectState } from './config.js';
-import { assignGovernedTurn, getActiveTurnCount } from './governed-state.js';
+import { assignGovernedTurn, getActiveTurnCount, initializeGovernedRun } from './governed-state.js';
 import { writeDispatchBundle } from './dispatch-bundle.js';
 import { getDispatchTurnDir } from './turn-paths.js';
 import { readBarriers, readCoordinatorHistory, recordCoordinatorDecision } from './coordinator-state.js';
@@ -253,6 +253,17 @@ export function dispatchCoordinatorTurn(workspacePath, state, config, assignment
     return { ok: false, error: runtime.detail };
   }
 
+  let repoState = runtime.state;
+  if (repoState.status === 'idle' || repoState.status === 'completed') {
+    const initResult = initializeGovernedRun(runtime.root, runtime.config, {
+      allow_terminal_restart: repoState.status === 'completed',
+    });
+    if (!initResult.ok) {
+      return { ok: false, error: initResult.error };
+    }
+    repoState = initResult.state;
+  }
+
   const assignResult = assignGovernedTurn(runtime.root, runtime.config, assignment.role);
   if (!assignResult.ok) {
     return { ok: false, error: assignResult.error };

package/src/lib/mission-plans.js

@@ -12,7 +12,7 @@ import { join } from 'path';
 import { loadChainReport } from './chain-reports.js';
 import { writeDispatchBundle } from './dispatch-bundle.js';
 import { loadProjectContext, loadProjectState } from './config.js';
-import { reissueTurn } from './governed-state.js';
+import { reactivateGovernedRun, reissueTurn } from './governed-state.js';
 import { emitRunEvent } from './run-events.js';
 import { readBarriers, readCoordinatorHistory, recordCoordinatorDecision } from './coordinator-state.js';
 import { loadCoordinatorConfig } from './coordinator-config.js';
@@ -1074,7 +1074,19 @@ export function retryCoordinatorWorkstream(root, mission, planId, workstreamId,
     return { ok: false, error: reissued.error };
   }
 
-  const bundleResult = writeDispatchBundle(repoTurn.root, reissued.state, repoTurn.config, {
+  let repoStateForBundle = reissued.state;
+  if (reissued.state?.status === 'blocked' || reissued.state?.status === 'paused') {
+    const reactivated = reactivateGovernedRun(repoTurn.root, reissued.state, {
+      via: 'mission plan launch --retry',
+      notificationConfig: repoTurn.config,
+    });
+    if (!reactivated.ok) {
+      return { ok: false, error: `Turn reissued but blocked run could not be reactivated: ${reactivated.error}` };
+    }
+    repoStateForBundle = reactivated.state;
+  }
+
+  const bundleResult = writeDispatchBundle(repoTurn.root, repoStateForBundle, repoTurn.config, {
     turnId: reissued.newTurn.turn_id,
   });
   if (!bundleResult.ok) {