agentxchain 2.128.0 → 2.130.0

package/src/lib/missions.js

@@ -1,8 +1,9 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { loadAllChainReports, loadChainReport, loadLatestChainReport } from './chain-reports.js';
-import { buildPlanProgressSummary, loadLatestPlan } from './mission-plans.js';
+import { buildPlanProgressSummary, loadLatestPlan, synchronizeCoordinatorPlanState } 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']);
@@ -140,12 +141,31 @@ export function buildMissionSnapshot(root, missionArtifact) {
   const totalRuns = chains.reduce((sum, chain) => sum + (chain.runs?.length || 0), 0);
   const totalTurns = chains.reduce((sum, chain) => sum + (chain.total_turns || 0), 0);
   const latestChain = chains[0] || null;
-  const latestPlan = loadLatestPlan(root, missionArtifact.mission_id);
+  let 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 };
+    }
+  }
+
+  if (latestPlan && missionArtifact.coordinator && latestPlan.coordinator_scope) {
+    const syncedPlan = synchronizeCoordinatorPlanState(root, missionArtifact, latestPlan);
+    if (syncedPlan.ok) {
+      latestPlan = syncedPlan.plan;
+    }
+  }
+
   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 +175,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 +184,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 +222,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) {
@@ -622,6 +622,7 @@ export function checkCleanBaseline(root, writeAuthority) {
 
   return {
     clean: false,
+    dirty_files: actorDirtyFiles,
     reason: `Working tree has uncommitted changes in actor-owned files: ${actorDirtyFiles.slice(0, 5).join(', ')}${actorDirtyFiles.length > 5 ? '...' : ''}. Authoritative/proposed turns require a clean baseline in v1. Commit or stash those changes before assigning the next code-writing turn.`,
   };
 }
@@ -701,7 +702,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,9 @@ export const VALID_RUN_EVENTS = [
   'turn_accepted',
   'turn_rejected',
   'turn_conflicted',
+  'acceptance_failed',
+  'turn_reissued',
+  'turn_checkpointed',
   'run_blocked',
   'run_completed',
   'escalation_raised',
@@ -41,6 +44,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 +58,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}`);
@@ -393,6 +396,16 @@ async function executeParallelTurns(root, config, state, maxConcurrent, callback
 
       acceptedCount++;
       history.push({ role: roleId, turn_id: turn.turn_id, accepted: true });
+      if (callbacks.afterAccept) {
+        const afterAcceptResult = await callbacks.afterAccept({ turn, acceptResult });
+        if (afterAcceptResult?.ok === false) {
+          errors.push(`afterAccept(${roleId}): ${afterAcceptResult.error}`);
+          if (afterAcceptResult.state) {
+            emit({ type: 'blocked', state: afterAcceptResult.state, reason: 'after_accept_failed' });
+          }
+          return { terminal: true, ok: false, stop_reason: 'blocked', history, acceptedCount };
+        }
+      }
       emit({ type: 'turn_accepted', turn, role: roleId, state: acceptResult.state });
     } else {
       const validationResult = {
@@ -442,6 +455,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}`);
@@ -507,6 +522,16 @@ async function dispatchAndProcess(root, config, turn, assignState, callbacks, em
     }
 
     history.push({ role: roleId, turn_id: turn.turn_id, accepted: true });
+    if (callbacks.afterAccept) {
+      const afterAcceptResult = await callbacks.afterAccept({ turn, acceptResult });
+      if (afterAcceptResult?.ok === false) {
+        errors.push(`afterAccept(${roleId}): ${afterAcceptResult.error}`);
+        if (afterAcceptResult.state) {
+          emit({ type: 'blocked', state: afterAcceptResult.state, reason: 'after_accept_failed' });
+        }
+        return { terminal: true, ok: false, stop_reason: 'blocked', history };
+      }
+    }
     emit({ type: 'turn_accepted', turn, role: roleId, state: acceptResult.state });
     return { terminal: false, accepted: true, history };
   }

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,

package/src/lib/turn-checkpoint.js

@@ -0,0 +1,221 @@
+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 { emitRunEvent } from './run-events.js';
+import { safeWriteJson } from './safe-write.js';
+
+const STATE_PATH = '.agentxchain/state.json';
+const HISTORY_PATH = '.agentxchain/history.jsonl';
+
+function readState(root) {
+  const filePath = join(root, STATE_PATH);
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeState(root, state) {
+  safeWriteJson(join(root, STATE_PATH), state);
+}
+
+function readHistoryEntries(root) {
+  const filePath = join(root, HISTORY_PATH);
+  if (!existsSync(filePath)) return [];
+  const raw = readFileSync(filePath, 'utf8').trim();
+  if (!raw) return [];
+  return raw.split('\n').filter(Boolean).map((line) => JSON.parse(line));
+}
+
+function writeHistoryEntries(root, entries) {
+  const filePath = join(root, HISTORY_PATH);
+  const content = entries.map((entry) => JSON.stringify(entry)).join('\n');
+  writeFileSync(filePath, content ? `${content}\n` : '');
+}
+
+function git(root, args) {
+  return execFileSync('git', args, {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}
+
+function isGitRepo(root) {
+  try {
+    return git(root, ['rev-parse', '--is-inside-work-tree']) === 'true';
+  } catch {
+    return false;
+  }
+}
+
+function normalizeFilesChanged(filesChanged) {
+  return [...new Set(
+    (Array.isArray(filesChanged) ? filesChanged : [])
+      .filter((value) => typeof value === 'string')
+      .map((value) => value.trim())
+      .filter(Boolean),
+  )];
+}
+
+function extractGitError(err) {
+  const stderr = typeof err?.stderr === 'string' ? err.stderr.trim() : '';
+  const stdout = typeof err?.stdout === 'string' ? err.stdout.trim() : '';
+  return stderr || stdout || err?.message || 'git command failed';
+}
+
+function buildCheckpointCommit(entry) {
+  const subject = `checkpoint: ${entry.turn_id} (role=${entry.role}, phase=${entry.phase})`;
+  const bodyLines = [
+    `Summary: ${entry.summary || '(none)'}`,
+    `Turn-ID: ${entry.turn_id}`,
+    `Role: ${entry.role || '(unknown)'}`,
+    `Phase: ${entry.phase || '(unknown)'}`,
+    `Runtime: ${entry.runtime_id || '(unknown)'}`,
+  ];
+  if (entry.intent_id) bodyLines.push(`Intent-ID: ${entry.intent_id}`);
+  if (entry.accepted_at) bodyLines.push(`Accepted-At: ${entry.accepted_at}`);
+  return { subject, body: bodyLines.join('\n') };
+}
+
+export function detectPendingCheckpoint(root, dirtyFiles = []) {
+  const actorDirtyFiles = normalizeFilesChanged(dirtyFiles);
+  if (actorDirtyFiles.length === 0) return { required: false };
+
+  const resolved = resolveAcceptedTurnHistoryReference(root, null);
+  if (!resolved.ok || !resolved.entry) return { required: false };
+
+  const entry = resolved.entry;
+  if (entry.checkpoint_sha) return { required: false };
+
+  const turnFiles = normalizeFilesChanged(entry.files_changed);
+  if (turnFiles.length === 0) return { required: false };
+
+  const dirtyOutsideTurn = actorDirtyFiles.filter((file) => !turnFiles.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.`,
+  };
+}
+
+export function checkpointAcceptedTurn(root, opts = {}) {
+  if (!isGitRepo(root)) {
+    return { ok: false, error: 'checkpoint-turn requires a git repository.' };
+  }
+
+  const resolved = resolveAcceptedTurnHistoryReference(root, opts.turnId || opts.turn || null);
+  if (!resolved.ok || !resolved.entry) {
+    return { ok: false, error: resolved.error || 'Accepted turn not found.' };
+  }
+
+  const entry = resolved.entry;
+  if (entry.checkpoint_sha) {
+    return {
+      ok: true,
+      already_checkpointed: true,
+      turn: entry,
+      checkpoint_sha: entry.checkpoint_sha,
+    };
+  }
+
+  const filesChanged = normalizeFilesChanged(entry.files_changed);
+  if (filesChanged.length === 0) {
+    return {
+      ok: true,
+      skipped: true,
+      turn: entry,
+      reason: 'Accepted turn has no writable files_changed paths to checkpoint.',
+    };
+  }
+
+  try {
+    git(root, ['add', '-A', '--', ...filesChanged]);
+  } catch (err) {
+    return {
+      ok: false,
+      turn: entry,
+      error: `Failed to stage accepted files for checkpoint: ${extractGitError(err)}`,
+    };
+  }
+
+  let staged = [];
+  try {
+    staged = git(root, ['diff', '--cached', '--name-only', '--', ...filesChanged])
+      .split('\n')
+      .map((value) => value.trim())
+      .filter(Boolean);
+  } catch (err) {
+    return {
+      ok: false,
+      turn: entry,
+      error: `Failed to inspect staged checkpoint diff: ${extractGitError(err)}`,
+    };
+  }
+
+  if (staged.length === 0) {
+    return {
+      ok: true,
+      skipped: true,
+      turn: entry,
+      reason: `Accepted turn ${entry.turn_id} has no staged repo changes to checkpoint.`,
+    };
+  }
+
+  const commit = buildCheckpointCommit(entry);
+  try {
+    git(root, ['commit', '-m', commit.subject, '-m', commit.body]);
+  } catch (err) {
+    return {
+      ok: false,
+      turn: entry,
+      error: `Checkpoint commit failed: ${extractGitError(err)}`,
+    };
+  }
+
+  const checkpointSha = git(root, ['rev-parse', 'HEAD']);
+  const checkpointedAt = new Date().toISOString();
+
+  const historyEntries = readHistoryEntries(root).map((historyEntry) => (
+    historyEntry.turn_id === entry.turn_id
+      ? { ...historyEntry, checkpoint_sha: checkpointSha, checkpointed_at: checkpointedAt }
+      : historyEntry
+  ));
+  writeHistoryEntries(root, historyEntries);
+
+  const state = readState(root);
+  if (state) {
+    writeState(root, {
+      ...state,
+      last_completed_turn: {
+        turn_id: entry.turn_id,
+        role: entry.role || null,
+        phase: entry.phase || null,
+        checkpoint_sha: checkpointSha,
+        checkpointed_at: checkpointedAt,
+        intent_id: entry.intent_id || null,
+      },
+    });
+
+    emitRunEvent(root, 'turn_checkpointed', {
+      run_id: state.run_id || null,
+      phase: state.phase || null,
+      status: state.status || null,
+      turn: { turn_id: entry.turn_id, role_id: entry.role || null },
+      intent_id: entry.intent_id || null,
+      payload: { checkpoint_sha: checkpointSha, checkpointed_at: checkpointedAt },
+    });
+  }
+
+  return {
+    ok: true,
+    turn: entry,
+    checkpoint_sha: checkpointSha,
+    checkpointed_at: checkpointedAt,
+  };
+}

package/src/templates/governed/full-local-cli.json

@@ -0,0 +1,71 @@
+{
+  "id": "full-local-cli",
+  "display_name": "Full Local CLI",
+  "description": "Human-gated automation pattern with PM, Dev, QA, and Director all running as authoritative local_cli roles.",
+  "version": "1",
+  "protocol_compatibility": ["1.0", "1.1"],
+  "planning_artifacts": [],
+  "system_spec_overlay": {
+    "purpose_guidance": "Describe the repo as a human-gated all-local automation system. Clarify that PM, Dev, QA, and Engineering Director execute through local CLI runtimes while humans retain approval authority at phase and completion gates.",
+    "interface_guidance": "Document the governed operator boundary: which local CLI runtimes are expected, how prompts are delivered, and which approvals remain human-gated even though all core roles are automated.",
+    "behavior_guidance": "Explain the dispatch rhythm for authoritative local CLI turns, the clean-working-tree requirement between accepted automated turns, and how injected intents or reissued turns change the next dispatch charter.",
+    "error_cases_guidance": "Call out weak authority flags, stale runtime bindings, dirty-baseline failures, and post-dispatch drift as first-class operational risks for this template.",
+    "acceptance_tests_guidance": "- [ ] PM, Dev, QA, and Engineering Director all bind to authoritative local_cli runtimes\n- [ ] Human approval remains required for phase transitions and run completion\n- [ ] Operator docs include the clean-tree checkpoint rule between accepted automated turns\n- [ ] Connector validation confirms the downstream CLI authority mode is strong enough for unattended governed execution"
+  },
+  "prompt_overrides": {},
+  "acceptance_hints": [],
+  "scaffold_blueprint": {
+    "roles": {
+      "pm": {
+        "title": "Product Manager",
+        "mandate": "Protect user value, scope clarity, and acceptance criteria.",
+        "write_authority": "authoritative",
+        "runtime": "local-pm"
+      },
+      "dev": {
+        "title": "Developer",
+        "mandate": "Implement approved work safely and verify behavior.",
+        "write_authority": "authoritative",
+        "runtime": "local-dev"
+      },
+      "qa": {
+        "title": "QA",
+        "mandate": "Challenge correctness, acceptance coverage, and ship readiness.",
+        "write_authority": "authoritative",
+        "runtime": "local-qa"
+      },
+      "eng_director": {
+        "title": "Engineering Director",
+        "mandate": "Resolve tactical deadlocks and enforce technical coherence.",
+        "write_authority": "authoritative",
+        "runtime": "local-director"
+      }
+    },
+    "runtimes": {
+      "local-pm": {
+        "type": "local_cli",
+        "command": ["claude", "--print", "--dangerously-skip-permissions"],
+        "cwd": ".",
+        "prompt_transport": "stdin"
+      },
+      "local-dev": {
+        "type": "local_cli",
+        "command": ["claude", "--print", "--dangerously-skip-permissions"],
+        "cwd": ".",
+        "prompt_transport": "stdin"
+      },
+      "local-qa": {
+        "type": "local_cli",
+        "command": ["claude", "--print", "--dangerously-skip-permissions"],
+        "cwd": ".",
+        "prompt_transport": "stdin"
+      },
+      "local-director": {
+        "type": "local_cli",
+        "command": ["claude", "--print", "--dangerously-skip-permissions"],
+        "cwd": ".",
+        "prompt_transport": "stdin"
+      }
+    }
+  }
+}