p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/src/workflow-page/bootstrap.ts

@@ -0,0 +1,277 @@
+import type { HarnessConfig } from "../config/types.js";
+import type { RoleModelRole } from "../config/role-models.js";
+import {
+  resolveBuilderModel,
+  resolvePlannerModel,
+  summarizeRoleModelSource,
+} from "../cursor/model.js";
+import {
+  validateCanonicalLinearWorkflow,
+  type CanonicalValidationResult,
+} from "../workflow/canonical-workflow-validation.js";
+import type {
+  WorkflowBootstrapPayload,
+  WorkflowCatalogLoadMetadata,
+  WorkflowModelCatalogEntry,
+  WorkflowModelSelection,
+  WorkflowScope,
+  WorkflowSourceContext,
+} from "./types.js";
+import { buildModelSaveReadiness } from "./catalog-validation.js";
+import { dataSourceLabel } from "./source-context.js";
+import { getFixtureDefinition } from "./fixtures/index.js";
+import { getFixtureWorkflowScopes } from "./fixtures/workflow-scopes.js";
+import { emptyHarnessConfig } from "./model-catalog.js";
+import { lookupModelInCatalog } from "./model-catalog-lookup.js";
+import { hashWorkflowFingerprint } from "./fingerprint.js";
+import { buildLiveWorkflowScopes, validateRequestedScopeId } from "./workflow-scopes.js";
+import { enrichWorkflowScopes } from "./scope-branches.js";
+import {
+  buildCurrentWorkflowMappings,
+  enrichStatusRecords,
+  type LinearStatusInput,
+} from "./current-workflow.js";
+import type { WorkflowFixtureId } from "./constants.js";
+import type { WorkflowHealthState } from "./types.js";
+
+export interface WorkflowBootstrapDependencies {
+  cwd: string;
+  context: WorkflowSourceContext;
+  config?: HarnessConfig;
+  configFingerprint?: string;
+  teamId?: string;
+  teamKey?: string;
+  linearStatuses?: LinearStatusInput[];
+  modelCatalog?: WorkflowModelCatalogEntry[];
+  catalogLoadMetadata?: WorkflowCatalogLoadMetadata;
+  warnings?: string[];
+  scopes?: WorkflowScope[];
+  debugEnabled?: boolean;
+}
+
+export function buildConfigFingerprint(config?: HarnessConfig): string {
+  return hashWorkflowFingerprint(config ?? {});
+}
+
+function buildWorkflowModelSelection(
+  config: HarnessConfig,
+  role: RoleModelRole,
+  modelCatalog: WorkflowModelCatalogEntry[],
+): WorkflowModelSelection {
+  const resolved = role === "planner" ? resolvePlannerModel(config) : resolveBuilderModel(config);
+  const catalogEntry = lookupModelInCatalog(modelCatalog, resolved.id);
+  return {
+    modelId: resolved.id,
+    displayName: catalogEntry?.displayName ?? resolved.id,
+    parameters: resolved.params?.map((parameter) => ({
+      id: parameter.id,
+      value: parameter.value,
+    })) ?? [],
+    source: summarizeRoleModelSource(config, role),
+  };
+}
+
+function resolveScopes(deps: WorkflowBootstrapDependencies): WorkflowScope[] {
+  const raw =
+    deps.scopes?.length
+      ? deps.scopes
+      : deps.context.mode === "fixture"
+        ? getFixtureWorkflowScopes()
+        : buildLiveWorkflowScopes(deps.config ?? emptyHarnessConfig());
+  return enrichWorkflowScopes(raw, deps.config);
+}
+
+function buildCanonicalValidation(input: {
+  statuses: LinearStatusInput[];
+  config?: HarnessConfig;
+  catalogLoadMetadata: WorkflowCatalogLoadMetadata;
+}): CanonicalValidationResult | undefined {
+  if (input.catalogLoadMetadata.statusCatalog !== "loaded") {
+    return undefined;
+  }
+  return validateCanonicalLinearWorkflow({
+    workflowStates: input.statuses.map((status) => ({
+      id: status.id,
+      name: status.name,
+      category: status.type,
+    })),
+    config: input.config,
+  });
+}
+
+function deriveWorkflowHealthState(input: {
+  catalogLoadMetadata: WorkflowCatalogLoadMetadata;
+  canonicalValidation?: CanonicalValidationResult;
+}): WorkflowHealthState {
+  if (input.catalogLoadMetadata.statusCatalog === "unavailable") {
+    return "linear-unavailable";
+  }
+  if (input.canonicalValidation && !input.canonicalValidation.valid) {
+    return "blocking-configuration-error";
+  }
+  return "healthy";
+}
+
+export async function buildWorkflowBootstrap(
+  deps: WorkflowBootstrapDependencies,
+): Promise<WorkflowBootstrapPayload> {
+  const warnings = [...(deps.warnings ?? [])];
+  const context = deps.context;
+  const scopes = resolveScopes(deps);
+  const allowlist = new Map(scopes.map((scope) => [scope.id, scope]));
+  const scopeResolution = validateRequestedScopeId(context.scopeId, allowlist);
+
+  if (context.rejectionReason) {
+    return rejectedPayload(context, scopes, warnings);
+  }
+
+  if (scopeResolution.error || !scopeResolution.scope) {
+    return rejectedPayload(
+      {
+        ...context,
+        rejectionReason: scopeResolution.error ?? "Workflow scope is required.",
+      },
+      scopes,
+      warnings,
+    );
+  }
+
+  const selectedScope = scopeResolution.scope;
+  const effectiveConfig = deps.config ?? emptyHarnessConfig();
+
+  let linearStatuses = deps.linearStatuses ?? [];
+  let modelCatalog = deps.modelCatalog ?? [];
+  let config = deps.config;
+  let catalogLoadMetadata: WorkflowCatalogLoadMetadata =
+    deps.catalogLoadMetadata ?? {
+      statusCatalog: context.mode === "fixture" ? "loaded" : "unavailable",
+      modelCatalog: context.mode === "fixture" ? "loaded" : "unavailable",
+    };
+
+  if (context.mode === "fixture" && context.fixtureId) {
+    const fixture = getFixtureDefinition(context.fixtureId as WorkflowFixtureId);
+    linearStatuses = fixture.statuses;
+    modelCatalog = fixture.modelCatalog;
+    config = fixture.config ?? config;
+    if (process.env.P_DEV_OPERATIONS_DEBUG === "1") {
+      warnings.push(...fixture.warnings);
+    }
+    catalogLoadMetadata = { statusCatalog: "loaded", modelCatalog: "loaded" };
+  }
+
+  const statusRecords = enrichStatusRecords({
+    config: effectiveConfig,
+    statuses: linearStatuses,
+    source: context.mode === "fixture" ? "fixture" : "linear-live",
+  });
+  const mappings = buildCurrentWorkflowMappings({
+    config: effectiveConfig,
+    statuses: linearStatuses,
+    source: context.mode === "fixture" ? "fixture" : "linear-live",
+  });
+  const canonicalValidation = buildCanonicalValidation({
+    statuses: linearStatuses,
+    config,
+    catalogLoadMetadata,
+  });
+
+  const plannerSelection = buildWorkflowModelSelection(
+    effectiveConfig,
+    "planner",
+    modelCatalog,
+  );
+  const builderSelection = buildWorkflowModelSelection(
+    effectiveConfig,
+    "builder",
+    modelCatalog,
+  );
+  const modelSaveReadiness = buildModelSaveReadiness({
+    plannerSelection,
+    builderSelection,
+    modelCatalog,
+    catalogLoaded: catalogLoadMetadata.modelCatalog === "loaded",
+  });
+
+  const healthState = deriveWorkflowHealthState({
+    catalogLoadMetadata,
+    canonicalValidation,
+  });
+
+  return {
+    sourceMode: context.mode,
+    fixtureId: context.fixtureId,
+    selectedScopeId: selectedScope.id,
+    scopes,
+    debugEnabled: deps.debugEnabled ?? false,
+    dataSourceLabel: dataSourceLabel(context),
+    statuses: statusRecords,
+    currentWorkflowMappings: mappings,
+    modelCatalog,
+    catalogLoadMetadata,
+    plannerSelection,
+    builderSelection,
+    configFingerprint:
+      deps.configFingerprint ?? buildConfigFingerprint(config),
+    modelSaveReadiness,
+    canonicalWorkflow: {
+      healthState,
+      violations: canonicalValidation?.violations ?? [],
+      informationalWarnings: canonicalValidation?.informationalWarnings ?? [],
+      resolvedStatusIds: Object.fromEntries(
+        Object.entries(canonicalValidation?.resolvedStatuses ?? {}).map(
+          ([key, value]) => [key, value.id],
+        ),
+      ),
+      mergePathVariant:
+        selectedScope.baseBranch === selectedScope.productionBranch
+          ? "direct-production"
+          : "integration-then-production",
+    },
+    warnings,
+  };
+}
+
+function rejectedPayload(
+  context: WorkflowSourceContext,
+  scopes: WorkflowScope[],
+  warnings: string[],
+): WorkflowBootstrapPayload {
+  const emptyConfig = emptyHarnessConfig();
+  const plannerSelection = buildWorkflowModelSelection(emptyConfig, "planner", []);
+  const builderSelection = buildWorkflowModelSelection(emptyConfig, "builder", []);
+
+  return {
+    sourceMode: context.mode,
+    fixtureId: context.fixtureId,
+    selectedScopeId: undefined,
+    scopes,
+    debugEnabled: false,
+    dataSourceLabel: dataSourceLabel(context),
+    statuses: [],
+    currentWorkflowMappings: [],
+    modelCatalog: [],
+    catalogLoadMetadata: {
+      statusCatalog: "unavailable",
+      modelCatalog: "unavailable",
+    },
+    plannerSelection,
+    builderSelection,
+    configFingerprint: buildConfigFingerprint(undefined),
+    modelSaveReadiness: buildModelSaveReadiness({
+      plannerSelection,
+      builderSelection,
+      modelCatalog: [],
+      catalogLoaded: false,
+    }),
+    canonicalWorkflow: {
+      healthState: "linear-unavailable",
+      violations: [],
+      informationalWarnings: [],
+      resolvedStatusIds: {},
+      mergePathVariant: "direct-production",
+    },
+    warnings,
+  };
+}
+
+export { buildWorkflowFingerprint } from "./current-workflow.js";

package/workspace-snapshot/files/src/workflow-page/catalog-validation.ts

@@ -0,0 +1,158 @@
+import type { RoleModelRole } from "../config/role-models.js";
+import { lookupModelInCatalog } from "./model-catalog-lookup.js";
+import type {
+  ModelSaveReadiness,
+  WorkflowModelCatalogEntry,
+  WorkflowModelSelection,
+  WorkflowRoleModelSaveReadiness,
+} from "./types.js";
+
+export interface ModelSaveSelectionInput {
+  modelId: string;
+  parameters: Array<{ id: string; value: string }>;
+}
+
+export interface ModelSaveValidationResult {
+  valid: boolean;
+  issues: string[];
+  state: WorkflowRoleModelSaveReadiness["state"];
+}
+
+function validateParameterValue(input: {
+  parameterId: string;
+  value: string;
+  definition: WorkflowModelCatalogEntry["supportedParameters"][number];
+}): string | undefined {
+  const { parameterId, value, definition } = input;
+  if (definition.type === "boolean") {
+    if (value !== "true" && value !== "false") {
+      return `Parameter "${parameterId}" must be "true" or "false".`;
+    }
+    return undefined;
+  }
+
+  if (definition.allowedValues?.length) {
+    if (!definition.allowedValues.includes(value)) {
+      return `Parameter "${parameterId}" value "${value}" is not allowed. Expected one of: ${definition.allowedValues.join(", ")}.`;
+    }
+  }
+
+  return undefined;
+}
+
+export function validateModelSelectionAgainstCatalog(input: {
+  role: RoleModelRole;
+  selection: ModelSaveSelectionInput;
+  modelCatalog: WorkflowModelCatalogEntry[];
+  catalogLoaded: boolean;
+}): WorkflowRoleModelSaveReadiness {
+  const issues: string[] = [];
+
+  if (!input.catalogLoaded) {
+    return {
+      role: input.role,
+      ready: false,
+      state: "catalog-unavailable",
+      issues: [
+        "Model catalog is unavailable, so model selections cannot be validated for save.",
+      ],
+    };
+  }
+
+  const model = lookupModelInCatalog(input.modelCatalog, input.selection.modelId);
+  if (!model || model.availability !== "available") {
+    issues.push(
+      `Model "${input.selection.modelId}" is unavailable in the current catalog.`,
+    );
+    return {
+      role: input.role,
+      ready: false,
+      state: "invalid-model",
+      issues,
+    };
+  }
+
+  let hasInvalidParameter = false;
+  for (const parameter of input.selection.parameters) {
+    const definition = model.supportedParameters.find(
+      (entry) => entry.id === parameter.id,
+    );
+    if (!definition) {
+      issues.push(`Model parameter "${parameter.id}" is not supported.`);
+      hasInvalidParameter = true;
+      continue;
+    }
+
+    const valueIssue = validateParameterValue({
+      parameterId: parameter.id,
+      value: parameter.value,
+      definition,
+    });
+    if (valueIssue) {
+      issues.push(valueIssue);
+      hasInvalidParameter = true;
+    }
+  }
+
+  if (hasInvalidParameter) {
+    return {
+      role: input.role,
+      ready: false,
+      state: "invalid-parameter",
+      issues,
+    };
+  }
+
+  return {
+    role: input.role,
+    ready: true,
+    state: "ready",
+    issues,
+  };
+}
+
+export function buildModelSaveReadiness(input: {
+  plannerSelection: WorkflowModelSelection;
+  builderSelection: WorkflowModelSelection;
+  modelCatalog: WorkflowModelCatalogEntry[];
+  catalogLoaded: boolean;
+}): ModelSaveReadiness {
+  const planner = validateModelSelectionAgainstCatalog({
+    role: "planner",
+    selection: {
+      modelId: input.plannerSelection.modelId,
+      parameters: input.plannerSelection.parameters,
+    },
+    modelCatalog: input.modelCatalog,
+    catalogLoaded: input.catalogLoaded,
+  });
+  const builder = validateModelSelectionAgainstCatalog({
+    role: "builder",
+    selection: {
+      modelId: input.builderSelection.modelId,
+      parameters: input.builderSelection.parameters,
+    },
+    modelCatalog: input.modelCatalog,
+    catalogLoaded: input.catalogLoaded,
+  });
+
+  return {
+    planner,
+    builder,
+    ready: planner.ready && builder.ready,
+  };
+}
+
+export function validateModelSavePayload(input: {
+  role: RoleModelRole;
+  selection: ModelSaveSelectionInput;
+  modelCatalog: WorkflowModelCatalogEntry[];
+  catalogLoaded: boolean;
+}): ModelSaveValidationResult {
+  const readiness = validateModelSelectionAgainstCatalog(input);
+  return {
+    valid: readiness.ready,
+    issues: readiness.issues,
+    state: readiness.state,
+  };
+}

package/workspace-snapshot/files/src/workflow-page/constants.ts

@@ -0,0 +1,22 @@
+export const P_DEV_WORKFLOW_FIXTURES_ENV = "P_DEV_WORKFLOW_FIXTURES";
+
+/** Browser matrix tests still opt in via the operations env name. */
+export const P_DEV_OPERATIONS_FIXTURES_ENV = "P_DEV_OPERATIONS_FIXTURES";
+
+export const WORKFLOW_FIXTURE_IDS = [
+  "basic-current-workflow",
+  "branching-pr-review",
+  "empty-linear-statuses",
+  "credential-errors",
+  "hundred-node-performance",
+  "canonical-case-rename",
+  "canonical-wrong-category",
+  "canonical-whitespace-name",
+  "canonical-plan-review-present",
+] as const;
+
+export type WorkflowFixtureId = (typeof WORKFLOW_FIXTURE_IDS)[number];
+
+export function isWorkflowFixtureId(value: string): value is WorkflowFixtureId {
+  return (WORKFLOW_FIXTURE_IDS as readonly string[]).includes(value);
+}

package/workspace-snapshot/files/src/workflow-page/current-workflow.ts

@@ -0,0 +1,225 @@
+import {
+  DEPRECATED_STATUS_NAMES,
+  getDispatchTriggerStatuses,
+  isDispatchTriggerStatusName,
+  lookupRequiredStatus,
+} from "../setup/linear-status-contract.js";
+import { lookupCanonicalStatusByExactName } from "../workflow/canonical-product-development-workflow.js";
+import {
+  getEligibleHandoffStatuses,
+  getEligibleImplementationStatuses,
+  getEligibleMergeStatuses,
+  getEligiblePlanningStatuses,
+  getEligibleRevisionStatuses,
+  getTransitionalStatus,
+} from "../config/status-names.js";
+import type { HarnessConfig } from "../config/types.js";
+import type {
+  WorkflowCurrentWorkflowMapping,
+  WorkflowStatusRecord,
+} from "./types.js";
+
+export interface LinearStatusInput {
+  id: string;
+  name: string;
+  type: string;
+  color?: string;
+}
+
+export interface CurrentWorkflowContext {
+  config: HarnessConfig;
+  statuses: LinearStatusInput[];
+  source: "linear-live" | "fixture";
+}
+
+function normalizeStatusName(name: string): string {
+  return name.trim().toLowerCase();
+}
+
+function findStatusesByName(
+  statuses: LinearStatusInput[],
+  configuredName: string,
+): LinearStatusInput[] {
+  const normalized = normalizeStatusName(configuredName);
+  return statuses.filter(
+    (status) => normalizeStatusName(status.name) === normalized,
+  );
+}
+
+function buildMapping(
+  mappingKey: string,
+  configuredStatusName: string,
+  statuses: LinearStatusInput[],
+): WorkflowCurrentWorkflowMapping {
+  const matches = findStatusesByName(statuses, configuredStatusName);
+  let state: WorkflowCurrentWorkflowMapping["state"] = "missing";
+  if (matches.length === 1) {
+    state = "resolved";
+  } else if (matches.length > 1) {
+    state = "ambiguous";
+  }
+  return {
+    mappingKey,
+    configuredStatusName,
+    resolvedStatusIds: matches.map((status) => status.id),
+    state,
+  };
+}
+
+export function buildCurrentWorkflowMappings(
+  context: CurrentWorkflowContext,
+): WorkflowCurrentWorkflowMapping[] {
+  const { config, statuses } = context;
+  const mappings: Array<[string, string]> = [
+    ["planning", getEligiblePlanningStatuses(config)[0] ?? "Ready for Planning"],
+    [
+      "implementation",
+      getEligibleImplementationStatuses(config)[0] ?? "Ready for Build",
+    ],
+    ["handoff", getEligibleHandoffStatuses(config)[0] ?? "PR Open"],
+    ["revision", getEligibleRevisionStatuses(config)[0] ?? "Needs Revision"],
+    ["merge", getEligibleMergeStatuses(config)[0] ?? "Ready to Merge"],
+    ["planningInProgress", getTransitionalStatus(config, "planningInProgress")],
+    ["buildingInProgress", getTransitionalStatus(config, "buildingInProgress")],
+    ["prOpen", getTransitionalStatus(config, "prOpen")],
+    ["pmReview", getTransitionalStatus(config, "pmReview")],
+    ["needsRevision", getTransitionalStatus(config, "needsRevision")],
+    ["revisingInProgress", getTransitionalStatus(config, "revisingInProgress")],
+    ["readyToMerge", getTransitionalStatus(config, "readyToMerge")],
+    ["mergingInProgress", getTransitionalStatus(config, "mergingInProgress")],
+    ["mergedToDev", getTransitionalStatus(config, "mergedToDev")],
+    ["mergedDeployed", getTransitionalStatus(config, "mergedDeployed")],
+    ["blocked", getTransitionalStatus(config, "blocked")],
+  ];
+
+  return mappings.map(([key, name]) => buildMapping(key, name, statuses));
+}
+
+function collectMappingKeysForStatus(
+  statusName: string,
+  mappings: WorkflowCurrentWorkflowMapping[],
+): string[] {
+  const normalized = normalizeStatusName(statusName);
+  return mappings
+    .filter(
+      (mapping) =>
+        normalizeStatusName(mapping.configuredStatusName) === normalized,
+    )
+    .map((mapping) => mapping.mappingKey);
+}
+
+function resolveMappingState(
+  statusId: string,
+  statusName: string,
+  mappings: WorkflowCurrentWorkflowMapping[],
+): WorkflowStatusRecord["mappingState"] {
+  const directMatches = mappings.filter((mapping) =>
+    mapping.resolvedStatusIds.includes(statusId),
+  );
+  if (directMatches.length >= 1) {
+    if (directMatches.some((mapping) => mapping.state === "ambiguous")) {
+      return "ambiguous";
+    }
+    if (directMatches.some((mapping) => mapping.state === "missing")) {
+      return "missing";
+    }
+    return "resolved";
+  }
+
+  const nameMatches = mappings.filter(
+    (mapping) =>
+      normalizeStatusName(mapping.configuredStatusName) ===
+      normalizeStatusName(statusName),
+  );
+  if (nameMatches.some((mapping) => mapping.state === "ambiguous")) {
+    return "ambiguous";
+  }
+  if (nameMatches.some((mapping) => mapping.state === "missing")) {
+    return "missing";
+  }
+  if (nameMatches.length > 0) {
+    return "unmapped";
+  }
+  return "unmapped";
+}
+
+export function enrichStatusRecords(
+  context: CurrentWorkflowContext,
+): WorkflowStatusRecord[] {
+  const mappings = buildCurrentWorkflowMappings(context);
+  const dispatchTriggers = new Set(
+    getDispatchTriggerStatuses().map((name) => normalizeStatusName(name)),
+  );
+  const deprecated = new Set(
+    DEPRECATED_STATUS_NAMES.map((name) => normalizeStatusName(name)),
+  );
+
+  const nameCounts = new Map<string, number>();
+  for (const status of context.statuses) {
+    const key = normalizeStatusName(status.name);
+    nameCounts.set(key, (nameCounts.get(key) ?? 0) + 1);
+  }
+
+  return context.statuses.map((status) => {
+    const required = lookupRequiredStatus(status.name);
+    const canonical = lookupCanonicalStatusByExactName(status.name);
+    const normalizedName = normalizeStatusName(status.name);
+    const mappingKeys = collectMappingKeysForStatus(status.name, mappings);
+    const participates =
+      Boolean(required) ||
+      mappingKeys.length > 0 ||
+      isDispatchTriggerStatusName(status.name) ||
+      dispatchTriggers.has(normalizedName);
+
+    let mappingState = resolveMappingState(status.id, status.name, mappings);
+    if ((nameCounts.get(normalizedName) ?? 0) > 1) {
+      mappingState = "ambiguous";
+    }
+    if (deprecated.has(normalizedName)) {
+      mappingState = mappingState === "resolved" ? "ambiguous" : mappingState;
+    }
+
+    return {
+      id: status.id,
+      name: status.name,
+      category: status.type,
+      color: status.color,
+      source: context.source,
+      requiredWorkflowRole: required?.role,
+      participatesInCurrentHarnessWorkflow: participates,
+      automationTriggerStatus: isDispatchTriggerStatusName(status.name),
+      currentMappingKeys: mappingKeys,
+      mappingState,
+      canonicalStatusKey:
+        canonical && canonical.category === status.type ? canonical.key : undefined,
+    };
+  });
+}
+
+export function buildWorkflowFingerprint(
+  mappings: WorkflowCurrentWorkflowMapping[],
+): string {
+  return JSON.stringify(
+    mappings.map((mapping) => ({
+      key: mapping.mappingKey,
+      name: mapping.configuredStatusName,
+      ids: [...mapping.resolvedStatusIds].sort(),
+      state: mapping.state,
+    })),
+  );
+}
+
+export function findDuplicateNormalizedNames(
+  statuses: LinearStatusInput[],
+): string[] {
+  const groups = new Map<string, string[]>();
+  for (const status of statuses) {
+    const key = normalizeStatusName(status.name);
+    const list = groups.get(key) ?? [];
+    list.push(status.name);
+    groups.set(key, list);
+  }
+  return [...groups.entries()]
+    .filter(([, names]) => names.length > 1)
+    .map(([key]) => key);
+}

package/workspace-snapshot/files/src/workflow-page/fingerprint.ts

@@ -0,0 +1,9 @@
+import { createHash } from "node:crypto";
+
+export function hashOperationsFingerprint(value: unknown): string {
+  return createHash("sha256")
+    .update(JSON.stringify(value))
+    .digest("hex");
+}
+
+export const hashWorkflowFingerprint = hashOperationsFingerprint;

package/workspace-snapshot/files/src/workflow-page/fixture-definition.ts

@@ -0,0 +1,16 @@
+import type { HarnessConfig } from "../config/types.js";
+import type { WorkflowFixtureId } from "./constants.js";
+import type {
+  WorkflowModelCatalogEntry,
+  WorkflowScope,
+} from "./types.js";
+import type { LinearStatusInput } from "./current-workflow.js";
+
+export interface WorkflowFixtureDefinition {
+  id: WorkflowFixtureId;
+  statuses: LinearStatusInput[];
+  modelCatalog: WorkflowModelCatalogEntry[];
+  workflowScopes: WorkflowScope[];
+  config?: HarnessConfig;
+  warnings: string[];
+}