@moretea-labs/forge 1.5.1 → 1.7.0

package/src/runtime/control-plane/goal-loop/types.ts

@@ -1,378 +0,0 @@
-/**
- * Autonomous Goal Loop contracts.
- *
- * GoalContract sits above Issue/Task: Issue/Task manage work items;
- * GoalContract owns objective-level durable loop state.
- *
- * Models are workers/reviewers/planners/handoff recipients.
- * Policy, audit, state, approval, verification, and finalization stay in forge.
- */
-
-export const GOAL_MODES = ['manual', 'supervised', 'autonomous'] as const;
-export type GoalMode = (typeof GOAL_MODES)[number];
-
-export const GOAL_STATUSES = [
-  'created',
-  'planning',
-  'ready',
-  'dispatching',
-  'running',
-  'verifying',
-  'repairing',
-  'waiting_for_user',
-  'handoff_ready',
-  'finalized',
-  'failed',
-  'stopped',
-] as const;
-export type GoalStatus = (typeof GOAL_STATUSES)[number];
-
-export const TERMINAL_GOAL_STATUSES: readonly GoalStatus[] = [
-  'finalized',
-  'failed',
-  'stopped',
-] as const;
-
-export const ACTIVE_GOAL_STATUSES: readonly GoalStatus[] = [
-  'created',
-  'planning',
-  'ready',
-  'dispatching',
-  'running',
-  'verifying',
-  'repairing',
-  'waiting_for_user',
-  'handoff_ready',
-] as const;
-
-export const PROVIDER_KINDS = [
-  'direct_edit',
-  'local_cli',
-  'remote_api',
-  'cloud_agent',
-  'handoff_only',
-] as const;
-export type ProviderKind = (typeof PROVIDER_KINDS)[number];
-
-export const MODEL_FAMILIES = [
-  'none',
-  'codex',
-  'claude',
-  'grok',
-  'deepseek',
-  'openai',
-  'github_copilot',
-  'chatgpt_handoff',
-] as const;
-export type ModelFamily = (typeof MODEL_FAMILIES)[number];
-
-export const PROVIDER_STATUSES = [
-  'ready',
-  'disabled',
-  'missing_auth',
-  'rate_limited',
-  'unavailable',
-  'failed_health_check',
-  'handoff_only',
-] as const;
-export type ProviderStatus = (typeof PROVIDER_STATUSES)[number];
-
-export const PROVIDER_CAPABILITIES = [
-  'code_patch',
-  'code_review',
-  'architecture_planning',
-  'long_context',
-  'structured_output',
-  'browser_planning',
-  'ios_log_analysis',
-  'test_failure_repair',
-  'tool_calling',
-  'local_file_mutation',
-  'remote_side_effects',
-] as const;
-export type ProviderCapability = (typeof PROVIDER_CAPABILITIES)[number];
-
-export const FAILURE_CLASSES = [
-  'source_defect',
-  'test_failure',
-  'typecheck_failure',
-  'merge_conflict',
-  'provider_unavailable',
-  'provider_rate_limited',
-  'missing_auth',
-  'policy_blocked',
-  'external_write_requires_approval',
-  'dirty_worktree',
-  'stale_runtime_projection',
-  'controller_restart_required',
-  'unknown',
-] as const;
-export type FailureClass = (typeof FAILURE_CLASSES)[number];
-
-export const APPROVAL_STATES = [
-  'approval_not_required',
-  'normal_authorization_required',
-  'strong_confirmation_required',
-  'blocked_by_policy',
-] as const;
-export type ApprovalState = (typeof APPROVAL_STATES)[number];
-
-export const TASK_INTENTS = [
-  'deterministic_edit',
-  'code_implementation',
-  'code_repair',
-  'architecture_planning',
-  'ios_build_or_sim',
-  'browser_automation',
-  'verification_repair',
-  'review',
-  'unknown',
-] as const;
-export type TaskIntent = (typeof TASK_INTENTS)[number];
-
-export interface ProviderLimits {
-  maxContextChars: number;
-  maxRuntimeMs: number;
-  maxPatchFiles: number;
-  maxChangedLines: number;
-}
-
-export interface ProviderSafety {
-  mayMutateFiles: boolean;
-  mayRunCommands: boolean;
-  /** When true, model output is applied by forge, never by the model itself. */
-  requiresApplyByForge: boolean;
-  requiresApprovalForExternalEffects: boolean;
-}
-
-export interface ProviderDescriptor {
-  providerId: string;
-  kind: ProviderKind;
-  modelFamily: ModelFamily;
-  status: ProviderStatus;
-  capabilities: ProviderCapability[];
-  limits: ProviderLimits;
-  safety: ProviderSafety;
-  /** True only when the provider can be invoked through local CLI/API. */
-  directDispatch: boolean;
-  summary: string;
-  lastErrorCode?: string;
-  rateLimited?: boolean;
-  configured?: boolean;
-  authPresent?: boolean;
-}
-
-export interface ProviderHealthReport {
-  providerId: string;
-  configured: boolean;
-  authPresent: boolean;
-  executableOrApiReachable: boolean;
-  modelAvailable: boolean | 'skipped';
-  lastErrorCode?: string;
-  rateLimitState?: 'unknown' | 'ok' | 'limited';
-  directDispatchAllowed: boolean;
-  handoffOnly: boolean;
-  status: ProviderStatus;
-  summary: string;
-  /** Never includes tokens, headers, or key material. */
-  redacted: true;
-}
-
-export interface GoalConstraints {
-  maxChangedFiles?: number;
-  maxChangedLines?: number;
-  allowCommit?: boolean;
-  allowPush?: boolean;
-  allowDestructive?: boolean;
-  allowExternalWrite?: boolean;
-  requireHandoffOnAmbiguity?: boolean;
-  allowedPaths?: string[];
-  forbiddenPaths?: string[];
-}
-
-export interface GoalVerificationPolicy {
-  requiredCheckIds: string[];
-  requirePassingEvidence: boolean;
-  maxInfrastructureRetries: number;
-}
-
-export interface GoalArtifactRef {
-  kind: string;
-  id?: string;
-  title: string;
-  summary?: string;
-  createdAt: string;
-}
-
-export interface GoalTransitionEvidence {
-  from: GoalStatus;
-  to: GoalStatus;
-  reason: string;
-  at: string;
-  providerId?: string;
-  failureClass?: FailureClass;
-  note?: string;
-}
-
-export interface GoalContract {
-  schemaVersion: 1;
-  goalId: string;
-  repoId: string;
-  title: string;
-  objective: string;
-  mode: GoalMode;
-  status: GoalStatus;
-  currentStep: string;
-  issueId?: string;
-  taskIds: string[];
-  constraints: GoalConstraints;
-  allowedExecutors: string[];
-  forbiddenExecutors: string[];
-  requiredApprovals: string[];
-  acceptanceCriteria: string[];
-  verificationPolicy: GoalVerificationPolicy;
-  lastRunId?: string;
-  lastProviderId?: string;
-  retryBudget: number;
-  repairAttempts: number;
-  artifacts: GoalArtifactRef[];
-  handoffPacketIds: string[];
-  transitionHistory: GoalTransitionEvidence[];
-  lastFailureClass?: FailureClass;
-  waitingReason?: string;
-  nextSafeAction?: string;
-  verificationEvidence?: Array<{ checkId: string; ok: boolean; summary: string; at: string }>;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface GoalContractStore {
-  schemaVersion: 1;
-  updatedAt: string;
-  goals: GoalContract[];
-}
-
-export interface GoalHandoffPacket {
-  schemaVersion: 1;
-  packetId: string;
-  goalId: string;
-  repoId: string;
-  objective: string;
-  currentState: {
-    status: GoalStatus;
-    currentStep: string;
-    lastProviderId?: string;
-    waitingReason?: string;
-  };
-  completedSteps: string[];
-  blockers: string[];
-  lastEvidence: Array<{ title: string; summary?: string }>;
-  currentDiffSummary?: string;
-  nextSafeActions: string[];
-  recommendedProvider?: string;
-  requiredUserDecision?: string;
-  exactToolCallsSuggested: Array<{
-    tool: string;
-    operation?: string;
-    payload?: Record<string, unknown>;
-    risk?: string;
-  }>;
-  constraints: GoalConstraints;
-  acceptanceCriteria: string[];
-  timestamp: string;
-  /** Secrets are never stored in packets. */
-  redacted: true;
-}
-
-export interface GoalHandoffPacketStore {
-  schemaVersion: 1;
-  updatedAt: string;
-  packets: GoalHandoffPacket[];
-}
-
-export interface StructuredProviderOutput {
-  summary: string;
-  proposed_patch?: string;
-  patch_instructions?: string;
-  changed_files: string[];
-  verification_commands: string[];
-  risk_notes: string[];
-}
-
-export interface ExecutorRouteInput {
-  /** Migration/testing escape hatch: adapters must return this exact policy decision. */
-  routePolicyInput?: import('../routing/route-policy').RoutePolicyInput;
-  goal: Pick<
-    GoalContract,
-    | 'goalId'
-    | 'repoId'
-    | 'mode'
-    | 'status'
-    | 'objective'
-    | 'constraints'
-    | 'allowedExecutors'
-    | 'forbiddenExecutors'
-    | 'lastProviderId'
-    | 'repairAttempts'
-    | 'retryBudget'
-    | 'lastFailureClass'
-  >;
-  taskIntent: TaskIntent;
-  risk: 'readonly' | 'local_repo_write' | 'workspace_write' | 'remote_write' | 'destructive' | 'raw_secret_config';
-  requiredCapabilities?: ProviderCapability[];
-  providers: ProviderDescriptor[];
-  retryHistory?: Array<{ providerId: string; failureClass?: FailureClass }>;
-  userConstraints?: {
-    preferProvider?: string;
-    forbidProvider?: string[];
-  };
-  policyBlocked?: boolean;
-  requiresApproval?: boolean;
-  externalWrite?: boolean;
-  /**
-   * Optional user routing preferences from controllerHome/global/executor-routing.json.
-   * When absent, built-in default order is used.
-   */
-  routingConfig?: {
-    orders?: Partial<Record<string, string[]>>;
-    defaultImplementationProvider?: string;
-    defaultRepairProvider?: string;
-    defaultPlanningProvider?: string;
-    defaultReviewProvider?: string;
-    defaultBrowserPlanningProvider?: string;
-    defaultIosAnalysisProvider?: string;
-  };
-}
-
-export interface ExecutorRouteDecision {
-  selectedProviderId: string | null;
-  selectedProvider?: ProviderDescriptor;
-  reason: string;
-  directDispatch: boolean;
-  handoffOnly: boolean;
-  waitForUser: boolean;
-  approvalState: ApprovalState;
-  alternatives: string[];
-  /** Replayable evidence from the single Route Policy authority. */
-  routeDecision: import('../routing/route-policy').RouteDecision;
-}
-
-export interface GoalLoopTickResult {
-  goalId: string;
-  from: GoalStatus;
-  to: GoalStatus;
-  transitioned: boolean;
-  reason: string;
-  providerId?: string;
-  handoffPacketId?: string;
-  waitingReason?: string;
-  nextSafeAction?: string;
-}
-
-export function isTerminalGoalStatus(status: GoalStatus): boolean {
-  return (TERMINAL_GOAL_STATUSES as readonly string[]).includes(status);
-}
-
-export function isActiveGoalStatus(status: GoalStatus): boolean {
-  return (ACTIVE_GOAL_STATUSES as readonly string[]).includes(status);
-}

package/src/runtime/control-plane/startup-recovery.ts

@@ -1,198 +0,0 @@
-import { existsSync, realpathSync } from 'fs';
-import { join, resolve } from 'path';
-import {
-  consolidateRepositoryRegistry,
-  listRepositories,
-  reconcileRepositoryCheckouts,
-  repositoryCheckoutLifecycle,
-  repositoryCheckoutRootMatches,
-} from '../../cli/repositories/registry';
-import { repositoryControllerRoot } from '../../cli/repositories/controller-home';
-import { listLocalBridgeJobs, reconcileLocalBridgeJobs } from '../../cli/local-bridge/job-store';
-import { listExecutionJobs, rebuildExecutionJobIndexes } from '../execution/jobs/store';
-import { reconcileExecutionJobs } from './global-scheduler/reconciliation';
-import { listActiveLeases } from '../resources/leases/store';
-import { rebuildRepositoryProjection } from '../projections/materialized-view';
-import { readRepositoryProjectionDirty } from '../projections/invalidation';
-import { CONTROLLER_SCOPE_REPO_ID } from '../../cli/repositories/controller-home';
-import { reconcileStaleWorkContracts } from './facade/work-contract-store';
-import { recoverManagedProcesses } from '../execution/process-runtime/runtime';
-
-export interface ControllerRecoveryError {
-  repoId: string;
-  phase: 'registry' | 'checkouts' | 'execution-indexes' | 'execution-jobs' | 'local-jobs' | 'leases' | 'work-contracts' | 'projection';
-  code: string;
-  message: string;
-}
-
-export interface ControllerRecoveryRepositoryResult {
-  repoId: string;
-  degraded: boolean;
-  archivedCheckoutIds?: string[];
-  executionIndexesRebuilt?: boolean;
-  executionJobs?: ReturnType<typeof reconcileExecutionJobs>;
-  localJobs?: ReturnType<typeof reconcileLocalBridgeJobs>;
-  activeLeases?: number;
-  workContracts?: ReturnType<typeof reconcileStaleWorkContracts>;
-  projectionRebuilt?: boolean;
-}
-
-export interface ControllerStartupRecoveryResult {
-  completedAt: string;
-  repositories: ControllerRecoveryRepositoryResult[];
-  errors: ControllerRecoveryError[];
-  degraded: boolean;
-}
-
-function comparableCheckoutPath(value: string): string {
-  const resolved = resolve(value);
-  try {
-    return realpathSync(resolved);
-  } catch {
-    return process.platform === 'darwin' && resolved.startsWith('/var/')
-      ? `/private${resolved}`
-      : resolved;
-  }
-}
-
-function errorCode(error: unknown): string {
-  const message = error instanceof Error ? error.message : String(error);
-  const separator = message.indexOf(':');
-  return separator > 0 ? message.slice(0, separator) : 'RECOVERY_FAILED';
-}
-
-function persistedProjectionExists(controllerHome: string, repoId: string): boolean {
-  return existsSync(join(repositoryControllerRoot(controllerHome, repoId), 'projections', 'runtime.json'));
-}
-
-function projectionNeedsRebuild(controllerHome: string, repoId: string): boolean {
-  return !persistedProjectionExists(controllerHome, repoId)
-    || readRepositoryProjectionDirty(controllerHome, repoId) !== undefined;
-}
-
-/**
- * Synchronous, repository-isolated restart reconciliation. Every operation is
- * bounded by the underlying durable-store scans; one repository failure is
- * recorded and cannot prevent healthy repositories from becoming ready.
- */
-export function reconcileControllerStartup(controllerHome: string): ControllerStartupRecoveryResult {
-  const recovered: ControllerRecoveryRepositoryResult[] = [];
-  const errors: ControllerRecoveryError[] = [];
-  try {
-    consolidateRepositoryRegistry(controllerHome);
-  } catch (error) {
-    errors.push({
-      repoId: CONTROLLER_SCOPE_REPO_ID,
-      phase: 'registry',
-      code: errorCode(error),
-      message: error instanceof Error ? error.message : String(error),
-    });
-  }
-  // Recover process leases / terminal receipts for every repository.
-  try {
-    for (const repository of listRepositories(controllerHome).filter((repo) => repo.enabled && !repo.removedAt)) {
-      try {
-        recoverManagedProcesses(controllerHome, repository.repoId);
-      } catch {
-        /* per-repo best-effort */
-      }
-    }
-  } catch {
-    /* process runtime optional in early fixtures */
-  }
-  const repositories = listRepositories(controllerHome).filter((repo) => repo.enabled && !repo.removedAt);
-  for (const repository of repositories) {
-    const result: ControllerRecoveryRepositoryResult = { repoId: repository.repoId, degraded: false };
-    const run = <T>(phase: ControllerRecoveryError['phase'], action: () => T): T | undefined => {
-      try {
-        return action();
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        result.degraded = true;
-        errors.push({ repoId: repository.repoId, phase, code: errorCode(error), message });
-        return undefined;
-      }
-    };
-
-    const checkoutReconciliation = run('checkouts', () =>
-      reconcileRepositoryCheckouts(repository.repoId, controllerHome));
-    result.archivedCheckoutIds = checkoutReconciliation?.archivedCheckoutIds;
-
-    // Rebuild from records first so a lost/stale active or request index
-    // cannot hide accepted work from reconciliation or idempotency lookup.
-    result.executionIndexesRebuilt = run('execution-indexes', () => {
-      rebuildExecutionJobIndexes(controllerHome, [repository.repoId]);
-      return true;
-    });
-    result.executionJobs = run('execution-jobs', () => reconcileExecutionJobs(controllerHome, repository.repoId));
-    result.localJobs = run('local-jobs', () => reconcileLocalBridgeJobs(repository.canonicalRoot));
-    result.activeLeases = run('leases', () => listActiveLeases(controllerHome, repository.repoId).length);
-    result.workContracts = run('work-contracts', () => {
-      const activeExecutionJobs = listExecutionJobs(controllerHome, repository.repoId, 500)
-        .filter((job) => ['queued', 'dispatched', 'running', 'waiting_for_approval'].includes(job.status)).length;
-      const activeLocalJobs = listLocalBridgeJobs(repository.canonicalRoot, 500)
-        .filter((job) => ['approved', 'dispatched', 'running'].includes(job.status)).length;
-      const activeLeases = listActiveLeases(controllerHome, repository.repoId).length;
-      const checkouts = checkoutReconciliation?.repository.checkouts ?? repository.checkouts;
-      return reconcileStaleWorkContracts(
-        { controllerHome, repoId: repository.repoId },
-        {
-          activeExecutionJobs,
-          activeLocalJobs,
-          activeLeases,
-          worktreeAvailability: (worktreeRef) => {
-            const worktreePath = comparableCheckoutPath(worktreeRef);
-            const checkout = checkouts.find((candidate) =>
-              comparableCheckoutPath(candidate.localRoot) === worktreePath
-              || comparableCheckoutPath(candidate.canonicalRoot) === worktreePath);
-            if (checkout) {
-              return repositoryCheckoutLifecycle(checkout) === 'active' ? 'active' : 'inactive';
-            }
-            if (!existsSync(worktreePath)) return 'missing';
-            const reconciledRepository = checkoutReconciliation?.repository ?? repository;
-            return repositoryCheckoutRootMatches(reconciledRepository, worktreeRef) ? 'unknown' : 'inactive';
-          },
-        },
-      );
-    });
-    result.projectionRebuilt = run('projection', () => {
-      if (!projectionNeedsRebuild(controllerHome, repository.repoId)) return false;
-      rebuildRepositoryProjection(controllerHome, repository.repoId);
-      return true;
-    });
-    recovered.push(result);
-  }
-  // Controller-scoped plugin work uses the same durable Job and lease stores,
-  // but it is intentionally absent from the Repository Registry. Reconcile it
-  // explicitly so a daemon restart cannot strand local_system work.
-  const controllerResult: ControllerRecoveryRepositoryResult = {
-    repoId: CONTROLLER_SCOPE_REPO_ID,
-    degraded: false,
-  };
-  const runController = <T>(phase: ControllerRecoveryError['phase'], action: () => T): T | undefined => {
-    try {
-      return action();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      controllerResult.degraded = true;
-      errors.push({ repoId: CONTROLLER_SCOPE_REPO_ID, phase, code: errorCode(error), message });
-      return undefined;
-    }
-  };
-  controllerResult.executionIndexesRebuilt = runController('execution-indexes', () => {
-    rebuildExecutionJobIndexes(controllerHome, [CONTROLLER_SCOPE_REPO_ID]);
-    return true;
-  });
-  controllerResult.executionJobs = runController('execution-jobs', () =>
-    reconcileExecutionJobs(controllerHome, CONTROLLER_SCOPE_REPO_ID));
-  controllerResult.activeLeases = runController('leases', () =>
-    listActiveLeases(controllerHome, CONTROLLER_SCOPE_REPO_ID).length);
-  recovered.push(controllerResult);
-
-  return {
-    completedAt: new Date().toISOString(),
-    repositories: recovered,
-    errors,
-    degraded: errors.length > 0,
-  };
-}