@moretea-labs/forge 1.5.0-rc.1

package/src/runtime/execution/process-runtime/check-receipt.ts

@@ -0,0 +1,185 @@
+import { createHash } from 'crypto';
+import type {
+  ProcessCheckReceiptEvidence,
+  ProcessCheckReceiptStatus,
+} from '../../evidence/process-check-receipt';
+import type { ManagedProcessRecord, ProcessRuntimeStatus } from './types';
+
+export type { ProcessCheckReceiptEvidence, ProcessCheckReceiptStatus } from '../../evidence/process-check-receipt';
+
+export interface ProcessCheckReceiptExpectation {
+  repoId?: string;
+  checkoutId?: string;
+  workId?: string;
+  executionSessionId?: string;
+  editSessionId?: string;
+  editRevision?: number;
+  issueId?: string;
+  taskId?: string;
+  checkId?: string;
+  requestId?: string;
+  processId?: string;
+  /** Required to rebind a shared physical Check Process to another consumer. */
+  checkExecution?: {
+    cacheKey: string;
+    revision: string;
+    definitionDigest: string;
+    environmentFingerprint: string;
+    timeoutMs: number;
+    scopeKey: string;
+  };
+}
+
+export interface ProcessCheckCompletionReceipt extends ProcessCheckReceiptEvidence {
+  runtimeStatus: Extract<ProcessRuntimeStatus, 'succeeded' | 'failed' | 'timed_out' | 'cancelled'>;
+}
+
+function fail(code: string, message: string): never {
+  throw new Error(`${code}: ${message}`);
+}
+
+function artifactSlug(id: string): string {
+  return id.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'check';
+}
+
+export function processCheckArtifactPath(checkId: string): string {
+  return `.ai/harness/checks/controller/latest-${artifactSlug(checkId)}.json`;
+}
+
+function receiptStatus(status: ProcessRuntimeStatus): ProcessCheckReceiptStatus {
+  if (status === 'succeeded') return 'passed';
+  if (status === 'failed') return 'failed';
+  if (status === 'timed_out') return 'timed_out';
+  if (status === 'cancelled') return 'cancelled';
+  fail('PROCESS_CHECK_RECEIPT_NOT_TERMINAL', `process status ${status} is not an accepted terminal check result`);
+}
+
+function assertExpected(label: string, actual: unknown, expected: unknown): void {
+  if (expected === undefined) return;
+  if (actual !== expected) {
+    fail('PROCESS_CHECK_RECEIPT_IDENTITY_MISMATCH', `${label} expected ${String(expected)} but received ${String(actual)}`);
+  }
+}
+
+function stableDigest(value: Record<string, unknown>): string {
+  return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+
+/**
+ * Normalize one persisted Process Runtime record into the single authoritative
+ * check completion receipt consumed by Edit Sessions, Work validation and Tasks.
+ */
+export function processCheckCompletionReceipt(
+  record: ManagedProcessRecord,
+  expected: ProcessCheckReceiptExpectation = {},
+): ProcessCheckCompletionReceipt {
+  if (record.origin?.surface !== 'check' || !record.origin.checkId?.trim()) {
+    fail('PROCESS_CHECK_RECEIPT_NOT_CHECK', `process ${record.processId} is not a bound check process`);
+  }
+  const status = receiptStatus(record.status);
+  const contradictoryTerminal =
+    (status === 'passed' && (record.exitCode !== 0 || record.timedOut === true || record.cancelled === true))
+    || (status === 'failed' && (record.exitCode === 0 || record.timedOut === true || record.cancelled === true))
+    || (status === 'timed_out' && record.timedOut !== true)
+    || (status === 'cancelled' && record.cancelled !== true);
+  if (contradictoryTerminal) {
+    fail(
+      'PROCESS_CHECK_RECEIPT_STATUS_CONTRADICTION',
+      `process ${record.processId} status ${record.status} contradicts exitCode/timedOut/cancelled terminal fields`,
+    );
+  }
+  if (!record.finishedAt) {
+    fail('PROCESS_CHECK_RECEIPT_INCOMPLETE', `process ${record.processId} has no finishedAt timestamp`);
+  }
+  const checkId = record.origin.checkId.trim();
+  const semanticRebind = expected.checkExecution !== undefined;
+  assertExpected('repoId', record.repoId, expected.repoId);
+  assertExpected('checkId', checkId, expected.checkId);
+  assertExpected('processId', record.processId, expected.processId);
+  if (semanticRebind) {
+    const physical = record.checkExecution;
+    if (!physical) {
+      fail('PROCESS_CHECK_RECEIPT_REUSE_IDENTITY_MISSING', `process ${record.processId} has no semantic Check execution identity`);
+    }
+    assertExpected('check cacheKey', physical.cacheKey, expected.checkExecution!.cacheKey);
+    assertExpected('check revision', physical.revision, expected.checkExecution!.revision);
+    assertExpected('check definitionDigest', physical.definitionDigest, expected.checkExecution!.definitionDigest);
+    assertExpected('check environmentFingerprint', physical.environmentFingerprint, expected.checkExecution!.environmentFingerprint);
+    assertExpected('check timeoutMs', physical.timeoutMs, expected.checkExecution!.timeoutMs);
+    assertExpected('check scopeKey', physical.scopeKey, expected.checkExecution!.scopeKey);
+    if (physical.reuseScope === 'checkout') {
+      assertExpected('checkout-scoped receipt checkoutId', record.checkoutId, expected.checkoutId);
+    }
+  } else {
+    assertExpected('checkoutId', record.checkoutId, expected.checkoutId);
+    assertExpected('workId', record.workId, expected.workId);
+    assertExpected('executionSessionId', record.origin.executionSessionId, expected.executionSessionId);
+    assertExpected('editSessionId', record.origin.editSessionId, expected.editSessionId);
+    assertExpected('editRevision', record.origin.editRevision, expected.editRevision);
+    assertExpected('issueId', record.origin.issueId, expected.issueId);
+    assertExpected('taskId', record.origin.taskId, expected.taskId);
+    assertExpected('requestId', record.origin.requestId, expected.requestId);
+  }
+
+  const consumerCheckoutId = semanticRebind ? expected.checkoutId ?? record.checkoutId : record.checkoutId;
+  const consumerWorkId = semanticRebind ? expected.workId : record.workId;
+  const consumerExecutionSessionId = semanticRebind ? expected.executionSessionId : record.origin.executionSessionId;
+  const consumerEditSessionId = semanticRebind ? expected.editSessionId : record.origin.editSessionId;
+  const consumerEditRevision = semanticRebind ? expected.editRevision : record.origin.editRevision;
+  const consumerIssueId = semanticRebind ? expected.issueId : record.origin.issueId;
+  const consumerTaskId = semanticRebind ? expected.taskId : record.origin.taskId;
+  const consumerRequestId = semanticRebind ? expected.requestId : record.origin.requestId;
+  const reusedExecution = semanticRebind && (
+    consumerCheckoutId !== record.checkoutId
+    || consumerWorkId !== record.workId
+    || consumerExecutionSessionId !== record.origin.executionSessionId
+    || consumerEditSessionId !== record.origin.editSessionId
+    || consumerEditRevision !== record.origin.editRevision
+    || consumerIssueId !== record.origin.issueId
+    || consumerTaskId !== record.origin.taskId
+    || consumerRequestId !== record.origin.requestId
+  );
+
+  const ok = status === 'passed';
+  const summaryTail = (record.stderrTail || record.stdoutTail || '').trim().slice(-500);
+  const summary = ok
+    ? `Passed with persisted Process evidence: ${record.processId}${reusedExecution ? ' (shared semantic Check execution)' : ''}`
+    : `${status === 'timed_out' ? 'Timed out' : status === 'cancelled' ? 'Cancelled' : 'Failed'} with persisted Process evidence: ${record.processId}${summaryTail ? `; ${summaryTail}` : ''}`;
+  const stable = {
+    schemaVersion: 1,
+    repoId: record.repoId,
+    checkoutId: consumerCheckoutId,
+    workId: consumerWorkId,
+    executionSessionId: consumerExecutionSessionId,
+    editSessionId: consumerEditSessionId,
+    editRevision: consumerEditRevision,
+    issueId: consumerIssueId,
+    taskId: consumerTaskId,
+    checkId,
+    requestId: consumerRequestId,
+    processId: record.processId,
+    commandId: record.commandId,
+    sourceCheckoutId: record.checkoutId,
+    checkCacheKey: record.checkExecution?.cacheKey,
+    checkRevision: record.checkExecution?.revision,
+    checkDefinitionDigest: record.checkExecution?.definitionDigest,
+    checkEnvironmentFingerprint: record.checkExecution?.environmentFingerprint,
+    reusedExecution,
+    status,
+    runtimeStatus: record.status as ProcessCheckCompletionReceipt['runtimeStatus'],
+    ok,
+    exitCode: record.exitCode,
+    timedOut: status === 'timed_out' || record.timedOut === true,
+    cancelled: status === 'cancelled' || record.cancelled === true,
+    artifactPath: processCheckArtifactPath(checkId),
+    summary,
+    startedAt: record.startedAt,
+    finishedAt: record.finishedAt,
+  } satisfies Omit<ProcessCheckCompletionReceipt, 'receiptId' | 'resultDigest'>;
+  const resultDigest = stableDigest(stable);
+  return {
+    ...stable,
+    resultDigest,
+    receiptId: `check_receipt_${resultDigest.slice(0, 24)}`,
+  };
+}

package/src/runtime/execution/process-runtime/check-runner-sidecar.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env bun
+import { createHash } from 'crypto';
+import { resolve } from 'path';
+import {
+  runControllerCheck,
+  snapshotControllerCheck,
+} from '../../../cli/controller/check-runner';
+
+interface ParsedArgs {
+  repo: string;
+  checkId: string;
+  timeoutMs?: number;
+  expectedCheckFingerprint: string;
+}
+
+function requiredValue(argv: string[], flag: string): string {
+  const index = argv.indexOf(flag);
+  const value = index >= 0 ? argv[index + 1]?.trim() : undefined;
+  if (!value) throw new Error(`PERSISTED_CHECK_USAGE: missing ${flag}`);
+  return value;
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  const timeoutRaw = argv.includes('--timeout-ms') ? requiredValue(argv, '--timeout-ms') : undefined;
+  const timeoutMs = timeoutRaw === undefined ? undefined : Number(timeoutRaw);
+  if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+    throw new Error('PERSISTED_CHECK_USAGE: invalid --timeout-ms');
+  }
+  return {
+    repo: requiredValue(argv, '--repo'),
+    checkId: requiredValue(argv, '--check-id'),
+    timeoutMs,
+    expectedCheckFingerprint: requiredValue(argv, '--expected-check-fingerprint'),
+  };
+}
+
+export function runPersistedCheckSidecar(argv = process.argv.slice(2)): number {
+  const args = parseArgs(argv);
+  const root = resolve(args.repo);
+  const snapshot = snapshotControllerCheck(root, args.checkId);
+  const actualFingerprint = createHash('sha256').update(JSON.stringify(snapshot)).digest('hex');
+  if (actualFingerprint !== args.expectedCheckFingerprint) {
+    throw new Error('CHECK_SNAPSHOT_CHANGED: registered check changed before Process Runtime execution');
+  }
+  const result = runControllerCheck(root, args.checkId, args.timeoutMs, snapshot);
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr.endsWith('\n') ? result.stderr : `${result.stderr}\n`);
+  return result.ok ? 0 : Math.max(1, result.status || 1);
+}
+
+const direct = typeof process.argv[1] === 'string'
+  && (process.argv[1].includes('check-runner-sidecar') || process.argv[1].endsWith('/forge-check-runner'));
+if (direct) {
+  try {
+    process.exitCode = runPersistedCheckSidecar();
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

package/src/runtime/execution/process-runtime/command-facade.ts

@@ -0,0 +1,321 @@
+/**
+ * repository_command_execute → Unified Process Runtime.
+ *
+ * Short readonly / focused commands: Direct (wait briefly, return result).
+ * Longer local build/test: Managed (same spawn, return handle).
+ * release / remote / non-idempotent: Durable (caller keeps ExecutionJob path).
+ */
+
+import type { RepositoryRecord } from '../../../cli/repositories/types';
+import { classifyRepositoryCommand } from '../../../cli/repositories/command-classifier';
+import {
+  executeRepositoryCommandAsync,
+  executeRepositoryReadOnlyCommandDirect,
+  type RepositoryCommandExecution,
+} from '../../../cli/repositories/command-executor';
+import { normalizeRepositoryCommand } from '../../../cli/repositories/command-normalization';
+import { claimsForRepositoryCommand, scopeResourceClaims, toProcessClaims } from './resource-claims';
+import {
+  spawnManagedProcess,
+  getProcessHandle,
+  waitForProcess,
+  cancelProcess,
+  readProcessLogs,
+} from './runtime';
+import type { ProcessHandle, ProcessCommandSpec } from './types';
+import { DEFAULT_INTERACTIVE_WAIT_MS } from './types';
+import { durationAwareInteractiveWaitMs } from './interactive-admission';
+import { isFocusedCheckCommand } from '../thin-harness/execution-router';
+import { assertExecutionIdentity, type ResolvedExecutionIdentity } from '../../control-plane/execution/execution-identity';
+
+export type RepositoryCommandRoute =
+  | 'process_direct'
+  | 'process_managed'
+  | 'durable'
+  | 'reject';
+
+export interface RepositoryCommandProcessInput {
+  controllerHome: string;
+  repository: RepositoryRecord;
+  command: string | readonly string[];
+  cwd?: string;
+  timeoutMs?: number;
+  interactiveWaitMs?: number;
+  maxOutputBytes?: number;
+  /** Force durable workflow (async apply, release, remote). */
+  forceDurable?: boolean;
+  requestId?: string;
+  workId?: string;
+  commandId?: string;
+  signal?: AbortSignal;
+  /** Explicit unregistered local workspace authority; never inferred from cwd. */
+  allowNonGitWorkspace?: boolean;
+  /** Immutable resolved identity — required; never inferred from main/active/cwd. */
+  executionIdentity: ResolvedExecutionIdentity;
+}
+
+export interface RepositoryCommandProcessResult {
+  route: RepositoryCommandRoute;
+  reason?: string;
+  process?: ProcessHandle;
+  /** Present for completed direct/managed handles. */
+  ok?: boolean;
+  exitCode?: number;
+  stdout?: string;
+  stderr?: string;
+  executionStatus?: RepositoryCommandExecution['status'];
+  policyDecision?: RepositoryCommandExecution['policyDecision'];
+  authorizationDecision?: RepositoryCommandExecution['authorizationDecision'];
+  approvalRequestId?: string;
+  durableSideEffects: {
+    executionJobCount: number;
+    localJobCount: number;
+    workerSpawnCount: number;
+    projectionUpdateCount: number;
+  };
+  suggestedOperation?: string;
+}
+
+const emptyEffects = {
+  executionJobCount: 0,
+  localJobCount: 0,
+  workerSpawnCount: 0,
+  projectionUpdateCount: 0,
+};
+
+function toProcessCommand(command: string | readonly string[], cwd: string): ProcessCommandSpec {
+  const normalized = normalizeRepositoryCommand(command);
+  if (normalized.kind === 'argv') {
+    return {
+      kind: 'argv',
+      executable: normalized.executable,
+      args: [...(normalized.args ?? [])],
+      cwd,
+    };
+  }
+  return {
+    kind: 'shell',
+    shellCommand: normalized.shellCommand ?? String(command),
+    cwd,
+  };
+}
+
+/**
+ * Decide Direct / Managed / Durable without spawning.
+ */
+export function classifyRepositoryCommandRoute(
+  command: string | readonly string[],
+  options: {
+    forceDurable?: boolean;
+    defaultBranch?: string;
+    timeoutMs?: number;
+  } = {},
+): { route: RepositoryCommandRoute; reason: string } {
+  if (options.forceDurable) {
+    return { route: 'durable', reason: 'force_durable_or_async' };
+  }
+  const classification = classifyRepositoryCommand(command, options.defaultBranch);
+  // ExecutionJobs are retired. Authorized local destructive/remote-risk commands
+  // still execute through Process Runtime; SuperController owns retry/replay policy.
+  if (classification.risk === 'remote_write' || classification.risk === 'destructive') {
+    return {
+      route: 'process_managed',
+      reason: `risk_${classification.risk}_via_process_runtime`,
+    };
+  }
+  // release / rollback style commands
+  const text = Array.isArray(command) ? command.join(' ') : String(command);
+  if (/\b(?:gh\s+release\s+(?:create|delete|edit|upload)|git\s+push|npm\s+publish)\b/i.test(text)) {
+    return { route: 'durable', reason: 'release_or_remote_mutation' };
+  }
+  if (classification.risk === 'readonly') {
+    // Short readonly → direct. Only an *explicit* long timeout upgrades to managed.
+    if (typeof options.timeoutMs === 'number' && options.timeoutMs > 30_000) {
+      return { route: 'process_managed', reason: 'readonly_long_timeout' };
+    }
+    return { route: 'process_direct', reason: 'readonly_fast_path' };
+  }
+  // workspace_write / build-test
+  if (isFocusedCheckCommand(command) || /\b(?:test|typecheck|lint|build|check)\b/i.test(text)) {
+    return { route: 'process_managed', reason: 'local_build_or_test' };
+  }
+  // Unknown mutating local command remains one local Managed Process. Timeout is
+  // a process lifecycle budget and must never select a different architecture.
+  return { route: 'process_managed', reason: 'local_workspace_mutation' };
+}
+
+/**
+ * Execute via Unified Process Runtime when route is process_*.
+ * Does not create ExecutionJob / LocalJob / Worker.
+ */
+export async function executeRepositoryCommandViaProcessRuntime(
+  input: RepositoryCommandProcessInput,
+): Promise<RepositoryCommandProcessResult> {
+  const decision = classifyRepositoryCommandRoute(input.command, {
+    forceDurable: input.forceDurable,
+    defaultBranch: input.repository.defaultBranch,
+    timeoutMs: input.timeoutMs,
+  });
+
+  if (decision.route === 'durable' || decision.route === 'reject') {
+    return {
+      route: decision.route,
+      reason: decision.reason,
+      durableSideEffects: emptyEffects,
+      suggestedOperation: 'repository_command_execute via Durable Work / Local Job',
+    };
+  }
+
+  if (!input.executionIdentity) {
+    throw new Error('EXECUTION_IDENTITY_REQUIRED: repository command process path requires an immutable executionIdentity');
+  }
+  const executionIdentity = input.executionIdentity;
+  if (executionIdentity.repositoryId !== input.repository.repoId) {
+    throw new Error(
+      `EXECUTION_IDENTITY_MISMATCH: repository ${input.repository.repoId} differs from identity ${executionIdentity.repositoryId}`,
+    );
+  }
+  if (executionIdentity.checkoutId !== input.repository.activeCheckoutId) {
+    throw new Error(
+      `CHECKOUT_ROUTE_MISMATCH: repository checkout ${input.repository.activeCheckoutId} differs from identity ${executionIdentity.checkoutId}`,
+    );
+  }
+  const cwd = input.cwd?.trim() || executionIdentity.canonicalRoot;
+  if (!cwd) {
+    return {
+      route: 'reject',
+      reason: 'missing_repository_cwd',
+      durableSideEffects: emptyEffects,
+    };
+  }
+
+  // A short readonly command owns no durable Process/Lease state. Validate the
+  // same immutable repository identity first, then execute with the bounded
+  // non-persistent reader. This keeps reads available while a stale/passive
+  // Runtime remains correctly fenced from Controller writes.
+  const canonicalCommand = normalizeRepositoryCommand(input.command);
+  if (decision.route === 'process_direct' && canonicalCommand.kind === 'argv') {
+    assertExecutionIdentity({
+      controllerHome: input.controllerHome,
+      identity: executionIdentity,
+      cwd,
+      requestedRepoId: input.repository.repoId,
+      requestedCheckoutId: input.repository.activeCheckoutId,
+    });
+    const direct = await executeRepositoryReadOnlyCommandDirect(input.repository, {
+      command: input.command,
+      cwd: input.cwd,
+      timeoutMs: Math.min(input.timeoutMs ?? 30_000, 30_000),
+      maxOutputBytes: input.maxOutputBytes,
+      signal: input.signal,
+      allowNonGitWorkspace: executionIdentity.authority === 'ephemeral_workspace',
+    });
+    return {
+      route: 'process_direct',
+      reason: decision.reason,
+      ok: direct.ok,
+      exitCode: direct.exitCode,
+      stdout: direct.stdout,
+      stderr: direct.stderr,
+      executionStatus: direct.status,
+      policyDecision: direct.policyDecision,
+      authorizationDecision: direct.authorizationDecision,
+      approvalRequestId: direct.approvalRequestId,
+      durableSideEffects: emptyEffects,
+    };
+  }
+
+  // An explicitly resolved ephemeral workspace has no canonical Runtime-owned
+  // Process storage. Keep its bounded local source edits on the same direct
+  // executor used for bounded reads instead of manufacturing a Process lease
+  // that a separate Runtime authority can fence. Unknown commands remain
+  // conservatively classified/authorized by the command executor; durable,
+  // remote, and destructive routes never reach this branch.
+  if (executionIdentity.authority === 'ephemeral_workspace' && input.allowNonGitWorkspace === true) {
+    const direct = await executeRepositoryCommandAsync(input.controllerHome, input.repository, {
+      command: input.command,
+      cwd: input.cwd,
+      timeoutMs: Math.min(input.timeoutMs ?? 30_000, 30_000),
+      maxOutputBytes: input.maxOutputBytes,
+      signal: input.signal,
+      allowNonGitWorkspace: true,
+    });
+    return {
+      route: 'process_direct',
+      reason: 'ephemeral_workspace_bounded_direct',
+      ok: direct.ok,
+      exitCode: direct.exitCode,
+      stdout: direct.stdout,
+      stderr: direct.stderr,
+      executionStatus: direct.status,
+      policyDecision: direct.policyDecision,
+      authorizationDecision: direct.authorizationDecision,
+      approvalRequestId: direct.approvalRequestId,
+      durableSideEffects: emptyEffects,
+    };
+  }
+
+  const interactiveWaitMs = durationAwareInteractiveWaitMs(
+    input.command,
+    input.interactiveWaitMs,
+    Math.min(DEFAULT_INTERACTIVE_WAIT_MS, 250),
+  );
+  const timeoutMs = Math.max(
+    interactiveWaitMs + 1,
+    Math.min(input.timeoutMs ?? 15 * 60_000, 24 * 60 * 60_000),
+  );
+
+  const claims = scopeResourceClaims(
+    claimsForRepositoryCommand(
+      input.command,
+      executionIdentity.repositoryId,
+      executionIdentity.checkoutId,
+      input.repository.defaultBranch,
+    ),
+    executionIdentity.repositoryId,
+    executionIdentity.checkoutId,
+    input.workId,
+  );
+
+  const handle = await spawnManagedProcess({
+    controllerHome: input.controllerHome,
+    repoId: executionIdentity.repositoryId,
+    checkoutId: executionIdentity.checkoutId,
+    executionIdentity,
+    workId: input.workId,
+    commandId: input.commandId,
+    command: toProcessCommand(input.command, cwd),
+    // Short commands complete inside this budget; longer ones return a running handle.
+    interactiveWaitMs,
+    timeoutMs,
+    maxOutputBytes: input.maxOutputBytes,
+    resourceClaims: toProcessClaims(claims),
+    origin: {
+      surface: 'command',
+      toolName: 'repository_command_execute',
+      requestId: input.requestId,
+      correlationId: input.workId,
+    },
+    signal: input.signal,
+    returnHandleImmediately: input.forceDurable === true,
+  });
+
+  const route: RepositoryCommandRoute = handle.completed ? 'process_direct' : 'process_managed';
+  return {
+    route,
+    reason: decision.reason,
+    process: handle,
+    ok: handle.ok,
+    exitCode: handle.exitCode,
+    stdout: handle.stdout,
+    stderr: handle.stderr,
+    durableSideEffects: handle.durableSideEffects,
+  };
+}
+
+export {
+  getProcessHandle as getRepositoryCommandProcess,
+  waitForProcess as waitRepositoryCommandProcess,
+  cancelProcess as cancelRepositoryCommandProcess,
+  readProcessLogs as readRepositoryCommandProcessLogs,
+};