chati-dev 4.5.15 → 4.5.27

package/src/terminal/run-rail-task.js

@@ -0,0 +1,380 @@
+#!/usr/bin/env node
+
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { resolve } from 'node:path';
+import {
+  buildSpawnCommand, getTerminalCompletionAuthorityReceipt,
+  getTerminalLaunchAuthorityReceipt, isTransientFailure, killTerminal, spawnTerminal, waitForTerminal,
+} from './spawner.js';
+import { checkProviderReadiness } from './provider-preflight.js';
+import { getRateLimiter } from './rate-limiter.js';
+import {
+  dispatchReadyRailTask, heartbeatRailTask, loadRailHandoff, recordRailExecutionEvidence,
+  relinquishRailTask, resolveRailAttemptContext,
+} from '../orchestrator/rail-runtime.js';
+import { parseRailExecutionEnvelope } from '../orchestrator/rail-execution-evidence.js';
+import {
+  loadRuntimeInstallationV2, resolveRuntimeExecutableBindingV2,
+} from '../orchestrator/runtime-installation-v2.js';
+export { buildRailTaskPrompt } from './rail-prompts.js';
+
+function fail(code, message, details = {}) {
+  const error = new Error(message);
+  error.code = code;
+  error.details = details;
+  throw error;
+}
+
+function exactTask({ projectDir, handoff_id, task_id }) {
+  const stored = loadRailHandoff({ projectDir, handoff_id });
+  const task = stored.handoff.tasks.find((candidate) => candidate.task_id === task_id);
+  if (!task) fail('TASK_NOT_FOUND', `task ${task_id} is not part of sealed handoff ${handoff_id}`);
+  return Object.freeze({ stored, task });
+}
+
+function terminalConfig({
+  projectDir, task, invocation, prompt, timeout, providerExecutableBinding, baseCommitRef,
+}) {
+  return Object.freeze({
+    agent: 'rail',
+    taskId: task.task_id,
+    provider: invocation.harness_id,
+    providerId: invocation.provider_id,
+    model: invocation.model_pin.model_id,
+    reasoningConfiguration: invocation.model_pin.reasoning_configuration,
+    catalogSnapshotRef: invocation.model_pin.catalog_snapshot_ref,
+    providerExecutableBinding,
+    prompt,
+    workingDir: projectDir,
+    executionBaseCommitRef: baseCommitRef,
+    timeout,
+    writeScope: ['.'],
+    authorityContext: {
+      authority_kind: 'rail_execution',
+      invocation_id: invocation.invocation_id,
+      launch_nonce: invocation.launch_nonce,
+      provider_id: invocation.provider_id,
+    },
+  });
+}
+
+function assertExactTerminalRoute(config) {
+  const built = buildSpawnCommand(config);
+  if (built.actualProvider !== config.provider
+    || built.actualModel !== config.model
+    || built.actualReasoningConfiguration !== config.reasoningConfiguration) {
+    fail('RAIL_TERMINAL_ROUTE_MISMATCH', 'terminal adapter changed the sealed RAIL execution binding', {
+      expected: { provider: config.provider, model: config.model, reasoning_configuration: config.reasoningConfiguration },
+      actual: { provider: built.actualProvider, model: built.actualModel, reasoning_configuration: built.actualReasoningConfiguration },
+    });
+  }
+  return built;
+}
+
+function terminalEvidence(handle) {
+  const stdout = (handle.stdout || []).join('');
+  const stderr = (handle.stderr || []).join('');
+  // The journal has a stricter record limit than the terminal authority
+  // capture. Reject oversized RAIL output instead of truncating it: a
+  // truncated transcript cannot be cryptographically bound to the signed
+  // completion receipt.
+  if (Buffer.byteLength(stdout) > 1_000_000 || Buffer.byteLength(stderr) > 100_000) {
+    fail('RAIL_EXECUTION_OUTPUT_TOO_LARGE', 'RAIL terminal output exceeds the journal-bound evidence limit');
+  }
+  return Object.freeze({
+    terminal_id: handle.id,
+    provider: handle.provider,
+    model: handle.model,
+    reasoning_configuration: handle.reasoningConfiguration,
+    exit_status: handle.exitCode,
+    retry_count: handle.retryCount || 0,
+    started_at: handle.startedAt,
+    stdout,
+    stderr,
+    terminal_authority_receipt: getTerminalCompletionAuthorityReceipt(handle),
+  });
+}
+
+export function startClaimHeartbeat({ projectDir, handoff_id, attempt_id, claim_id, operator_id, lease_ttl_ms, initial_lease, activeHandle }) {
+  const intervalMs = Math.max(25, Math.min(60_000, Math.floor(lease_ttl_ms / 3)));
+  let heartbeatCount = 0;
+  let contentionCount = 0;
+  let latestLease = initial_lease;
+  let failure = null;
+  const timer = setInterval(() => {
+    if (failure) return;
+    try {
+      const heartbeat = heartbeatRailTask({
+        projectDir, handoff_id, attempt_id, claim_id, operator_id, lease_ttl_ms,
+      });
+      heartbeatCount += 1;
+      latestLease = heartbeat.lease;
+    } catch (error) {
+      if (error?.code === 'JOURNAL_LOCK_BUSY' && Date.now() < Date.parse(latestLease.expires_at)) {
+        contentionCount += 1;
+        return;
+      }
+      failure = error;
+      const handle = activeHandle();
+      if (handle?.process && handle.status === 'running') handle.process.kill('SIGTERM');
+    }
+  }, intervalMs);
+  timer.unref?.();
+  return Object.freeze({
+    stop() { clearInterval(timer); },
+    evidence() {
+      return Object.freeze({
+        heartbeat_count: heartbeatCount,
+        contention_count: contentionCount,
+        latest_lease: latestLease,
+        failure,
+      });
+    },
+  });
+}
+
+/**
+ * Production RAIL boundary. It atomically claims dependency-ready work through
+ * dispatchReadyRailTask and starts the exact selected CLI binding from inside
+ * the injected adapter. Retries reuse that same binding and never downgrade.
+ */
+export async function executeReadyRailTask({
+  projectDir,
+  handoff_id,
+  task_id,
+  attempt_id = `attempt-${randomUUID()}`,
+  operator_id = 'operator://chati/runtime',
+  browser_request,
+  git_dir = projectDir,
+  lease_ttl_ms,
+  recover_expired = false,
+  timeout = 30 * 60 * 1000,
+  max_retries = 2,
+} = {}) {
+  if (!projectDir || !handoff_id || !task_id) fail('RAIL_DISPATCH_INPUT_REQUIRED', 'projectDir, handoff_id and task_id are required');
+  const { stored, task } = exactTask({ projectDir, handoff_id, task_id });
+  const binding = task.execution_binding;
+  const providerExecutableBinding = resolveRuntimeExecutableBindingV2({
+    artifact: loadRuntimeInstallationV2(projectDir),
+    provider_id: binding.provider_id,
+    harness_id: binding.harness_id,
+  });
+  const readiness = checkProviderReadiness(binding.harness_id, {
+    workingDir: projectDir, executableBinding: providerExecutableBinding,
+  });
+  if (!readiness.ready) fail(readiness.code || 'PROVIDER_NOT_READY', readiness.detail || `${binding.harness_id} is not ready`);
+
+  let handle = null;
+  let exactConfig = null;
+  const adapter = Object.freeze({
+    harness_id: binding.harness_id,
+    invoke({ invocation, prompt, reserve_launch }) {
+      exactConfig = Object.freeze({
+        ...terminalConfig({
+          projectDir, task, invocation, prompt, timeout, providerExecutableBinding,
+          baseCommitRef: stored.handoff.seal.git_commit_ref,
+        }),
+        beforeAuthoritySpawn: reserve_launch,
+      });
+      assertExactTerminalRoute(exactConfig);
+      handle = spawnTerminal(exactConfig);
+      return getTerminalLaunchAuthorityReceipt(handle);
+    },
+  });
+
+  await getRateLimiter(binding.harness_id).waitForSlot();
+  const effectiveLeaseTtlMs = lease_ttl_ms ?? 5 * 60 * 1000;
+  let dispatch;
+  try {
+    dispatch = dispatchReadyRailTask({
+      projectDir, handoff_id, task_id, attempt_id, operator_id,
+      adapter, browser_request, git_dir, lease_ttl_ms: effectiveLeaseTtlMs,
+      recover_expired,
+    });
+  } catch (error) {
+    if (handle) await killTerminal(handle);
+    throw error;
+  }
+  if (!handle || !exactConfig) fail('RAIL_EXECUTION_NOT_STARTED', 'RAIL adapter did not start the selected harness');
+
+  const heartbeat = startClaimHeartbeat({
+    projectDir,
+    handoff_id,
+    attempt_id,
+    claim_id: dispatch.claim.claim.claim_id,
+    operator_id,
+    lease_ttl_ms: effectiveLeaseTtlMs,
+    initial_lease: dispatch.claim.claim.lease,
+    activeHandle: () => handle,
+  });
+  let claimRelinquished = false;
+  const relinquishClaim = (reason) => {
+    if (claimRelinquished) return null;
+    const relinquished = relinquishRailTask({
+      projectDir, handoff_id, attempt_id,
+      claim_id: dispatch.claim.claim.claim_id,
+      operator_id,
+      reason,
+    });
+    claimRelinquished = true;
+    return relinquished;
+  };
+  try {
+  let retries = 0;
+  const failedAttemptRefs = [];
+  const recordFailedAttempt = () => {
+    handle.retryCount = retries;
+    const failedExecution = terminalEvidence(handle);
+    const persisted = recordRailExecutionEvidence({
+      projectDir, handoff_id, task_id, attempt_id,
+      invocation: dispatch.invocation,
+      execution: failedExecution,
+      base_commit_ref: dispatch.claim.attempt.git_commit_ref,
+      result_commit_ref: null,
+    });
+    failedAttemptRefs.push(persisted.evidence_ref);
+  };
+  try {
+    await waitForTerminal(handle);
+    while (handle.exitCode !== 0 && retries < max_retries && isTransientFailure(handle.exitCode, [...handle.stdout, ...handle.stderr])) {
+      if (heartbeat.evidence().failure) break;
+      recordFailedAttempt();
+      retries += 1;
+      await new Promise((resolveDelay) => setTimeout(resolveDelay, 2_000 * (2 ** (retries - 1))));
+      if (heartbeat.evidence().failure) break;
+      await getRateLimiter(binding.harness_id).waitForSlot();
+      try {
+        dispatch = dispatchReadyRailTask({
+          projectDir, handoff_id, task_id, attempt_id, operator_id,
+          adapter, browser_request, git_dir, lease_ttl_ms: effectiveLeaseTtlMs,
+        });
+      } catch (error) {
+        if (handle) await killTerminal(handle);
+        throw error;
+      }
+      await waitForTerminal(handle);
+    }
+  } finally {
+    heartbeat.stop();
+  }
+  const heartbeatEvidence = heartbeat.evidence();
+  if (heartbeatEvidence.failure) fail(
+    'RAIL_LEASE_HEARTBEAT_FAILED',
+    'RAIL execution lost its claim lease heartbeat and was stopped for reconciliation',
+    { cause_code: heartbeatEvidence.failure.code, cause: heartbeatEvidence.failure.message },
+  );
+  handle.retryCount = retries;
+  const execution = terminalEvidence(handle);
+  const base_commit_ref = dispatch.claim.attempt.git_commit_ref;
+  const invalidOutput = execution.terminal_authority_receipt.execution_result_status === 'invalid_output';
+  const envelope = execution.exit_status === 0 && !invalidOutput
+    ? parseRailExecutionEnvelope((handle.stdout || []).join(''))
+    : null;
+  if (envelope && envelope.launch_nonce !== dispatch.invocation.launch_nonce) {
+    fail('RAIL_EXECUTION_LAUNCH_NONCE_MISMATCH', 'execution output does not echo the canonical launch nonce');
+  }
+  const result_commit_ref = envelope?.result_commit_ref ?? null;
+  const persistedExecution = recordRailExecutionEvidence({
+    projectDir,
+    handoff_id,
+    task_id,
+    attempt_id,
+    invocation: dispatch.invocation,
+    execution,
+    base_commit_ref,
+    result_commit_ref,
+  });
+  const executionSucceeded = persistedExecution.outcome === 'succeeded';
+  const relinquished = relinquishClaim(executionSucceeded ? 'action_complete' : 'execution_failed');
+  if (!executionSucceeded && execution.exit_status === 0) {
+    fail(
+      persistedExecution.failure_code || 'RAIL_EXECUTION_OUTPUT_INVALID',
+      'RAIL execution completed without a valid canonical result commit',
+      { execution_evidence_ref: persistedExecution.evidence_ref },
+    );
+  }
+  return Object.freeze({
+    ok: executionSucceeded,
+    action: executionSucceeded ? 'rail_task_executed' : 'rail_task_execution_failed',
+    handoff_id,
+    task_id,
+    attempt_id,
+    claim: dispatch.claim,
+    resumed: dispatch.resumed,
+    invocation: dispatch.invocation,
+    launch_receipt: dispatch.receipt,
+    execution,
+    base_commit_ref,
+    result_commit_ref,
+    execution_evidence_ref: persistedExecution.evidence_ref,
+    failed_execution_evidence_refs: Object.freeze(failedAttemptRefs),
+    lease_heartbeat_count: heartbeatEvidence.heartbeat_count,
+    lease_contention_count: heartbeatEvidence.contention_count,
+    latest_lease: relinquished?.lease ?? heartbeatEvidence.latest_lease ?? dispatch.claim.claim.lease,
+    browser_manifest: dispatch.browser_manifest,
+    next_required_action: executionSucceeded ? 'independent_review' : 'rail_recover_same_attempt_after_lease_expiry',
+  });
+  } catch (error) {
+    try {
+      relinquishClaim('supervisor_error');
+    } catch (relinquishError) {
+      error.relinquish_error = {
+        code: relinquishError.code || 'RAIL_RELINQUISH_FAILED',
+        message: relinquishError.message,
+      };
+    }
+    throw error;
+  }
+}
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 2; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) continue;
+    const value = argv[index + 1];
+    if (value && !value.startsWith('--')) { args[token.slice(2)] = value; index += 1; }
+    else args[token.slice(2)] = true;
+  }
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  const attemptId = args['attempt-id'] || `attempt-${randomUUID()}`;
+  const projectDir = resolve(args['project-dir'] || process.cwd());
+  try {
+    const result = await executeReadyRailTask({
+      projectDir,
+      handoff_id: args['handoff-id'],
+      task_id: args['task-id'],
+      attempt_id: attemptId,
+      ...(args['operator-id'] ? { operator_id: args['operator-id'] } : {}),
+      ...(args.timeout ? { timeout: Number(args.timeout) } : {}),
+    });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    if (!result.ok) process.exitCode = 1;
+  } catch (error) {
+    let nextRequiredAction = 'rail_retry_same_attempt';
+    try {
+      resolveRailAttemptContext({ projectDir, handoff_id: args['handoff-id'], attempt_id: attemptId });
+      nextRequiredAction = 'rail_recover_same_attempt_after_lease_expiry';
+    } catch {
+      // No canonical claim exists, so the same attempt can be dispatched again.
+    }
+    process.stdout.write(`${JSON.stringify({
+      ok: false,
+      action: 'error',
+      code: error.code || 'RAIL_DISPATCH_FAILED',
+      error: error.message,
+      attempt_id: attemptId,
+      next_required_action: nextRequiredAction,
+    })}\n`);
+    process.exitCode = 1;
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
+  await main();
+}

package/src/terminal/run-team.js

@@ -27,6 +27,7 @@ import { collectResults, mergeHandoffs, buildConsolidatedHandoff } from './colle
 import { parseAgentOutput } from './handoff-parser.js';
 import { estimateTokens, COST_PER_1K } from './cost-tracker.js';
 import { getRateLimiter } from './rate-limiter.js';
+import { loadRuntimeInstallationV2 } from '../orchestrator/runtime-installation-v2.js';
 import {
   readTaskList, getTeamProgress, writeMailboxMessage, computeEchoSimilarity,
 } from './team-task-list.js';
@@ -85,6 +86,10 @@ async function main() {
   const teamId = args['team-id'];
   const teamType = args['team-type'];
   const projectDir = args['project-dir'] || process.cwd();
+  if (loadRuntimeInstallationV2(projectDir)) {
+    outputError('Runtime v2 uses individually signed planning commands and RAIL. The legacy native team runner is disabled.');
+    process.exit(1);
+  }
   const previousAgent = args['previous-agent'] || null;
   const provider = args.provider || null;
   const timeout = parseInt(args.timeout, 10) || 1_800_000; // default 30 minutes