@moretea-labs/forge 1.8.0 → 1.8.2

package/assets/templates/helpers/check-skill-version.ts

@@ -1,193 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Skill Version Consistency Checker
- *
- * Validates that version numbers are consistent across:
- * - package.json
- * - assets/skill-version.json
- *
- * Also checks if a generated project needs migration.
- */
-
-import { readFileSync, existsSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { resolveAgenticDevRoot } from "./workflow-contract.ts";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const REPO_ROOT = __dirname.endsWith("/.ai/harness/scripts")
-  ? join(__dirname, "../../..")
-  : __dirname.endsWith("/assets/templates/helpers")
-    ? join(__dirname, "../../..")
-    : join(__dirname, "..");
-
-export interface ConsistencyResult {
-  consistent: boolean;
-  packageJsonVersion: string | null;
-  skillVersionJsonVersion: string;
-  templateVersionJsonVersion: string;
-  skillVersionSource: string;
-  warnings: string[];
-  errors: string[];
-}
-
-export interface MigrationCheckResult {
-  needsMigration: boolean;
-  currentSkillVersion: string;
-  projectSkillVersion: string | null;
-  projectTemplatVersion: string | null;
-}
-
-/**
- * Check version consistency across the version sources this repo owns.
- */
-export function checkConsistency(repoRoot: string = REPO_ROOT): ConsistencyResult {
-  const errors: string[] = [];
-  const warnings: string[] = [];
-
-  // Read package.json
-  const pkgPath = join(repoRoot, "package.json");
-  if (!existsSync(pkgPath)) {
-    throw new Error(`package.json not found at ${pkgPath}`);
-  }
-  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-  const packageJsonVersion =
-    typeof pkg.version === "string" && pkg.version.length > 0
-      ? (pkg.version as string)
-      : null;
-
-  // Read the local source manifest when this script runs inside forge;
-  // generated projects resolve the upstream skill root instead.
-  const localSvPath = join(repoRoot, "assets", "skill-version.json");
-  const svPath = existsSync(localSvPath)
-    ? localSvPath
-    : join(resolveAgenticDevRoot(repoRoot), "assets", "skill-version.json");
-  if (!existsSync(svPath)) {
-    throw new Error(`skill-version.json not found at ${svPath}`);
-  }
-  const sv = JSON.parse(readFileSync(svPath, "utf-8"));
-  const skillVersionJsonVersion = sv.version as string;
-  const templateVersionJsonVersion = sv.templateVersion as string;
-  const usingLocalSkillManifest = svPath === localSvPath;
-
-  const packageCoreVersion = packageJsonVersion?.split("-", 1)[0] ?? null;
-  const isForgePackage =
-    pkg.name === "forge" ||
-    pkg.name === "@moretea-labs/forge-controller" ||
-    pkg.name === "@moretea-labs/forge";
-
-  if (
-    usingLocalSkillManifest &&
-    isForgePackage &&
-    packageCoreVersion !== null &&
-    packageCoreVersion !== skillVersionJsonVersion
-  ) {
-    errors.push(
-      `package.json core version (${packageCoreVersion}) must match assets/skill-version.json version (${skillVersionJsonVersion})`
-    );
-  }
-
-  if (usingLocalSkillManifest && templateVersionJsonVersion !== skillVersionJsonVersion) {
-    errors.push(
-      `assets/skill-version.json templateVersion (${templateVersionJsonVersion}) must match version (${skillVersionJsonVersion})`
-    );
-  }
-
-  if (!usingLocalSkillManifest && packageJsonVersion !== null) {
-    warnings.push(
-      `package.json.version (${packageJsonVersion}) belongs to the target repo; workflow stamp uses upstream forge skill-version.json`
-    );
-  }
-
-  return {
-    consistent: errors.length === 0,
-    packageJsonVersion,
-    skillVersionJsonVersion,
-    templateVersionJsonVersion,
-    skillVersionSource: svPath,
-    warnings,
-    errors,
-  };
-}
-
-/**
- * Check if a generated project needs migration.
- */
-export function checkProjectNeedsMigration(
-  projectPath: string,
-  repoRoot: string = REPO_ROOT
-): MigrationCheckResult {
-  const localSvPath = join(repoRoot, "assets", "skill-version.json");
-  const svPath = existsSync(localSvPath)
-    ? localSvPath
-    : join(resolveAgenticDevRoot(repoRoot), "assets", "skill-version.json");
-  const sv = JSON.parse(readFileSync(svPath, "utf-8"));
-  const currentSkillVersion = sv.version as string;
-
-  const stampPath = join(projectPath, ".claude", ".skill-version");
-  if (!existsSync(stampPath)) {
-    return {
-      needsMigration: true,
-      currentSkillVersion,
-      projectSkillVersion: null,
-      projectTemplatVersion: null,
-    };
-  }
-
-  const stampContent = readFileSync(stampPath, "utf-8");
-  const skillVersionMatch = stampContent.match(/^skill_version=(.+)$/m);
-  const templateVersionMatch = stampContent.match(/^template_version=(.+)$/m);
-
-  const projectSkillVersion = skillVersionMatch?.[1] ?? null;
-  const projectTemplatVersion = templateVersionMatch?.[1] ?? null;
-
-  return {
-    needsMigration: projectSkillVersion !== currentSkillVersion,
-    currentSkillVersion,
-    projectSkillVersion,
-    projectTemplatVersion,
-  };
-}
-
-// CLI entry point
-if (import.meta.main) {
-  const args = process.argv.slice(2);
-  const projectIdx = args.indexOf("--project");
-  const projectPath = projectIdx !== -1 ? args[projectIdx + 1] : null;
-
-  try {
-    const result = checkConsistency();
-
-    if (result.consistent) {
-      console.log(
-        `Workflow version check passed: forge=${result.skillVersionJsonVersion}, template=${result.templateVersionJsonVersion}`
-      );
-      console.log(`Workflow version source: ${result.skillVersionSource}`);
-      for (const warning of result.warnings) {
-        console.log(`Warning: ${warning}`);
-      }
-    } else {
-      console.error("Version consistency check FAILED:");
-      for (const error of result.errors) {
-        console.error(`  - ${error}`);
-      }
-      process.exit(1);
-    }
-
-    if (projectPath) {
-      const migration = checkProjectNeedsMigration(projectPath);
-      if (migration.needsMigration) {
-        console.log(
-          `Project at ${projectPath} needs migration: ` +
-          `${migration.projectSkillVersion ?? "(no stamp)"} → ${migration.currentSkillVersion}`
-        );
-      } else {
-        console.log(`Project at ${projectPath} is up to date (${migration.currentSkillVersion})`);
-      }
-    }
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}

package/packages/kernel/progression/api/index.ts

@@ -1,2 +0,0 @@
-export * from '../domain/types';
-export * from '../application/projector';

package/packages/kernel/progression/application/projector.ts

@@ -1,211 +0,0 @@
-import { createHash } from 'crypto';
-import type {
-  AutonomousGoalProgressionAction,
-  AutonomousGoalProgressionDecision,
-  AutonomousGoalProgressionReason,
-  AutonomousGoalProgressionSnapshot,
-  ProgressionControllerRoundSnapshot,
-  ProgressionPlanStepSnapshot,
-  ProgressionWorkSnapshot,
-} from '../domain/types';
-
-const EXECUTABLE_PLAN_STATUSES = new Set(['approved', 'executing', 'verifying', 'ready_to_finalize']);
-const ACTIVE_WORK_STATUSES = new Set(['open', 'running', 'ready']);
-const IN_FLIGHT_ROUND_STATUSES = new Set(['pending_release', 'dispatching', 'dispatched', 'claimed', 'waiting']);
-
-function stableSnapshot(snapshot: AutonomousGoalProgressionSnapshot): unknown {
-  return {
-    requirement: snapshot.requirement,
-    plan: {
-      planId: snapshot.plan.planId,
-      requirementId: snapshot.plan.requirementId,
-      sourceRevision: snapshot.plan.sourceRevision,
-      status: snapshot.plan.status,
-      steps: snapshot.plan.steps.map((step) => ({
-        id: step.id,
-        dependencies: [...step.dependencies],
-        status: step.status,
-        workId: step.workId,
-      })),
-    },
-    currentSourceRevision: snapshot.currentSourceRevision,
-    works: [...snapshot.works]
-      .map((work) => ({ ...work }))
-      .sort((left, right) => left.workId.localeCompare(right.workId)),
-    controllerRounds: [...(snapshot.controllerRounds ?? [])]
-      .map((round) => ({ ...round }))
-      .sort((left, right) => left.originWorkId.localeCompare(right.originWorkId) || left.roundCount - right.roundCount),
-    schedules: [...(snapshot.schedules ?? [])]
-      .map((schedule) => ({ ...schedule }))
-      .sort((left, right) => left.scheduleId.localeCompare(right.scheduleId)),
-  };
-}
-
-function decision(
-  snapshot: AutonomousGoalProgressionSnapshot,
-  kind: AutonomousGoalProgressionAction,
-  reasonCode: AutonomousGoalProgressionReason,
-  detail: Pick<AutonomousGoalProgressionDecision, 'planStepId' | 'workId' | 'dependencyStepIds'> = {},
-): AutonomousGoalProgressionDecision {
-  const identityInput = JSON.stringify({
-    snapshot: stableSnapshot(snapshot),
-    decision: { kind, reasonCode, ...detail },
-  });
-  return {
-    schemaVersion: 1,
-    kind,
-    reasonCode,
-    requirementId: snapshot.requirement.requirementId,
-    planId: snapshot.plan.planId,
-    ...detail,
-    idempotencyKey: `goal-progression:v1:${createHash('sha256').update(identityInput).digest('hex').slice(0, 32)}`,
-  };
-}
-
-function latestRoundForWork(
-  rounds: readonly ProgressionControllerRoundSnapshot[] | undefined,
-  workId: string,
-): ProgressionControllerRoundSnapshot | undefined {
-  return (rounds ?? [])
-    .filter((round) => round.originWorkId === workId)
-    .reduce<ProgressionControllerRoundSnapshot | undefined>(
-      (latest, round) => !latest || round.roundCount > latest.roundCount ? round : latest,
-      undefined,
-    );
-}
-
-function boundWork(
-  snapshot: AutonomousGoalProgressionSnapshot,
-  step: ProgressionPlanStepSnapshot,
-): ProgressionWorkSnapshot | undefined {
-  if (!step.workId) return undefined;
-  return snapshot.works.find((work) => work.workId === step.workId);
-}
-
-function invalidDependency(
-  steps: readonly ProgressionPlanStepSnapshot[],
-): { stepId: string; dependencyIds: string[] } | undefined {
-  const ids = new Set(steps.map((step) => step.id));
-  for (const step of steps) {
-    const missing = step.dependencies.filter((dependencyId) => dependencyId === step.id || !ids.has(dependencyId));
-    if (missing.length > 0) return { stepId: step.id, dependencyIds: [...missing] };
-  }
-  return undefined;
-}
-
-/**
- * Pure Goal-level progression projection. It never writes lifecycle state and
- * never equates machine delivery with Controller semantic acceptance.
- */
-export function projectAutonomousGoalProgression(
-  snapshot: AutonomousGoalProgressionSnapshot,
-): AutonomousGoalProgressionDecision {
-  const { requirement, plan } = snapshot;
-
-  if (requirement.state === 'done') return decision(snapshot, 'goal_complete', 'REQUIREMENT_ALREADY_DONE');
-  if (requirement.state === 'waiting_for_user') return decision(snapshot, 'wait_for_user', 'REQUIREMENT_WAITING_FOR_USER');
-  if (requirement.state === 'cancelled') return decision(snapshot, 'blocked_invalid_state', 'REQUIREMENT_CANCELLED');
-  if (plan.requirementId && plan.requirementId !== requirement.requirementId) {
-    return decision(snapshot, 'blocked_invalid_state', 'PLAN_REQUIREMENT_MISMATCH');
-  }
-
-  // A terminal Work may legitimately advance repository source A -> B before
-  // Controller semantic acceptance advances Plan.sourceRevision to B. Only that
-  // exact Work completion target may cross the drift boundary. Any later C is
-  // unrelated drift and still requires explicit re-evaluation.
-  const validatingDelivery = plan.steps
-    .filter((step) => step.status === 'executing' || step.status === 'validating')
-    .map((step) => ({ step, work: boundWork(snapshot, step) }))
-    .find(({ work }) => work?.status === 'completed'
-      && work.baseRevision === plan.sourceRevision
-      && work.completionTargetRevision === snapshot.currentSourceRevision);
-  const expectedDeliveryAdvance = Boolean(validatingDelivery && plan.sourceRevision !== snapshot.currentSourceRevision);
-  if (plan.sourceRevision !== snapshot.currentSourceRevision && !expectedDeliveryAdvance) {
-    return decision(snapshot, 'request_replan', 'PLAN_SOURCE_DRIFT');
-  }
-  if (plan.status === 'replanning' || plan.status === 'invalidated_by_drift') return decision(snapshot, 'request_replan', 'PLAN_REPLAN_REQUIRED');
-  if (plan.status === 'finalized') {
-    if (!plan.steps.every((step) => step.status === 'completed')) {
-      return decision(snapshot, 'blocked_invalid_state', 'PLAN_COMPLETION_STATE_CONTRADICTION');
-    }
-    return decision(snapshot, 'request_requirement_acceptance', 'PLAN_FINALIZED_REQUIRES_REQUIREMENT_ACCEPTANCE');
-  }
-  if (plan.status === 'superseded' || plan.status === 'cancelled') return decision(snapshot, 'blocked_invalid_state', 'PLAN_TERMINAL_INVALID');
-  if (!EXECUTABLE_PLAN_STATUSES.has(plan.status)) return decision(snapshot, 'blocked_invalid_state', 'PLAN_NOT_EXECUTABLE');
-  if (plan.steps.length === 0) return decision(snapshot, 'blocked_invalid_state', 'PLAN_EMPTY');
-
-  const ids = new Set(plan.steps.map((step) => step.id));
-  if (ids.size !== plan.steps.length) return decision(snapshot, 'blocked_invalid_state', 'PLAN_STEP_ID_DUPLICATE');
-  const badDependency = invalidDependency(plan.steps);
-  if (badDependency) {
-    return decision(snapshot, 'blocked_invalid_state', 'PLAN_DEPENDENCY_INVALID', {
-      planStepId: badDependency.stepId,
-      dependencyStepIds: badDependency.dependencyIds,
-    });
-  }
-
-  for (const step of plan.steps) {
-    if (step.status !== 'executing' && step.status !== 'validating') continue;
-    const work = boundWork(snapshot, step);
-    if (!work) return decision(snapshot, 'blocked_invalid_state', 'PLAN_STEP_WORK_MISSING', { planStepId: step.id, workId: step.workId });
-    if (work.planId !== plan.planId || work.planStepId !== step.id || (work.requirementId && work.requirementId !== requirement.requirementId)) {
-      return decision(snapshot, 'blocked_invalid_state', 'WORK_IDENTITY_MISMATCH', { planStepId: step.id, workId: work.workId });
-    }
-    if ((work.status === 'completed' || work.status === 'failed' || work.status === 'cancelled') && step.status === 'executing') {
-      return decision(snapshot, 'blocked_invalid_state', 'PLAN_STEP_TERMINAL_WORK_RECONCILIATION_REQUIRED', { planStepId: step.id, workId: work.workId });
-    }
-    if (work.status === 'failed' || work.status === 'cancelled') {
-      return decision(snapshot, 'request_replan', 'WORK_FAILED_REPLAN', { planStepId: step.id, workId: work.workId });
-    }
-    if (work.status === 'blocked') return decision(snapshot, 'wait_current_work', 'WORK_BLOCKED', { planStepId: step.id, workId: work.workId });
-    if (work.status === 'completed') {
-      return decision(snapshot, 'request_controller_acceptance', 'MACHINE_COMPLETE_REQUIRES_CONTROLLER_ACCEPTANCE', {
-        planStepId: step.id,
-        workId: work.workId,
-      });
-    }
-    if (ACTIVE_WORK_STATUSES.has(work.status)) {
-      const round = latestRoundForWork(snapshot.controllerRounds, work.workId);
-      if (round?.status === 'waiting_for_user') {
-        return decision(snapshot, 'wait_for_user', 'CONTROLLER_ROUND_WAITING_FOR_USER', { planStepId: step.id, workId: work.workId });
-      }
-      if (round?.status === 'goal_complete') {
-        return decision(snapshot, 'blocked_invalid_state', 'CONTROLLER_ROUND_TERMINAL_CONTRADICTION', { planStepId: step.id, workId: work.workId });
-      }
-      if (round && (IN_FLIGHT_ROUND_STATUSES.has(round.status) || round.status === 'blocked' || round.status === 'failed')) {
-        return decision(snapshot, 'wait_current_work', 'CONTROLLER_ROUND_IN_FLIGHT', { planStepId: step.id, workId: work.workId });
-      }
-      return decision(snapshot, 'continue_current_work', 'WORK_READY_TO_CONTINUE', { planStepId: step.id, workId: work.workId });
-    }
-  }
-
-  if (plan.steps.every((step) => step.status === 'completed')) {
-    return decision(snapshot, 'blocked_invalid_state', 'PLAN_COMPLETION_STATE_CONTRADICTION');
-  }
-
-  const completedIds = new Set(plan.steps.filter((step) => step.status === 'completed').map((step) => step.id));
-  const dependencyReady = plan.steps.filter((step) =>
-    step.status !== 'completed'
-    && step.dependencies.every((dependencyId) => completedIds.has(dependencyId)),
-  );
-  const explicitReady = dependencyReady.filter((step) => step.status === 'ready');
-
-  if (explicitReady.length === 1) {
-    return decision(snapshot, 'start_next_plan_step', 'NEXT_PLAN_STEP_READY', { planStepId: explicitReady[0].id });
-  }
-  if (explicitReady.length > 1) {
-    return decision(snapshot, 'blocked_invalid_state', 'MULTIPLE_READY_PLAN_STEPS', {
-      dependencyStepIds: explicitReady.map((step) => step.id),
-    });
-  }
-  const readinessNotProjected = dependencyReady.find((step) => step.status === 'pending');
-  if (readinessNotProjected) {
-    return decision(snapshot, 'blocked_invalid_state', 'PLAN_STEP_READINESS_NOT_PROJECTED', { planStepId: readinessNotProjected.id });
-  }
-
-  const blocked = plan.steps.find((step) => step.status !== 'completed');
-  return decision(snapshot, 'wait_dependency', 'PLAN_DEPENDENCY_WAIT', {
-    planStepId: blocked?.id,
-    dependencyStepIds: blocked?.dependencies.filter((dependencyId) => !completedIds.has(dependencyId)) ?? [],
-  });
-}

package/packages/kernel/progression/domain/types.ts

@@ -1,116 +0,0 @@
-import type { ControllerRoundRelayStatus } from '../../controller/api/index';
-import type { RequirementState, PlanContractStatus, PlanStepStatus } from '../../goal/api/index';
-import type { RepositorySchedule } from '../../scheduler/api/index';
-import type { WorkContractStatus } from '../../work/api/index';
-
-/**
- * Read-only lifecycle facts consumed by the Goal Progression projector.
- * These are projections of existing authorities, never a persistence schema.
- */
-export interface ProgressionRequirementSnapshot {
-  requirementId: string;
-  state: RequirementState;
-  revision: number;
-}
-
-export interface ProgressionPlanStepSnapshot {
-  id: string;
-  dependencies: readonly string[];
-  status: PlanStepStatus;
-  workId?: string;
-}
-
-export interface ProgressionPlanSnapshot {
-  planId: string;
-  requirementId?: string;
-  sourceRevision: string;
-  status: PlanContractStatus;
-  steps: readonly ProgressionPlanStepSnapshot[];
-}
-
-export interface ProgressionWorkSnapshot {
-  workId: string;
-  requirementId?: string;
-  planId?: string;
-  planStepId?: string;
-  status: WorkContractStatus;
-  /** Exact source revision from which this Work execution started. */
-  baseRevision?: string;
-  /** Exact integrated target revision from the canonical Work completion receipt, when delivery changed source. */
-  completionTargetRevision?: string;
-}
-
-export type ProgressionScheduleSnapshot = Pick<RepositorySchedule, 'scheduleId' | 'revision' | 'enabled' | 'nextEligibleAt' | 'pausedReason'>;
-
-export interface ProgressionControllerRoundSnapshot {
-  originWorkId: string;
-  status: ControllerRoundRelayStatus;
-  roundCount: number;
-}
-
-export interface AutonomousGoalProgressionSnapshot {
-  requirement: ProgressionRequirementSnapshot;
-  plan: ProgressionPlanSnapshot;
-  currentSourceRevision: string;
-  works: readonly ProgressionWorkSnapshot[];
-  controllerRounds?: readonly ProgressionControllerRoundSnapshot[];
-  schedules?: readonly ProgressionScheduleSnapshot[];
-}
-
-export const AUTONOMOUS_GOAL_PROGRESSION_ACTIONS = [
-  'continue_current_work',
-  'wait_current_work',
-  'request_controller_acceptance',
-  'request_requirement_acceptance',
-  'start_next_plan_step',
-  'wait_dependency',
-  'request_replan',
-  'wait_for_user',
-  'goal_complete',
-  'blocked_invalid_state',
-] as const;
-export type AutonomousGoalProgressionAction = (typeof AUTONOMOUS_GOAL_PROGRESSION_ACTIONS)[number];
-
-export const AUTONOMOUS_GOAL_PROGRESSION_REASONS = [
-  'REQUIREMENT_ALREADY_DONE',
-  'REQUIREMENT_WAITING_FOR_USER',
-  'REQUIREMENT_CANCELLED',
-  'PLAN_REQUIREMENT_MISMATCH',
-  'PLAN_SOURCE_DRIFT',
-  'PLAN_REPLAN_REQUIRED',
-  'PLAN_TERMINAL_INVALID',
-  'PLAN_NOT_EXECUTABLE',
-  'PLAN_EMPTY',
-  'PLAN_STEP_ID_DUPLICATE',
-  'PLAN_DEPENDENCY_INVALID',
-  'PLAN_STEP_WORK_MISSING',
-  'WORK_IDENTITY_MISMATCH',
-  'PLAN_STEP_TERMINAL_WORK_RECONCILIATION_REQUIRED',
-  'WORK_FAILED_REPLAN',
-  'WORK_BLOCKED',
-  'CONTROLLER_ROUND_IN_FLIGHT',
-  'CONTROLLER_ROUND_WAITING_FOR_USER',
-  'CONTROLLER_ROUND_TERMINAL_CONTRADICTION',
-  'WORK_READY_TO_CONTINUE',
-  'MACHINE_COMPLETE_REQUIRES_CONTROLLER_ACCEPTANCE',
-  'PLAN_FINALIZED_REQUIRES_REQUIREMENT_ACCEPTANCE',
-  'PLAN_COMPLETION_STATE_CONTRADICTION',
-  'NEXT_PLAN_STEP_READY',
-  'PLAN_DEPENDENCY_WAIT',
-  'MULTIPLE_READY_PLAN_STEPS',
-  'PLAN_STEP_READINESS_NOT_PROJECTED',
-] as const;
-export type AutonomousGoalProgressionReason = (typeof AUTONOMOUS_GOAL_PROGRESSION_REASONS)[number];
-
-export interface AutonomousGoalProgressionDecision {
-  schemaVersion: 1;
-  kind: AutonomousGoalProgressionAction;
-  reasonCode: AutonomousGoalProgressionReason;
-  requirementId: string;
-  planId: string;
-  planStepId?: string;
-  workId?: string;
-  dependencyStepIds?: string[];
-  /** Stable replay identity derived only from the immutable input snapshot + decision. */
-  idempotencyKey: string;
-}

package/packages/kernel/progression/index.ts

@@ -1 +0,0 @@
-export * from './api/index';